idun-agent-engine 0.3.4__py3-none-any.whl

idun_agent_engine-0.3.4.dist-info/METADATA

@@ -0,0 +1,335 @@
+Metadata-Version: 2.4
+Name: idun-agent-engine
+Version: 0.3.4
+Summary: Python SDK and runtime to serve AI agents with FastAPI, LangGraph, and observability.
+Project-URL: Homepage, https://github.com/geoffreyharrazi/idun-agent-platform
+Project-URL: Repository, https://github.com/geoffreyharrazi/idun-agent-platform
+Project-URL: Documentation, https://github.com/geoffreyharrazi/idun-agent-platform/tree/main/libs/idun_agent_engine
+Project-URL: Issues, https://github.com/geoffreyharrazi/idun-agent-platform/issues
+Author-email: Geoffrey HARRAZI <geoffreyharrazi@gmail.com>
+License-Expression: MIT
+Keywords: agents,fastapi,langgraph,llm,observability,sdk
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: <3.14,>=3.12
+Requires-Dist: ag-ui-adk<0.4.0,>=0.3.4
+Requires-Dist: ag-ui-langgraph<0.1.0,>=0.0.20
+Requires-Dist: ag-ui-protocol<0.2.0,>=0.1.8
+Requires-Dist: aiosqlite<0.22.0,>=0.21.0
+Requires-Dist: arize-phoenix-otel<1.0.0,>=0.2.0
+Requires-Dist: arize-phoenix<12.0.0,>=11.22.0
+Requires-Dist: click>=8.2.0
+Requires-Dist: copilotkit<0.2.0,>=0.1.72
+Requires-Dist: deepagents<1.0.0,>=0.2.8
+Requires-Dist: fastapi<0.116.0,>=0.115.0
+Requires-Dist: google-adk<2.0.0,>=1.19.0
+Requires-Dist: google-cloud-logging<4.0.0,>=3.10.0
+Requires-Dist: guardrails-ai<0.8.0,>=0.7.0
+Requires-Dist: httpx<0.29.0,>=0.28.1
+Requires-Dist: idun-agent-schema<1.0.0,>=0.3.1
+Requires-Dist: langchain-core<2.0.0,>=1.0.0
+Requires-Dist: langchain-google-vertexai<4.0.0,>=2.0.27
+Requires-Dist: langchain-mcp-adapters<0.2.0,>=0.1.0
+Requires-Dist: langchain<2.0.0,>=1.0.0
+Requires-Dist: langfuse-haystack>=2.3.0
+Requires-Dist: langfuse<4.0.0,>=2.60.8
+Requires-Dist: langgraph-checkpoint-postgres<4.0.0,>=3.0.0
+Requires-Dist: langgraph-checkpoint-sqlite<4.0.0,>=3.0.0
+Requires-Dist: langgraph<2.0.0,>=1.0.0
+Requires-Dist: mcp<2.0.0,>=1.0.0
+Requires-Dist: openinference-instrumentation-google-adk<1.0.0,>=0.1.0
+Requires-Dist: openinference-instrumentation-guardrails<1.0.0,>=0.1.0
+Requires-Dist: openinference-instrumentation-langchain<1.0.0,>=0.1.13
+Requires-Dist: openinference-instrumentation-mcp<2.0.0,>=1.0.0
+Requires-Dist: openinference-instrumentation-vertexai<1.0.0,>=0.1.0
+Requires-Dist: opentelemetry-exporter-gcp-trace<2.0.0,>=1.6.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http<2.0.0,>=1.22.0
+Requires-Dist: pydantic<3.0.0,>=2.11.7
+Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: sqlalchemy<3.0.0,>=2.0.36
+Requires-Dist: streamlit<2.0.0,>=1.47.1
+Requires-Dist: tavily-python<0.8.0,>=0.7.9
+Requires-Dist: uvicorn<0.36.0,>=0.35.0
+Description-Content-Type: text/markdown
+
+# Idun Agent Engine
+
+Turn any LangGraph-based agent into a production-grade API in minutes.
+
+Idun Agent Engine is a lightweight runtime and SDK that wraps your agent with a FastAPI server, adds streaming, structured responses, config validation, and optional observability — with zero boilerplate. Use a YAML file or a fluent builder to configure and run.
+
+## Installation
+
+```bash
+pip install idun-agent-engine
+```
+
+- Requires Python 3.13
+- Ships with FastAPI, Uvicorn, LangGraph, SQLite checkpointing, and optional observability hooks
+
+## Quickstart
+
+### 1) Minimal one-liner (from a YAML config)
+
+```python
+from idun_agent_engine.core.server_runner import run_server_from_config
+
+run_server_from_config("config.yaml")
+```
+
+Example `config.yaml`:
+
+```yaml
+server:
+  api:
+    port: 8000
+
+agent:
+  type: "langgraph"
+  config:
+    name: "My Example LangGraph Agent"
+    graph_definition: "./examples/01_basic_config_file/example_agent.py:app"
+    # Optional: conversation persistence
+    checkpointer:
+      type: "sqlite"
+      db_url: "sqlite:///example_checkpoint.db"
+    # Optional: provider-agnostic observability
+    observability:
+      provider: langfuse   # or phoenix
+      enabled: true
+      options:
+        host: ${LANGFUSE_HOST}
+        public_key: ${LANGFUSE_PUBLIC_KEY}
+        secret_key: ${LANGFUSE_SECRET_KEY}
+        run_name: "idun-langgraph-run"
+```
+
+Run and open docs at `http://localhost:8000/docs`.
+
+### 2) Programmatic setup with the fluent builder
+
+```python
+from pathlib import Path
+from idun_agent_engine import ConfigBuilder, create_app, run_server
+
+config = (
+    ConfigBuilder()
+    .with_api_port(8000)
+    .with_langgraph_agent(
+        name="Programmatic Example Agent",
+        graph_definition=str(Path("./examples/02_programmatic_config/smart_agent.py:app")),
+        sqlite_checkpointer="programmatic_example.db",
+    )
+    .build()
+)
+
+app = create_app(engine_config=config)
+run_server(app, reload=True)
+```
+
+## Endpoints
+
+All servers expose these by default:
+
+- POST `/agent/invoke`: single request/response
+- POST `/agent/stream`: server-sent events stream of `ag-ui` protocol events
+- GET `/health`: service health with engine version
+- GET `/`: root landing with links
+
+Invoke example:
+
+```bash
+curl -X POST "http://localhost:8000/agent/invoke" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "Hello!", "session_id": "user-123"}'
+```
+
+Stream example:
+
+```bash
+curl -N -X POST "http://localhost:8000/agent/stream" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "Tell me a story", "session_id": "user-123"}'
+```
+
+## LangGraph integration
+
+Point the engine to a `StateGraph` variable in your file using `graph_definition`:
+
+```python
+# examples/01_basic_config_file/example_agent.py
+import operator
+from typing import Annotated, TypedDict
+from langgraph.graph import END, StateGraph
+
+class AgentState(TypedDict):
+    messages: Annotated[list, operator.add]
+
+def greeting_node(state):
+    user_message = state["messages"][-1] if state["messages"] else ""
+    return {"messages": [("ai", f"Hello! You said: '{user_message}'")]}
+
+graph = StateGraph(AgentState)
+graph.add_node("greet", greeting_node)
+graph.set_entry_point("greet")
+graph.add_edge("greet", END)
+
+# This variable name is referenced by graph_definition
+app = graph
+```
+
+Then reference it in config:
+
+```yaml
+agent:
+  type: "langgraph"
+  config:
+    graph_definition: "./examples/01_basic_config_file/example_agent.py:app"
+```
+
+Behind the scenes, the engine:
+
+- Validates config with Pydantic models
+- Loads your `StateGraph` from disk
+- Optionally wires a SQLite checkpointer via `langgraph.checkpoint.sqlite`
+- Exposes `invoke` and `stream` endpoints
+- Bridges LangGraph events to `ag-ui` stream events
+
+## Observability (optional)
+
+Enable provider-agnostic observability via the `observability` block in your agent config. Today supports Langfuse and Arize Phoenix (OpenInference) patterns; more coming soon.
+
+```yaml
+agent:
+  type: "langgraph"
+  config:
+    observability:
+      provider: langfuse   # or phoenix
+      enabled: true
+      options:
+        host: ${LANGFUSE_HOST}
+        public_key: ${LANGFUSE_PUBLIC_KEY}
+        secret_key: ${LANGFUSE_SECRET_KEY}
+        run_name: "idun-langgraph-run"
+```
+
+## Configuration reference
+
+- `server.api.port` (int): HTTP port (default 8000)
+- `agent.type` (enum): currently `langgraph` (CrewAI placeholder exists but not implemented)
+- `agent.config.name` (str): human-readable name
+- `agent.config.graph_definition` (str): absolute or relative `path/to/file.py:variable`
+- `agent.config.checkpointer` (sqlite): `{ type: "sqlite", db_url: "sqlite:///file.db" }`
+- `agent.config.observability` (optional): provider options as shown above
+- `mcp_servers` (list, optional): collection of MCP servers that should be available to your agent runtime. Each entry matches the fields supported by `langchain-mcp-adapters` (name, transport, url/command, headers, etc.).
+
+Config can be sourced by:
+
+- `engine_config` (preferred): pass a validated `EngineConfig` to `create_app`
+- `config_dict`: dict validated at runtime
+- `config_path`: path to YAML; defaults to `config.yaml`
+
+### MCP Servers
+
+You can mount MCP servers directly in your engine config. The engine will automatically
+create a `MultiServerMCPClient` and expose it on `app.state.mcp_registry`.
+
+```yaml
+mcp_servers:
+  - name: "math"
+    transport: "stdio"
+    command: "python"
+    args:
+      - "/path/to/math_server.py"
+  - name: "weather"
+    transport: "streamable_http"
+    url: "http://localhost:8000/mcp"
+```
+
+Inside your FastAPI dependencies or handlers:
+
+```python
+from idun_agent_engine.server.dependencies import get_mcp_registry
+
+@router.get("/mcp/{server}/tools")
+async def list_tools(server: str, registry = Depends(get_mcp_registry)):
+    return await registry.get_tools(server)
+```
+
+Or outside of FastAPI:
+
+```python
+from langchain_mcp_adapters.tools import load_mcp_tools
+
+registry = app.state.mcp_registry
+async with registry.get_session("math") as session:
+    tools = await load_mcp_tools(session)
+```
+
+## Examples
+
+The `examples/` folder contains complete projects:
+
+- `01_basic_config_file`: YAML config + simple agent
+- `02_programmatic_config`: `ConfigBuilder` usage and advanced flows
+- `03_minimal_setup`: one-line server from config
+
+Run any example with Python 3.13 installed.
+
+## CLI and runtime helpers
+
+Top-level imports for convenience:
+
+```python
+from idun_agent_engine import (
+  create_app,
+  run_server,
+  run_server_from_config,
+  run_server_from_builder,
+  ConfigBuilder,
+)
+```
+
+- `create_app(...)` builds the FastAPI app and registers routes
+- `run_server(app, ...)` runs with Uvicorn
+- `run_server_from_config(path, ...)` loads config, builds app, and runs
+- `run_server_from_builder(builder, ...)` builds from a builder and runs
+
+## Production notes
+
+- Use a process manager (e.g., multiple Uvicorn workers behind a gateway). Note: `reload=True` is for development and incompatible with multi-worker mode.
+- Mount behind a reverse proxy and enable TLS where appropriate.
+- Persist conversations using the SQLite checkpointer in production or replace with a custom checkpointer when available.
+
+## Roadmap
+
+- CrewAI adapter (placeholder exists, not yet implemented)
+- Additional stores and checkpointers
+- First-class CLI for `idun` commands
+
+## Contributing
+
+Issues and PRs are welcome. See the repository:
+
+- Repo: `https://github.com/geoffreyharrazi/idun-agent-platform`
+- Package path: `libs/idun_agent_engine`
+- Open an issue: `https://github.com/geoffreyharrazi/idun-agent-platform/issues`
+
+Run locally:
+
+```bash
+cd libs/idun_agent_engine
+poetry install
+poetry run pytest -q
+```
+
+## License
+
+MIT — see `LICENSE` in the repo root.

