agentified-langchain 0.0.6__tar.gz

agentified_langchain-0.0.6/.gitignore

@@ -0,0 +1,43 @@
+# Rust
+target/
+**/*.rs.bk
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Node
+node_modules/
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+*.egg
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.whl
+
+# TypeScript
+*.tsbuildinfo
+src/ts-packages/**/src/**/*.js
+src/ts-packages/**/src/**/*.js.map
+src/ts-packages/**/src/**/*.d.ts
+src/ts-packages/**/src/**/*.d.ts.map
+
+# Logs
+*.log

agentified_langchain-0.0.6/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: agentified-langchain
+Version: 0.0.6
+Summary: LangChain adapter for Agentified — tool injection for LangChain/LangGraph agents
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: agentified>=0.0.6
+Requires-Dist: langchain-core>=0.3
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'

agentified_langchain-0.0.6/README.md

@@ -0,0 +1,116 @@
+# agentified-langchain
+
+LangChain adapter for [Agentified](../../../README.md) — wraps SDK classes so that `session.context.assemble()` returns LangChain `StructuredTool` instances directly. No manual conversion needed.
+
+## Install
+
+```bash
+pip install agentified-langchain
+```
+
+Requires Python >= 3.10. Peer dependencies: `agentified >= 0.0.5`, `langchain-core >= 0.3`.
+
+## Quick Start
+
+```python
+from agentified_langchain import LangchainAgentified, BackendTool, RegisterInput
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import create_react_agent
+
+ag = LangchainAgentified()
+await ag.connect("http://localhost:9119")
+
+instance = await ag.register(RegisterInput(tools=[
+    BackendTool(name="get_weather", description="Get current weather",
+                parameters={"type": "object", "properties": {"city": {"type": "string"}}},
+                handler=lambda args: {"temp": 22, "city": args["city"]}),
+]))
+
+session = instance.session("chat-1")
+
+# Assemble context — tools are LangChain StructuredTools
+ctx = await session.context.messages(strategy="recent").assemble()
+
+# Pass directly to LangGraph
+llm = ChatOpenAI(model="gpt-4o-mini")
+agent = create_react_agent(llm, list(ctx.tools.values()))
+result = await agent.ainvoke({"messages": [{"role": "user", "content": "What's the weather?"}]})
+```
+
+## API Hierarchy
+
+```
+LangchainAgentified
+  ├── connect(server_url)
+  ├── disconnect()
+  ├── dataset(name) → LangchainDatasetRef
+  │    └── register(RegisterInput) → LangchainInstance
+  └── register(RegisterInput) → LangchainInstance
+
+LangchainInstance
+  ├── discover_tool → StructuredTool (agentified_discover)
+  ├── get_tools() → list[StructuredTool]
+  ├── session(id) → LangchainSession
+  └── namespace(id) → LangchainNamespace
+       └── session(id) → LangchainSession
+
+LangchainSession
+  ├── discover_tool → StructuredTool
+  ├── context → LangchainContextBuilder
+  │    ├── .tools(dict[str, StructuredTool]) → self
+  │    ├── .messages(strategy?, max_tokens?) → self
+  │    ├── .recall() → self
+  │    └── .assemble() → LangchainAssembledContext
+  ├── get_tools() → list[StructuredTool]
+  ├── conversation → Conversation
+  ├── get_messages(opts?) → GetMessagesResult
+  └── update_conversation(messages)
+```
+
+## `LangchainAssembledContext`
+
+Returned by `.assemble()`. Tools are already `StructuredTool` instances:
+
+```python
+ctx = await session.context.messages(strategy="recent").assemble()
+
+ctx.tools              # dict[str, StructuredTool] — explicit + discovered
+ctx.messages           # list[StoredMessage]
+ctx.token_estimate     # int
+ctx.strategy_used      # str
+ctx.recalled           # list (stub)
+```
+
+## `LangchainContextBuilder`
+
+Fluent API — chain `.tools()`, `.messages()`, `.recall()`, then `.assemble()`:
+
+```python
+ctx = await session.context \
+    .tools({"custom": my_structured_tool}) \
+    .messages(strategy="recent", max_tokens=4000) \
+    .assemble()
+```
+
+Explicit tools passed via `.tools()` are merged with auto-discovered tools.
+
+## `LangchainSession.get_tools()`
+
+Returns `discover_tool` + any tools discovered so far as `StructuredTool` instances:
+
+```python
+tools = session.get_tools()
+# [StructuredTool(agentified_discover), StructuredTool(get_weather), ...]
+```
+
+## Links
+
+- [Root README](../../../README.md)
+- [Documentation](../../../docs/)
+- [LangGraph guide](../../../docs/python/integrations/langgraph.md) — Full Python walkthrough
+- [Python SDK](../sdk/README.md)
+- [py-langchain-sdk-smoke example](../../../examples/py-langchain-sdk-smoke/) — Runnable smoke test
+
+## License
+
+[MIT](../../../LICENSE.md#mit-license)

agentified_langchain-0.0.6/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agentified-langchain"
+version = "0.0.6"
+description = "LangChain adapter for Agentified — tool injection for LangChain/LangGraph agents"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "agentified>=0.0.6",
+    "langchain-core>=0.3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agentified_langchain"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.uv.sources]
+agentified = { path = "../sdk", editable = true }
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+]

