idun-agent-engine 0.1.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

idun_agent_engine-0.2.2.dist-info/METADATA

@@ -0,0 +1,281 @@
+Metadata-Version: 2.4
+Name: idun-agent-engine
+Version: 0.2.2
+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-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.1
+Requires-Dist: fastapi<0.117.0,>=0.116.1
+Requires-Dist: google-adk<2.0.0,>=1.9.0
+Requires-Dist: httpx<0.29.0,>=0.28.1
+Requires-Dist: idun-agent-schema<0.3.0,>=0.2.2
+Requires-Dist: langchain-core<0.4.0,>=0.3.72
+Requires-Dist: langchain-google-vertexai<3.0.0,>=2.0.27
+Requires-Dist: langchain<0.4,>=0.3.27
+Requires-Dist: langfuse-haystack>=2.3.0
+Requires-Dist: langfuse==2.60.8
+Requires-Dist: langgraph-checkpoint-sqlite<3.0.0,>=2.0.11
+Requires-Dist: langgraph<0.7.0,>=0.6.3
+Requires-Dist: openinference-instrumentation-langchain<1.0.0,>=0.1.13
+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: 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
+
+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`
+
+## 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.2.2.dist-info/RECORD

@@ -0,0 +1,43 @@
+idun_agent_engine/__init__.py,sha256=PhOL6foq5V0eXaoXw7xKUeCWXIWrOHrAFB8OuJnBqyM,550
+idun_agent_engine/_version.py,sha256=sutD0vvlsO_-Z21w6GYb8GcWqm_wIsNhNle8EYA9Mgg,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=xzuHIV_P7EwGyK7V2qbFUZccpm5xHaAjAkIxJL4tAwo,2856
+idun_agent_engine/agent/haystack/__init__.py,sha256=y5ADrD8gWBeYIvV7tmu6OpPdJ8POHt-tyraIL7RkkWI,179
+idun_agent_engine/agent/haystack/haystack.py,sha256=6xq7tOlvQxyc2w9KxikpS5S6vmXjUlK9Giwhmzg2X0w,10556
+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=Fm6t-TeG_7s0tJHev5sIbKcD7gLLXv22pJH0S14Hp2k,17412
+idun_agent_engine/cli/__init__.py,sha256=5S_Oo7n7YwKk5VPyqborrRqKVz6lvwODQ5olj70wbnQ,490
+idun_agent_engine/core/__init__.py,sha256=F0DMDlWcSWS_1dvh3xMbrdcVvZRHVnoAFFgREuSJfBI,408
+idun_agent_engine/core/app_factory.py,sha256=fqxX6n4huCAsEY5lzPQPtBb7nWWaxzvhYaPsRUbZuEY,2333
+idun_agent_engine/core/config_builder.py,sha256=nqlFEASHN9zlZhUnu5NAhRo2DeFkFVQ0rpx-yfnBuIw,16283
+idun_agent_engine/core/engine_config.py,sha256=pHa-qiYUS7mvzW2eb6sXJoxxJCxC5fwcNUTcqiO90c0,584
+idun_agent_engine/core/server_runner.py,sha256=01_aAJC-s0C5fdkEUQzwk4Vlf1SX4lsZwRTkVaJx0VE,4898
+idun_agent_engine/observability/__init__.py,sha256=Jei-E8SgYulxFu5HkJz9HfcorIfQ6O7WZWGzP41ZK-4,298
+idun_agent_engine/observability/base.py,sha256=uVCptXKmU_8OAvLRZliK5RqG6fOxj3a3bg18GVGMeHU,3575
+idun_agent_engine/observability/langfuse/__init__.py,sha256=J8XcHV4aT1pF97k5EZiqrnYYPs9VjwfV5rUMihc5Pgk,128
+idun_agent_engine/observability/langfuse/langfuse_handler.py,sha256=Hn3FxqiYDrLmGNF3JXNRBpFit_c8s2w61jl2EQO_Lco,2385
+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=7yGYWxqbL4xNafpj8g8-S-TQ_GmGlPnSB_wRbW_lfMA,824
+idun_agent_engine/server/lifespan.py,sha256=BC914qErOmKLNZY0-XkMkYnA0aVhLZFY7nhpKXx2D_g,1301
+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=7vVzhnKXYv6yZEKP8o-ETMWhIa0Hd2qyMu63MhoiLL0,2361
+idun_agent_engine/server/routers/base.py,sha256=BWueBPN7ecdNWOyQaxpdpnd6GxOcN78N8bFWN_aNgmU,1899
+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=yxDY9zZIof0OrNfJR0Qc6qT3aJAhpL64V93tLgOb8Bg,2602
+idun_platform_cli/groups/agent/serve.py,sha256=IHC3vp_R45RW4enkNQCE-SP_J9GkmapAycktKcxT9Y8,3800
+idun_agent_engine-0.2.2.dist-info/METADATA,sha256=aFxItmgfCjlWJ_NFPnfJIA0wcrrGf7e62dbTzVpPi7I,8660
+idun_agent_engine-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+idun_agent_engine-0.2.2.dist-info/entry_points.txt,sha256=XG3oxlSOaCrYKT1oyhKa0Ag1iJPMZ-WF6gaV_mzIJW4,52
+idun_agent_engine-0.2.2.dist-info/RECORD,,

{idun_agent_engine-0.1.0.dist-info → idun_agent_engine-0.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

idun_agent_engine-0.2.2.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,73 @@
+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.13-slim
+RUN apt-get update && pip install uv
+WORKDIR /app
+
+RUN uv pip install idun-agent-schema==0.2.2
+RUN uv pip install idun-agent-engine==0.2.2
+
+COPY requirements.txt ./
+COPY config.yaml ./
+COPY agent/ ./agent/
+RUN uv pip install -r requirements.txt --system
+
+CMD ["idun", "agent", "serve", "--source=file", "--path", "config.yaml"]
+"""
+        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,104 @@
+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)
+            print(f"Successfully fetched and built config from {self._path}")
+            return config
+
+        except Exception as e:
+            print(f"[ERROR]: Cannot fetch config from {self._path}: {e} ")
+            sys.exit(1)
+
+    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.")

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()