idun_agent_engine-0.3.4.dist-info/RECORD

@@ -0,0 +1,60 @@
+idun_agent_engine/__init__.py,sha256=PhOL6foq5V0eXaoXw7xKUeCWXIWrOHrAFB8OuJnBqyM,550
+idun_agent_engine/_version.py,sha256=Z-hDh5-bBX3-YmjcPv65QOTgYe4majrXwcs240OhBY8,72
+idun_agent_engine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idun_agent_engine/agent/__init__.py,sha256=foyOoRdI_04q1b6f2A5EXEpWSCKjZxpgWMWrKcsHNl8,220
+idun_agent_engine/agent/base.py,sha256=c-3gljSHQpm6aY0JNDmXkaPtcW55rXdsI8Cgv9l4bCs,3294
+idun_agent_engine/agent/adk/__init__.py,sha256=jLV2Z9qQGZtBpF_0pQI1FRCPJ_J1G3Z6cEAzHnQyuu4,83
+idun_agent_engine/agent/adk/adk.py,sha256=29YC5rgLjdod-CU3a2JqgAvzYcD5u2EY7pylozGNi9c,11375
+idun_agent_engine/agent/haystack/__init__.py,sha256=y5ADrD8gWBeYIvV7tmu6OpPdJ8POHt-tyraIL7RkkWI,179
+idun_agent_engine/agent/haystack/haystack.py,sha256=k4NAx_zTBO9uiExM9NtuDAN94H1lrCWtHf1GEWEN16g,10966
+idun_agent_engine/agent/haystack/haystack_model.py,sha256=EtOYnsWRufcrQufTRMeB3V-rZVQqfnmwKwPsYGfZdCs,362
+idun_agent_engine/agent/haystack/utils.py,sha256=sKRoPhzZWFw1NPsYwCockafzMBCCq3lGOrndbNE_C3M,609
+idun_agent_engine/agent/langgraph/__init__.py,sha256=CoBdkp9P4livdy5B0bvj9o7ftoqKmXEr9cZv4TZLncs,107
+idun_agent_engine/agent/langgraph/langgraph.py,sha256=vM5ppt0s_2izzZVbVXXGXGCVUGSN-GZhvQ5-6YbOgVM,22904
+idun_agent_engine/core/__init__.py,sha256=F0DMDlWcSWS_1dvh3xMbrdcVvZRHVnoAFFgREuSJfBI,408
+idun_agent_engine/core/app_factory.py,sha256=XiLrctFT_n8LP3flKFwJoJDbiWPiw98N9lbkpR8P1O0,2597
+idun_agent_engine/core/config_builder.py,sha256=Q6f7lITqIHFlAfXEIfQvz_6s_GVFc4zVotOFF_YTFho,25641
+idun_agent_engine/core/engine_config.py,sha256=IR8WhbenDstNSL7ORrUW8AnzgS3exFQxtwip66pFhcM,545
+idun_agent_engine/core/server_runner.py,sha256=vLlgLQM-xyvFgJMgFW2eWZoN1oc0x9FGL6bH8WsF6O8,4897
+idun_agent_engine/guardrails/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idun_agent_engine/guardrails/base.py,sha256=vC554AbqOup9qjuOaTfG-w3fnd73J_7goMwab63jcIg,792
+idun_agent_engine/guardrails/guardrails_hub/guardrails_hub.py,sha256=7fCFoL8soXVkFW6p-TUD6XyR5x3j3I2ekofUG__sXu8,3396
+idun_agent_engine/guardrails/guardrails_hub/utils.py,sha256=bC6-MsCVF7xKTr48z7OzJJUeWvqAB7BiHeNTiKsme70,20
+idun_agent_engine/mcp/__init__.py,sha256=tsX4sJa7UZD-lr8O1acMwDrdDWJc_hMlB9IrX1NH8Wk,255
+idun_agent_engine/mcp/helpers.py,sha256=aFiLlk63pifBjGgctREFWxuSbb-um6QDOVpyikQ5NJ0,3224
+idun_agent_engine/mcp/registry.py,sha256=K9-OLF_7FoKmyrwi65i6E3goZROHLRgISlF1yPwkEm8,3996
+idun_agent_engine/observability/__init__.py,sha256=DCtK6b3xiX4dh0_8GBDOcSXQdcIJz2wTqqPa_ZFAES4,430
+idun_agent_engine/observability/base.py,sha256=C6mY_ZafDEHkMz8_ZeaEh--pyYuzJYEUqhoJ0sVP2wY,5570
+idun_agent_engine/observability/gcp_logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idun_agent_engine/observability/gcp_logging/gcp_logging_handler.py,sha256=cMUKfukmSZhIdO2v5oWkqI2_c6umtYqlhzflnOeoq6A,1685
+idun_agent_engine/observability/gcp_trace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idun_agent_engine/observability/gcp_trace/gcp_trace_handler.py,sha256=YBlUqUwPuOPi0yDNEy9x_g52nJBlSe9a0EEHDIHIr68,3898
+idun_agent_engine/observability/langfuse/__init__.py,sha256=J8XcHV4aT1pF97k5EZiqrnYYPs9VjwfV5rUMihc5Pgk,128
+idun_agent_engine/observability/langfuse/langfuse_handler.py,sha256=RP9MXiYDRe7zWTmZmzQBn6AjRn0y8jrBnWOaUUaMxNA,2795
+idun_agent_engine/observability/phoenix/__init__.py,sha256=tEwJYijcvSGNhFW4QJmvBcTu1D0YVJkZRTmkNCGTteM,130
+idun_agent_engine/observability/phoenix/phoenix_handler.py,sha256=lGqSq-L1vmoEhAr9rbWO3KlNX5HSgBhCKESHMdZ-AfY,2539
+idun_agent_engine/observability/phoenix_local/__init__.py,sha256=m9dIw1GWGKAW4wP08jxA7j4yrOg0Nxq_08bwVh8YogE,146
+idun_agent_engine/observability/phoenix_local/phoenix_local_handler.py,sha256=wjOZuMpAxdD5D33rzxycNEzFMunETpPnYjiHjbjz5GA,4252
+idun_agent_engine/server/__init__.py,sha256=WaFektUsy37bNg2niAUy_TykzStukgWPnxC-t49CEwo,177
+idun_agent_engine/server/dependencies.py,sha256=MVH8STOQ8wu-iYE_28y5dvw5FGT5PX0uQl0ldkpxw6Y,2080
+idun_agent_engine/server/lifespan.py,sha256=whWv7Gsl3CI_C13vWxl4wODOzlxIPRKSe58-_8B4zI8,3840
+idun_agent_engine/server/server_config.py,sha256=RYA7Y0c5aRw_WXaX8svFUIEtTPqzn3o-WQRm2p52C6g,213
+idun_agent_engine/server/routers/__init__.py,sha256=BgNzSVvHtGPGn5zhXhomwpKlDYBkeFi7xCbdcWVOgc8,102
+idun_agent_engine/server/routers/agent.py,sha256=HQkPRYFE5CadpzEQ3La8kK7lt5QUVuZTk-rzhZg9EsU,8995
+idun_agent_engine/server/routers/agui.py,sha256=Z1G4fuo57MazQWfp7ao8QZ1or2H9BXLS_JB1nFPXAkE,1891
+idun_agent_engine/server/routers/base.py,sha256=wICOXCokCIRjmHuDPDTWqeXqOVPes1CtDtiR_HvtsF0,3756
+idun_agent_engine/templates/__init__.py,sha256=xxbJZXaX6VEm_UrqzAOQcuujpEji5yqYzwQfwiqig8o,31
+idun_agent_engine/templates/correction.py,sha256=qApH4W99K31maxNrGf0hPVe_Wd4xjYjJrEKlu7PbRpw,1823
+idun_agent_engine/templates/deep_research.py,sha256=j4WypBkBz7V3EG-U8vawfNXDNhcCf2QiEK0veI4M68s,1077
+idun_agent_engine/templates/translation.py,sha256=vjp1yEyhDMFO4nEbq5WG7LAA7nLrhVAjznOkV7ob_Ss,2149
+idun_platform_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idun_platform_cli/main.py,sha256=jWL7Ob0p4KdRUqgPTP_EB68n7z2LyMKC2DeUsfWlBO4,200
+idun_platform_cli/groups/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idun_platform_cli/groups/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idun_platform_cli/groups/agent/main.py,sha256=QMGQi3JZ76SeFI3miIjVWpMt0L-hGz5FwxtTPQX4-Uw,301
+idun_platform_cli/groups/agent/package.py,sha256=LdIFAcfrlUcCssmSliYQIi0NFMuVkpx6t8WhMHATan8,2525
+idun_platform_cli/groups/agent/serve.py,sha256=2AbL0G1WqR33jlyiGaNvAoPZ3G1o52KYUptz_HaAjIg,3863
+idun_agent_engine-0.3.4.dist-info/METADATA,sha256=7avxM1HbAMGe_e_Baxb148Vwa24Y7VUXe6CLcEtMx8U,10648
+idun_agent_engine-0.3.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+idun_agent_engine-0.3.4.dist-info/entry_points.txt,sha256=XG3oxlSOaCrYKT1oyhKa0Ag1iJPMZ-WF6gaV_mzIJW4,52
+idun_agent_engine-0.3.4.dist-info/RECORD,,

