agentplane-runtime 0.0.1__py3-none-any.whl

agentplane_runtime/vector.py

@@ -0,0 +1,149 @@
+"""Read-only vector DB access (SPEC §3.2): qdrant via REST, pgvector via asyncpg.
+
+Vector DBs are consumed **read-only by contract** — there is no upsert path
+anywhere in the runtime.
+"""
+
+from __future__ import annotations
+
+from importlib.util import find_spec
+
+import httpx
+
+from agentplane_core import Document, JsonObject, VectorDBResource
+
+
+class VectorDBError(RuntimeError):
+    """Vector DB request failed."""
+
+
+class QdrantReader:
+    """Qdrant REST access: collection info + similarity search."""
+
+    def __init__(self, url: str, api_key: str = "", *, timeout: float = 30.0) -> None:
+        self._url = url.rstrip("/")
+        self._headers = {"api-key": api_key} if api_key else {}
+        self._timeout = timeout
+
+    async def collection_dimension(self, collection: str) -> int:
+        try:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                response = await client.get(
+                    f"{self._url}/collections/{collection}", headers=self._headers
+                )
+        except httpx.HTTPError as exc:
+            raise VectorDBError(f"qdrant unreachable: {exc}") from exc
+        if response.status_code != httpx.codes.OK:
+            raise VectorDBError(
+                f"cannot read collection {collection!r}: HTTP {response.status_code}"
+            )
+        params = response.json().get("result", {}).get("config", {}).get("params", {})
+        vectors = params.get("vectors", {})
+        size = vectors.get("size") if isinstance(vectors, dict) else None
+        if not isinstance(size, int):
+            raise VectorDBError(f"collection {collection!r} has no readable vector size")
+        return size
+
+    async def search(
+        self,
+        collection: str,
+        vector: list[float],
+        top_k: int,
+        filter: JsonObject | None = None,
+    ) -> list[Document]:
+        body: dict[str, object] = {"vector": vector, "limit": top_k, "with_payload": True}
+        if filter is not None:
+            body["filter"] = filter
+        try:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                response = await client.post(
+                    f"{self._url}/collections/{collection}/points/search",
+                    json=body,
+                    headers=self._headers,
+                )
+        except httpx.HTTPError as exc:
+            raise VectorDBError(f"qdrant unreachable: {exc}") from exc
+        if response.status_code != httpx.codes.OK:
+            raise VectorDBError(f"search failed: HTTP {response.status_code}")
+        documents: list[Document] = []
+        for hit in response.json().get("result", []):
+            payload = hit.get("payload") or {}
+            text = payload.get("text") or payload.get("content") or payload.get("chunk") or ""
+            metadata = {k: v for k, v in payload.items() if k not in ("text", "content", "chunk")}
+            documents.append(
+                Document(text=str(text), score=float(hit.get("score", 0.0)), metadata=metadata)
+            )
+        return documents
+
+
+class PgvectorReader:
+    """pgvector access via asyncpg ([postgres] extra); degrades with a clear error."""
+
+    def __init__(self, dsn: str, *, table_prefix: str = "") -> None:
+        if find_spec("asyncpg") is None:
+            raise VectorDBError("pgvector resources need the [postgres] extra (asyncpg) installed")
+        self._dsn = dsn
+        self._table_prefix = table_prefix
+
+    async def collection_dimension(self, collection: str) -> int:
+        import asyncpg  # noqa: PLC0415 - optional [postgres] extra
+
+        conn = await asyncpg.connect(self._dsn)
+        try:
+            row = await conn.fetchrow(
+                """
+                SELECT atttypmod AS dim FROM pg_attribute
+                WHERE attrelid = $1::regclass AND attname = 'embedding'
+                """,
+                collection,
+            )
+        finally:
+            await conn.close()
+        if row is None or not isinstance(row["dim"], int) or row["dim"] <= 0:
+            raise VectorDBError(f"table {collection!r} has no readable embedding dimension")
+        return int(row["dim"])
+
+    async def search(
+        self,
+        collection: str,
+        vector: list[float],
+        top_k: int,
+        filter: JsonObject | None = None,
+    ) -> list[Document]:
+        import asyncpg  # noqa: PLC0415 - optional [postgres] extra
+
+        if not collection.replace("_", "").isalnum():
+            raise VectorDBError(f"invalid collection name {collection!r}")
+        vector_literal = "[" + ",".join(f"{v:.8f}" for v in vector) + "]"
+        conn = await asyncpg.connect(self._dsn)
+        try:
+            rows = await conn.fetch(
+                f"""
+                SELECT text, metadata, 1 - (embedding <=> $1::vector) AS score
+                FROM {collection} ORDER BY embedding <=> $1::vector LIMIT $2
+                """,
+                vector_literal,
+                top_k,
+            )
+        finally:
+            await conn.close()
+        documents: list[Document] = []
+        for row in rows:
+            metadata = row["metadata"] if isinstance(row["metadata"], dict) else {}
+            documents.append(
+                Document(text=str(row["text"]), score=float(row["score"]), metadata=metadata)
+            )
+        return documents
+
+
+Reader = QdrantReader | PgvectorReader
+
+
+async def reader_for(resource: VectorDBResource, *, api_key: str = "", dsn: str = "") -> Reader:
+    """Build the right reader for a VectorDB resource."""
+    if resource.kind == "qdrant":
+        return QdrantReader(resource.url, api_key)
+    return PgvectorReader(dsn or resource.url)
+
+
+__all__ = ["PgvectorReader", "QdrantReader", "Reader", "VectorDBError", "reader_for"]