agentified_langchain-0.0.6/src/agentified_langchain/__init__.py

@@ -0,0 +1,26 @@
+from .agentified import (
+    LangchainAgentified,
+    LangchainAssembledContext,
+    LangchainContextBuilder,
+    LangchainDatasetRef,
+    LangchainInstance,
+    LangchainNamespace,
+    LangchainSession,
+)
+
+from agentified import (
+    BackendTool,
+    RegisterInput,
+)
+
+__all__ = [
+    "LangchainAgentified",
+    "LangchainAssembledContext",
+    "LangchainContextBuilder",
+    "LangchainDatasetRef",
+    "LangchainInstance",
+    "LangchainNamespace",
+    "LangchainSession",
+    "BackendTool",
+    "RegisterInput",
+]

agentified_langchain-0.0.6/src/agentified_langchain/agentified.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field, create_model
+from langchain_core.tools import StructuredTool
+
+from agentified import (
+    Agentified,
+    AssembledContext,
+    BackendTool,
+    ContextBuilder,
+    DatasetRef,
+    Instance,
+    Namespace,
+    RegisterInput,
+    Session,
+)
+from agentified.models import DiscoverTool, DiscoverToolInput
+
+
+# --- Helpers ---
+
+def _json_schema_to_pydantic(schema: dict[str, Any]) -> type[BaseModel]:
+    props = schema.get("properties", {})
+    required = set(schema.get("required", []))
+    fields: dict[str, Any] = {}
+    type_map = {"string": str, "number": float, "integer": int, "boolean": bool}
+    for name, spec in props.items():
+        py_type = type_map.get(spec.get("type", "string"), str)
+        desc = spec.get("description", "")
+        if name in required:
+            fields[name] = (py_type, Field(description=desc))
+        else:
+            fields[name] = (py_type | None, Field(default=None, description=desc))
+    return create_model("DynamicInput", **fields)
+
+
+def _build_lc_tool_map(backend_tools: list[BackendTool]) -> dict[str, StructuredTool]:
+    tools: dict[str, StructuredTool] = {}
+    for t in backend_tools:
+        input_model = _json_schema_to_pydantic(t.parameters)
+
+        async def _handler(h=t.handler, **kwargs: Any) -> Any:
+            result = h(kwargs)
+            if hasattr(result, "__await__"):
+                return await result
+            return result
+
+        tools[t.name] = StructuredTool.from_function(
+            coroutine=_handler,
+            name=t.name,
+            description=t.description,
+            args_schema=input_model,
+        )
+    return tools
+
+
+def _wrap_discover_tool(dt: DiscoverTool) -> StructuredTool:
+    async def _execute(**kwargs: Any) -> list[dict[str, Any]]:
+        inp = DiscoverToolInput(**kwargs)
+        result = await dt.execute(inp)
+        return [{"name": t.name, "description": t.description, "score": t.score} for t in result]
+
+    return StructuredTool.from_function(
+        coroutine=_execute,
+        name=dt.definition.name,
+        description=dt.definition.description,
+        args_schema=_json_schema_to_pydantic(dt.definition.parameters),
+    )
+
+
+# --- Wrapper classes ---
+
+class LangchainAssembledContext:
+    def __init__(self, sdk_ctx: AssembledContext, tools: dict[str, StructuredTool]) -> None:
+        self._sdk_ctx = sdk_ctx
+        self.tools = tools
+
+    @property
+    def messages(self):
+        return self._sdk_ctx.messages
+
+    @property
+    def recalled(self):
+        return self._sdk_ctx.recalled
+
+    @property
+    def strategy_used(self):
+        return self._sdk_ctx.strategy_used
+
+    @property
+    def fallback(self):
+        return self._sdk_ctx.fallback
+
+    @property
+    def token_estimate(self):
+        return self._sdk_ctx.token_estimate
+
+    @property
+    def conversation_messages(self):
+        return self._sdk_ctx.conversation_messages
+
+    @property
+    def total_messages(self):
+        return self._sdk_ctx.total_messages
+
+    @property
+    def included_messages(self):
+        return self._sdk_ctx.included_messages
+
+
+class LangchainContextBuilder:
+    def __init__(
+        self,
+        sdk_builder: ContextBuilder,
+        discover_tool: StructuredTool,
+        discovered_names: set[str],
+        lc_tool_cache: dict[str, StructuredTool],
+    ) -> None:
+        self._sdk_builder = sdk_builder
+        self._discover_tool = discover_tool
+        self._discovered_names = discovered_names
+        self._lc_tool_cache = lc_tool_cache
+        self._explicit_tools: dict[str, StructuredTool] = {}
+
+    def messages(self, **kwargs: Any) -> LangchainContextBuilder:
+        self._sdk_builder.messages(**kwargs)
+        return self
+
+    def tools(self, tools: dict[str, StructuredTool]) -> LangchainContextBuilder:
+        self._explicit_tools.update(tools)
+        return self
+
+    def recall(self, **kwargs: Any) -> LangchainContextBuilder:
+        self._sdk_builder.recall(**kwargs)
+        return self
+
+    async def assemble(self) -> LangchainAssembledContext:
+        sdk_ctx = await self._sdk_builder.assemble()
+
+        resolved: dict[str, StructuredTool] = {**self._explicit_tools}
+        for name in self._discovered_names:
+            if name not in resolved and name in self._lc_tool_cache:
+                resolved[name] = self._lc_tool_cache[name]
+
+        return LangchainAssembledContext(sdk_ctx, resolved)
+
+
+class LangchainSession:
+    def __init__(self, sess: Session, lc_tool_cache: dict[str, StructuredTool]) -> None:
+        self._sess = sess
+        self._lc_tool_cache = lc_tool_cache
+        self.discover_tool = _wrap_discover_tool(sess.discover_tool)
+
+    @property
+    def id(self) -> str:
+        return self._sess.id
+
+    @property
+    def namespace_id(self) -> str:
+        return self._sess.namespace_id
+
+    @property
+    def conversation(self):
+        return self._sess.conversation
+
+    @property
+    def context(self) -> LangchainContextBuilder:
+        return LangchainContextBuilder(
+            self._sess.context,
+            self.discover_tool,
+            self._sess.discover_tool.discovered_names,
+            self._lc_tool_cache,
+        )
+
+    def get_tools(self) -> list[StructuredTool]:
+        tools: list[StructuredTool] = [self.discover_tool]
+        for name in self._sess.discover_tool.discovered_names:
+            if name in self._lc_tool_cache:
+                tools.append(self._lc_tool_cache[name])
+        return tools
+
+    async def get_messages(self, *args: Any, **kwargs: Any):
+        return await self._sess.get_messages(*args, **kwargs)
+
+    async def update_conversation(self, *args: Any, **kwargs: Any):
+        return await self._sess.update_conversation(*args, **kwargs)
+
+
+class LangchainNamespace:
+    def __init__(self, ns: Namespace, lc_tool_cache: dict[str, StructuredTool]) -> None:
+        self._ns = ns
+        self._lc_tool_cache = lc_tool_cache
+
+    @property
+    def id(self) -> str:
+        return self._ns.id
+
+    def session(self, id: str) -> LangchainSession:
+        return LangchainSession(self._ns.session(id), self._lc_tool_cache)
+
+
+class LangchainInstance:
+    def __init__(self, inst: Instance, backend_tools: list[BackendTool]) -> None:
+        self._inst = inst
+        self._lc_tool_cache = _build_lc_tool_map(backend_tools)
+        self.discover_tool = _wrap_discover_tool(inst.discover_tool)
+
+    @property
+    def instance_id(self) -> str:
+        return self._inst.instance_id
+
+    @property
+    def dataset_id(self) -> str:
+        return self._inst.dataset_id
+
+    def get_tools(self) -> list[StructuredTool]:
+        tools: list[StructuredTool] = [self.discover_tool]
+        for name in self._inst.discover_tool.discovered_names:
+            if name in self._lc_tool_cache:
+                tools.append(self._lc_tool_cache[name])
+        return tools
+
+    def session(self, id: str) -> LangchainSession:
+        return LangchainSession(self._inst.session(id), self._lc_tool_cache)
+
+    def namespace(self, id: str) -> LangchainNamespace:
+        return LangchainNamespace(self._inst.namespace(id), self._lc_tool_cache)
+
+
+class LangchainDatasetRef:
+    def __init__(self, ref: DatasetRef) -> None:
+        self._ref = ref
+
+    async def register(self, input: RegisterInput) -> LangchainInstance:
+        inst = await self._ref.register(input)
+        return LangchainInstance(inst, input.tools)
+
+
+class LangchainAgentified:
+    def __init__(self, ag: Agentified | None = None) -> None:
+        self._ag = ag or Agentified()
+
+    async def connect(self, server_url: str) -> None:
+        await self._ag.connect(server_url)
+
+    async def disconnect(self) -> None:
+        await self._ag.disconnect()
+
+    def dataset(self, name: str) -> LangchainDatasetRef:
+        return LangchainDatasetRef(self._ag.dataset(name))
+
+    async def register(self, input: RegisterInput) -> LangchainInstance:
+        inst = await self._ag.register(input)
+        return LangchainInstance(inst, input.tools)
+
+    async def __aenter__(self) -> LangchainAgentified:
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.disconnect()

agentified_langchain-0.0.6/tests/conftest.py

@@ -0,0 +1,26 @@
+from agentified.models import BackendTool, RankedTool, ServerTool
+
+TEST_URL = "http://localhost:9119"
+
+TEST_TOOL = ServerTool(
+    name="get_weather",
+    description="Get weather for a city",
+    parameters={"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
+)
+
+RANKED_TOOL = RankedTool(**TEST_TOOL.model_dump(), score=0.95)
+
+BACKEND_TOOLS = [
+    BackendTool(
+        name="get_weather",
+        description="Get weather for a city",
+        parameters={"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
+        handler=lambda args: {"temp": 22, "city": args.get("city", "")},
+    ),
+    BackendTool(
+        name="search_docs",
+        description="Search documentation",
+        parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]},
+        handler=lambda args: {"results": [f"Doc about {args.get('query', '')}"]},
+    ),
+]