idun_agent_engine-0.3.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

idun_agent_engine-0.3.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+idun = idun_platform_cli.main:cli

idun_platform_cli/groups/agent/main.py

@@ -0,0 +1,16 @@
+"""Manage, Deploy and package agents."""
+
+import click
+
+from .package import package_command
+from .serve import serve_command
+
+
+@click.group()
+def agent():
+    """Agent command entrypoint."""
+    pass
+
+
+agent.add_command(serve_command, name="serve")
+agent.add_command(package_command, name="package")

idun_platform_cli/groups/agent/package.py

@@ -0,0 +1,70 @@
+import sys
+from enum import StrEnum
+from pathlib import Path
+
+import click
+
+
+class Dependency(StrEnum):
+    """Dependency Enum."""
+
+    REQUIREMENT = "requirements.txt"
+    PYPROJECT = "pyproject.toml"
+    NONE = "none"
+
+
+def get_dependencies(path: str) -> Dependency:
+    """Verifies if the path folder contains a `requirements.txt` or `pyproject.toml`, and returns which."""
+    """:param path: Path pointing to the agent's folder."""
+    agent_path = Path(path).resolve()
+    if (agent_path / "requirements.txt").exists():
+        return Dependency.REQUIREMENT
+    elif (agent_path / "pyproject.toml").exists():
+        return Dependency.PYPROJECT
+    else:
+        return Dependency.NONE
+
+
+def generate_dockerfile(dependency: Dependency) -> str:
+    # TODO: add envs vars based on source
+    """Generates Dockerfile based on given params."""
+    if dependency == Dependency.NONE:
+        print(
+            "[ERROR]: No pyproject.toml or requirements.txt found. Please make sure to include them."
+        )
+        sys.exit(1)
+        return ""  # Unreachable, but satisfies type checker
+    if dependency == Dependency.REQUIREMENT:
+        # TODO: use from file
+        requirements_dockerfile = f"""FROM python:3.12-slim
+RUN apt-get update && pip install uv
+
+RUN uv pip install idun-agent-schema==0.3.1 --system
+RUN uv pip install idun-agent-engine==0.3.1 --system
+
+COPY . .
+RUN uv pip install -r requirements.txt --system
+
+CMD ["idun", "agent", "serve", "--source=manager"]
+"""
+        return requirements_dockerfile
+    if dependency == Dependency.PYPROJECT:
+        # TODO: implement pyproject.toml support
+        raise NotImplementedError("pyproject.toml support is not yet implemented")
+    raise ValueError(f"Unknown dependency type: {dependency}")
+
+
+@click.command("package")
+@click.argument("path", default=".")
+@click.option("--target", required=False, default=".")
+def package_command(path: str, target: str):
+    """Packages the agent and it's dependencies into a Dockerfile. You can specifiy the input path and the destination. Defaults to current directory."""
+    dependency = get_dependencies(path)
+    dockerfile = generate_dockerfile(dependency)
+    target_path = Path(target)
+    dockerfile_path = target_path / "Dockerfile"
+    try:
+        dockerfile_path.write_text(dockerfile)
+        print(f"Dockerfile generated in {target}")
+    except OSError as e:
+        print(f"[ERROR]: Cannot write dockerfile to path {target}: {e}")