agentplane_runtime-0.0.1.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: agentplane-runtime
+Version: 0.0.1
+Summary: agentplane runtime: definitions, resources, flow execution, A2A + MCP serving
+License-Expression: MIT
+Requires-Python: >=3.12
+Requires-Dist: a2a-sdk[http-server]<2,>=1.1
+Requires-Dist: agentplane-core<0.1.0,>=0.0.1
+Requires-Dist: agentplane-sdk<0.1.0,>=0.0.1
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: cryptography>=43
+Requires-Dist: fastapi>=0.115
+Requires-Dist: fastmcp==3.4.4
+Requires-Dist: httpx>=0.27
+Requires-Dist: langgraph<2,>=1.0
+Requires-Dist: opentelemetry-api>=1.27
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.27
+Requires-Dist: opentelemetry-sdk>=1.27
+Requires-Dist: pydantic-settings>=2.4
+Requires-Dist: pyjwt[crypto]>=2.9
+Requires-Dist: sqlalchemy[asyncio]>=2.0.30
+Requires-Dist: uvicorn>=0.30
+Provides-Extra: postgres
+Requires-Dist: asyncpg>=0.29; extra == 'postgres'
+Requires-Dist: pgvector>=0.3; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# agentplane-runtime
+
+Owns flow definitions and resources; executes flows (LangGraph); serves each
+deployed flow as an **A2A agent** (`/a2a/{name}`, a2a-sdk, A2A v1.0) or an
+**MCP server** (`/mcp/{name}`, FastMCP streamable HTTP); self-registers with
+the agentplane registry.
+
+Required configuration (env prefix `AGENTPLANE_RUNTIME_`):
+
+| Variable | Purpose |
+|---|---|
+| `PUBLIC_BASE_URL` | externally reachable base (a gateway route) |
+| `REGISTRY_URL` | where to self-register (empty disables registration) |
+| `SECRET_KEY` | Fernet key for resource credentials |
+| `LLM_BASE_URL` | gateway's OpenAI-compatible endpoint (resource default) |
+
+Run it:
+
+```
+uvicorn --factory agentplane_runtime.app:create_app --port 8000
+```

agentplane_runtime-0.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+agentplane_runtime/__init__.py,sha256=q8xssnfMJBzxNFmE1ZngpKpgOBgtq3nCoahw6R4QcH0,300
+agentplane_runtime/api.py,sha256=2b_pOnWtULiyWP2AEOwMsVQD0AZQveyr9s1g5-vIDZw,8190
+agentplane_runtime/app.py,sha256=9YJ36KXLHHEulrxTkJCDws3UYve8uwPQwpwvxHlV59A,3034
+agentplane_runtime/auth.py,sha256=6CygzQV3GgkHnEbZytwEoneK6QAoyDTcCwXT9FTI1o8,4932
+agentplane_runtime/db.py,sha256=MqWNSikYeiPmpxZIAEQIJv8NgIrbQ-tussaNH-4p2P4,4047
+agentplane_runtime/definitions.py,sha256=KwvJWKj4O1gCNpocbcyQxwQnNwvMD3fCaj8q-2hrKNg,10751
+agentplane_runtime/engine.py,sha256=eqC4-LKmPp-TvvZ5BBrw3rGxoh1RctxmNOzDA7Oh9yc,16495
+agentplane_runtime/llm.py,sha256=RYmOrv67s91XeWFIs9qvQJy3nIhZN72jijRiLYP9wgk,4574
+agentplane_runtime/registration.py,sha256=4wwZcdWLoI5b5cyxGx6AoWxgWyKwyjPSbbT763xpza4,5263
+agentplane_runtime/resources.py,sha256=nLP1zyjPUp4g00YapkQKc_K1Iws5NfV6SAM6HGlUEKA,8886
+agentplane_runtime/secrets.py,sha256=vp1Ul_wDs5KlrNwMab_bnloqWEGk8arT7-o3QGsMm0Q,1614
+agentplane_runtime/serving.py,sha256=fq9kyyNm03fivXtq1VXEKVkPL-xafc5m5rGcHeKuv_Y,13694
+agentplane_runtime/settings.py,sha256=9EBcHUXaYAOZwEsczZVXKQzhCICQQWeNyEuzJqt65_8,1116
+agentplane_runtime/tracing.py,sha256=8Wzse1Se3U4m80W7OWuMB84MVaDuk43mci1dDf5OPmA,1949
+agentplane_runtime/validation.py,sha256=_ImfSHqwP2nut1Uv75YSdHz2Dvfd21-nOjFozpS6I6c,3214
+agentplane_runtime/vector.py,sha256=ESwm8P-X-U8ed_kCMgv9RWSx21thmM_m5ZQCZyFcFwA,5732
+agentplane_runtime-0.0.1.dist-info/METADATA,sha256=kIS9F--QfF28jv4DjtH95Ubgsec0x-_Xj-bs2mDpATc,1687
+agentplane_runtime-0.0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+agentplane_runtime-0.0.1.dist-info/RECORD,,

agentplane_runtime-0.0.1.dist-info/WHEEL

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