idun_platform_cli/groups/agent/serve.py

@@ -0,0 +1,107 @@
+import os
+import sys
+from enum import StrEnum
+
+import click
+
+from idun_agent_engine.core.app_factory import create_app
+from idun_agent_engine.core.config_builder import ConfigBuilder
+from idun_agent_engine.core.engine_config import EngineConfig
+from idun_agent_engine.core.server_runner import run_server
+
+
+class ServerSource(StrEnum):
+    """Enum for source types."""
+
+    MANAGER = "manager"
+    FILE = "file"
+
+
+class Serve:
+    """Helper class to run the server."""
+
+    def __init__(self, source: ServerSource, path: str | None = None) -> None:
+        self._source: ServerSource = source
+        self._path: str | None = path or None
+
+        if self._source == ServerSource.MANAGER and (
+            not os.getenv("IDUN_AGENT_API_KEY") or not os.getenv("IDUN_MANAGER_HOST")
+        ):
+            print(
+                "[ERROR]: either IDUN_AGENT_API_KEY or IDUN_MANAGER_HOST are not found. Make sure you add them both to your env variables, as `manager` source requires both."
+            )
+            sys.exit(1)
+
+        if self._source == ServerSource.MANAGER:
+            self._url: str = os.environ["IDUN_MANAGER_HOST"]
+            self._agent_api_key: str = os.environ["IDUN_AGENT_API_KEY"]
+
+        self._config: EngineConfig | None = self._resolve_source()
+
+    def _resolve_source(self):
+        """Returns the EngineConfig based on the type of the source."""
+        if self._source == ServerSource.MANAGER:
+            print("Getting the config for the manager...")
+            return self._fetch_from_manager()
+        elif self._source == ServerSource.FILE:
+            print(f"Building config from: {self._path}")
+            return self._fetch_from_path()
+
+    def _fetch_from_path(self) -> EngineConfig | None:
+        try:
+            config = ConfigBuilder().load_from_file(self._path or "")
+            print(f"✅ Successfully fetched and built config from {self._path}")
+            return config
+
+        except Exception as e:
+            raise ValueError(
+                f"[ERROR]: Cannot fetch config from {self._path}: {e} "
+            ) from e
+
+    def _fetch_from_manager(self) -> EngineConfig | None:
+        """Fetches the config from the api."""
+        try:
+            config = (
+                ConfigBuilder()
+                .with_config_from_api(agent_api_key=self._agent_api_key, url=self._url)
+                .build()
+            )
+            print(f"✅ Successfully fetched and built config from {self._url}")
+            return config
+        except Exception as e:
+            print(f"[ERROR]: Cannot fetch config from {self._url}: {e} ")
+            sys.exit(1)
+
+    def serve(self) -> None:
+        """Run the server using the idun engine."""
+        try:
+            app = create_app(engine_config=self._config)
+            run_server(app, port=self._config.server.api.port, reload=False)  # pyright: ignore
+        except Exception as e:
+            raise ValueError(f"[ERROR]: Cannot start the agent server: {e}") from e
+
+
+@click.command("serve")
+@click.option("--source", required=True)
+@click.option("--path")
+def serve_command(source: str, path: str | None):
+    """Reads a config and exposes it's agent as an API. Config is either fetched from the manager, or from a path.
+
+    Note: Fetching from the manager requires env vars: IDUN_AGENT_API_KEY and IDUN_MANAGER_HOST.
+    """
+    match source:
+        case ServerSource.MANAGER:
+            s = Serve(source=source)
+            s.serve()
+
+        case ServerSource.FILE:
+            if not path:
+                print(
+                    "[ERROR]: No config path provided. You need to specify the path of your config.yaml"
+                )
+                sys.exit(1)
+            s = Serve(source=source, path=path)
+            s.serve()
+        case _:
+            print(f"[ERROR]: Argument {source} not recognized.")
+            sys.exit(1)

idun_platform_cli/main.py

@@ -0,0 +1,14 @@
+import click
+from idun_platform_cli.groups.agent.main import agent
+
+
+@click.group()
+def cli():
+    """Entrypoint of the CLI."""
+    pass
+
+
+cli.add_command(agent)
+
+if __name__ == "__main__":
+    cli()