anlyon-langchain 0.1.0__tar.gz

anlyon_langchain-0.1.0/.gitignore

@@ -0,0 +1,35 @@
+node_modules/
+# pnpm puts its content-addressable store beside the project when HOME is
+# on a different filesystem, which is what happens inside a container. It is
+# ~2GB and ~100k files, and .dockerignore already excludes it from builds --
+# this keeps it out of commits too.
+.pnpm-store/
+dist/
+build/
+.next/
+coverage/
+*.tsbuildinfo
+
+# Python
+__pycache__/
+*.egg-info/
+.venv/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+
+# Env
+.env
+.env.*
+!.env.example
+skills-lock.json
+
+# Local MCP / tool overrides (may contain secrets  never commit)
+*.local.json
+.mcp.local.json
+
+# Local agent tooling config, not part of the build.
+.commandcode/
+
+# Redis snapshot left behind by a locally-run redis-server.
+dump.rdb

anlyon_langchain-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anlyon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

anlyon_langchain-0.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.5
+Name: anlyon-langchain
+Version: 0.1.0
+Summary: LangChain integration for Anlyon state primitives and trace callbacks
+Project-URL: Homepage, https://anlyon.com
+Project-URL: Documentation, https://docs.anlyon.com
+Project-URL: Repository, https://github.com/AnlyonHQ/anlyon-platform
+Project-URL: Issues, https://github.com/AnlyonHQ/anlyon-platform/issues
+Author-email: Anlyon <support@anlyon.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-governance,ai-agents,anlyon,approvals,langchain,memory,sdk,tracing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: anlyon>=0.1.0
+Requires-Dist: langchain-core>=1.6.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# anlyon-langchain
+
+LangChain integration for [Anlyon](https://anlyon.com): `AnlyonVectorStore` and `AnlyonRetriever` over Anlyon Memory, `AnlyonChatMessageHistory` over Anlyon Sessions, and `AnlyonTracer` for nested run/span tracing.
+
+## Trace a LangChain invocation
+
+```python
+from anlyon import Client
+from anlyon_langchain import AnlyonTracer
+
+client = Client(api_key="anlyon_live_...")
+tracer = AnlyonTracer(client, application="support-agent")
+
+# Pass the callback to any LangChain runnable/agent invocation.
+result = chain.invoke({"question": "Where is my order?"}, config={"callbacks": [tracer]})
+```
+
+The handler creates one Anlyon run for the root callback and parent-linked
+`workflow_step`, `model_call`, and `tool_call` spans for nested callbacks. It is
+best-effort: Anlyon transport failures never change the application result.
+
+## Installation
+
+```bash
+pip install anlyon-langchain
+```
+
+## Retrieval
+
+```python
+from anlyon import Client
+from anlyon_langchain import AnlyonVectorStore
+
+client = Client()  # uses ANLYON_API_KEY
+store = AnlyonVectorStore(client, collection="docs")
+retriever = store.as_retriever()
+```
+
+## Chat history
+
+`AnlyonChatMessageHistory` puts a chain's conversation in an Anlyon Session  durable across processes, and summarized automatically once the thread gets long.
+
+```python
+from anlyon import Client
+from anlyon_langchain import AnlyonChatMessageHistory
+from langchain_core.runnables.history import RunnableWithMessageHistory
+
+client = Client()
+
+chain_with_history = RunnableWithMessageHistory(
+    chain,
+    lambda session_id: AnlyonChatMessageHistory(client, session_id),
+    input_messages_key="input",
+    history_messages_key="history",
+)
+
+# `session_id` is an Anlyon session id  create one with client.sessions.create()
+chain_with_history.invoke(
+    {"input": "Where is my order?"},
+    config={"configurable": {"session_id": "ses_abc123"}},
+)
+```
+
+`.messages` reads the thread back as LangChain messages, `.add_messages()` appends a turn in one round-trip, and `.clear()` truncates the thread while keeping the session id usable.
+
+See the [Anlyon docs](https://docs.anlyon.com) for the full guide.
+
+## License
+
+MIT

anlyon_langchain-0.1.0/README.md

@@ -0,0 +1,70 @@
+# anlyon-langchain
+
+LangChain integration for [Anlyon](https://anlyon.com): `AnlyonVectorStore` and `AnlyonRetriever` over Anlyon Memory, `AnlyonChatMessageHistory` over Anlyon Sessions, and `AnlyonTracer` for nested run/span tracing.
+
+## Trace a LangChain invocation
+
+```python
+from anlyon import Client
+from anlyon_langchain import AnlyonTracer
+
+client = Client(api_key="anlyon_live_...")
+tracer = AnlyonTracer(client, application="support-agent")
+
+# Pass the callback to any LangChain runnable/agent invocation.
+result = chain.invoke({"question": "Where is my order?"}, config={"callbacks": [tracer]})
+```
+
+The handler creates one Anlyon run for the root callback and parent-linked
+`workflow_step`, `model_call`, and `tool_call` spans for nested callbacks. It is
+best-effort: Anlyon transport failures never change the application result.
+
+## Installation
+
+```bash
+pip install anlyon-langchain
+```
+
+## Retrieval
+
+```python
+from anlyon import Client
+from anlyon_langchain import AnlyonVectorStore
+
+client = Client()  # uses ANLYON_API_KEY
+store = AnlyonVectorStore(client, collection="docs")
+retriever = store.as_retriever()
+```
+
+## Chat history
+
+`AnlyonChatMessageHistory` puts a chain's conversation in an Anlyon Session  durable across processes, and summarized automatically once the thread gets long.
+
+```python
+from anlyon import Client
+from anlyon_langchain import AnlyonChatMessageHistory
+from langchain_core.runnables.history import RunnableWithMessageHistory
+
+client = Client()
+
+chain_with_history = RunnableWithMessageHistory(
+    chain,
+    lambda session_id: AnlyonChatMessageHistory(client, session_id),
+    input_messages_key="input",
+    history_messages_key="history",
+)
+
+# `session_id` is an Anlyon session id  create one with client.sessions.create()
+chain_with_history.invoke(
+    {"input": "Where is my order?"},
+    config={"configurable": {"session_id": "ses_abc123"}},
+)
+```
+
+`.messages` reads the thread back as LangChain messages, `.add_messages()` appends a turn in one round-trip, and `.clear()` truncates the thread while keeping the session id usable.
+
+See the [Anlyon docs](https://docs.anlyon.com) for the full guide.
+
+## License
+
+MIT

anlyon_langchain-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "anlyon-langchain"
+version = "0.1.0"
+description = "LangChain integration for Anlyon state primitives and trace callbacks"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Anlyon", email = "support@anlyon.com" }]
+keywords = ["anlyon", "langchain", "ai-agents", "agent-governance", "approvals", "tracing", "memory", "sdk"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = [
+    "anlyon>=0.1.0",
+    "langchain-core>=1.6.0",
+]
+
+[project.urls]
+Homepage = "https://anlyon.com"
+Documentation = "https://docs.anlyon.com"
+Repository = "https://github.com/AnlyonHQ/anlyon-platform"
+Issues = "https://github.com/AnlyonHQ/anlyon-platform/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23", "respx>=0.21"]
+
+[tool.uv.sources]
+anlyon = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/anlyon_langchain"]

anlyon_langchain-0.1.0/src/anlyon_langchain/__init__.py

@@ -0,0 +1,12 @@
+"""
+Anlyon LangChain integration  state primitives and trace callbacks.
+
+Thin wrappers over the `anlyon` SDK. No re-implementation.
+"""
+
+from .vectorstore import AnlyonVectorStore
+from .retriever import AnlyonRetriever
+from .chat_history import AnlyonChatMessageHistory
+from .tracing import AnlyonTracer
+
+__all__ = ["AnlyonVectorStore", "AnlyonRetriever", "AnlyonChatMessageHistory", "AnlyonTracer"]

anlyon_langchain-0.1.0/src/anlyon_langchain/chat_history.py

@@ -0,0 +1,149 @@
+"""
+AnlyonChatMessageHistory  LangChain chat history backed by an Anlyon Session.
+
+Drop this in wherever LangChain wants a `BaseChatMessageHistory` (most often
+inside `RunnableWithMessageHistory`) and the conversation persists in Anlyon:
+durable, workspace-scoped, and summarized automatically once it gets long.
+
+Thin wrapper  calls the SDK, never re-implements API logic.
+"""
+
+from __future__ import annotations
+from typing import Any, List, Sequence
+
+from langchain_core.chat_history import BaseChatMessageHistory
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+
+from anlyon import Client
+
+# LangChain message types ↔ Anlyon session roles.
+_ROLE_BY_TYPE = {
+    "human": "user",
+    "ai": "assistant",
+    "system": "system",
+    "tool": "tool",
+}
+
+# How many messages to read back. Anlyon caps a page at 200.
+_PAGE_LIMIT = 200
+
+
+def _to_role(message: BaseMessage) -> str:
+    """A LangChain message's role, defaulting anything exotic to `user`."""
+    return _ROLE_BY_TYPE.get(message.type, "user")
+
+
+def _to_langchain(message: dict[str, Any]) -> BaseMessage:
+    role = message.get("role")
+    content = message.get("content", "")
+    metadata = message.get("metadata") or {}
+
+    if role == "assistant":
+        return AIMessage(content=content, additional_kwargs=metadata)
+    if role == "system":
+        return SystemMessage(content=content, additional_kwargs=metadata)
+    if role == "tool":
+        # tool_call_id is required by LangChain; the session column carries it.
+        return ToolMessage(
+            content=content,
+            tool_call_id=message.get("toolCallId") or "",
+            additional_kwargs=metadata,
+        )
+    return HumanMessage(content=content, additional_kwargs=metadata)
+
+
+class AnlyonChatMessageHistory(BaseChatMessageHistory):
+    """
+    An Anlyon Session as a LangChain chat history.
+
+    Example:
+        ```python
+        from anlyon import Client
+        from anlyon_langchain import AnlyonChatMessageHistory
+
+        client = Client(api_key="anlyon_live_...")
+        session = client.sessions.create(title="Support chat")
+
+        history = AnlyonChatMessageHistory(client, session["id"])
+        history.add_user_message("Where is my order?")
+        history.messages  # → [HumanMessage(...)]
+        ```
+
+    Pass it to `RunnableWithMessageHistory` to persist a chain's conversation:
+
+        ```python
+        RunnableWithMessageHistory(
+            chain,
+            lambda session_id: AnlyonChatMessageHistory(client, session_id),
+            input_messages_key="input",
+            history_messages_key="history",
+        )
+        ```
+    """
+
+    def __init__(self, client: Client, session_id: str) -> None:
+        self.client = client
+        self.session_id = session_id
+
+    @property
+    def messages(self) -> List[BaseMessage]:
+        """The whole thread, oldest first."""
+        collected: List[BaseMessage] = []
+        offset = 0
+
+        while True:
+            page = self.client.sessions.messages(
+                self.session_id, limit=_PAGE_LIMIT, offset=offset
+            )
+            collected.extend(_to_langchain(m) for m in page)
+            if len(page) < _PAGE_LIMIT:
+                return collected
+            offset += _PAGE_LIMIT
+
+    def add_messages(self, messages: Sequence[BaseMessage]) -> None:
+        """Append a turn. One round-trip per call, not one per message."""
+        if not messages:
+            return
+
+        payload = [
+            {
+                "role": _to_role(m),
+                "content": _text(m),
+                **({"toolCallId": m.tool_call_id} if isinstance(m, ToolMessage) else {}),
+            }
+            for m in messages
+        ]
+        self.client.sessions.append(self.session_id, payload)
+
+    def clear(self) -> None:
+        """Truncate the thread. The session survives, so its id stays usable."""
+        self.client.sessions.clear_messages(self.session_id)
+
+
+def _text(message: BaseMessage) -> str:
+    """
+    Anlyon stores message content as text. LangChain content can also be a list
+    of parts (multimodal); keep the text parts and drop the rest rather than
+    storing a Python repr of a dict.
+    """
+    content: Any = message.content
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for part in content:
+            if isinstance(part, str):
+                parts.append(part)
+            elif isinstance(part, dict) and part.get("type") == "text":
+                parts.append(str(part.get("text", "")))
+        return "\n".join(parts)
+    return str(content)
+
+
+__all__ = ["AnlyonChatMessageHistory"]

anlyon_langchain-0.1.0/src/anlyon_langchain/retriever.py

@@ -0,0 +1,46 @@
+"""
+AnlyonRetriever  LangChain BaseRetriever backed by Anlyon Memory recall().
+
+Thin wrapper  calls the SDK, never re-implements API logic.
+"""
+
+from __future__ import annotations
+from typing import Optional
+
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+
+from anlyon import Client
+
+
+class AnlyonRetriever(BaseRetriever):
+    """Anlyon Memory as a LangChain retriever."""
+
+    client: Client
+    collection: Optional[str] = None
+    top_k: int = 5
+    mode: str = "hybrid"
+    rerank: bool = False
+
+    def _get_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: CallbackManagerForRetrieverRun,
+    ) -> list[Document]:
+        result = self.client.memory.recall(
+            query=query,
+            collection=self.collection,
+            top_k=self.top_k,
+            mode=self.mode,
+            rerank=self.rerank if self.rerank else None,
+        )
+        results = result.get("results", []) if isinstance(result, dict) else []
+        return [
+            Document(
+                page_content=r.get("content", ""),
+                metadata={"score": r.get("score", 0), **r.get("metadata", {})},
+            )
+            for r in results
+        ]

anlyon_langchain-0.1.0/src/anlyon_langchain/tracing.py

@@ -0,0 +1,246 @@
+"""LangChain callback adapter for the Anlyon run/span trace model.
+
+The handler is deliberately best-effort: observability must never change the
+result of an agent run. It maps LangChain run UUIDs to Anlyon span IDs and uses
+the parent UUID supplied by LangChain to preserve nesting.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from threading import RLock
+from typing import Any, Optional
+from uuid import UUID
+
+from langchain_core.callbacks import BaseCallbackHandler
+
+from anlyon import Client
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _span_id(run_id: UUID) -> str:
+    return f"lc_{run_id.hex}"
+
+
+def _safe_value(value: Any) -> Any:
+    """Keep callback payloads JSON-compatible before SDK serialization."""
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, dict):
+        return {str(key): _safe_value(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_safe_value(item) for item in value]
+    return str(value)
+
+
+def _extract_llm_usage(response: Any) -> tuple[Optional[dict[str, int]], Optional[str]]:
+    """Pull token usage and model name from an LLMResult, best-effort.
+
+    Providers report usage in two places: ``llm_output["token_usage"]``
+    (OpenAI-style ``prompt_tokens``/``completion_tokens``/``total_tokens``) and
+    the newer per-generation ``message.usage_metadata`` (``input_tokens``/
+    ``output_tokens``/``total_tokens``). Both normalize to the Anlyon span
+    convention: ``{"input": ..., "output": ..., "total": ...}``.
+    """
+    tokens: Optional[dict[str, int]] = None
+    model: Optional[str] = None
+
+    llm_output = getattr(response, "llm_output", None)
+    if isinstance(llm_output, dict):
+        model = llm_output.get("model_name") or llm_output.get("model")
+        usage = llm_output.get("token_usage") or llm_output.get("usage")
+        if isinstance(usage, dict):
+            normalized = {
+                "input": usage.get("prompt_tokens", usage.get("input_tokens")),
+                "output": usage.get("completion_tokens", usage.get("output_tokens")),
+                "total": usage.get("total_tokens"),
+            }
+            tokens = {k: int(v) for k, v in normalized.items() if isinstance(v, (int, float))}
+
+    if tokens is None:
+        for generations in getattr(response, "generations", []) or []:
+            for generation in generations:
+                usage = getattr(getattr(generation, "message", None), "usage_metadata", None)
+                if isinstance(usage, dict) and usage:
+                    tokens = {
+                        k: int(v)
+                        for k, v in {
+                            "input": usage.get("input_tokens"),
+                            "output": usage.get("output_tokens"),
+                            "total": usage.get("total_tokens"),
+                        }.items()
+                        if isinstance(v, (int, float))
+                    }
+                    break
+            if tokens:
+                break
+
+    return (tokens or None), model
+
+
+@dataclass
+class _TraceState:
+    run_id: str
+    root_langchain_id: UUID
+    spans: dict[UUID, "_TrackedSpan"] = field(default_factory=dict)
+
+
+@dataclass
+class _TrackedSpan:
+    id: str
+    name: str
+    type: str
+    parent_id: Optional[str]
+    started_at: str
+    input: Any
+    attributes: dict[str, Any]
+
+
+class AnlyonTracer(BaseCallbackHandler):
+    """Emit a run and nested spans for LangChain chain, LLM, and tool callbacks.
+
+    Attach one instance to a LangChain invocation with ``callbacks=[tracer]``.
+    The adapter keeps only in-flight UUID mappings in memory and is safe to
+    share across concurrent invocations.
+    """
+
+    raise_error = False
+
+    def __init__(self, client: Client, *, application: str = "langchain", run_name: str = "LangChain run") -> None:
+        super().__init__()
+        self.client = client
+        self.application = application
+        self.run_name = run_name
+        self._states: dict[UUID, _TraceState] = {}
+        self._lock = RLock()
+
+    def _start(
+        self,
+        kind: str,
+        run_id: UUID,
+        parent_run_id: Optional[UUID],
+        name: str,
+        input: Any = None,
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict[str, Any]] = None,
+    ) -> None:
+        try:
+            with self._lock:
+                state = self._states.get(parent_run_id) if parent_run_id else None
+                if state is None:
+                    started = self.client.runs.start(
+                        name=self.run_name,
+                        application=self.application,
+                        tags=tags,
+                        metadata={"framework": "langchain", **(metadata or {})},
+                    )
+                    state = _TraceState(run_id=started.data["id"], root_langchain_id=run_id)
+                parent_id = state.spans.get(parent_run_id).id if parent_run_id in state.spans else None
+                started_at = _now()
+                span = _TrackedSpan(
+                    id=_span_id(run_id),
+                    name=name,
+                    type=kind,
+                    parent_id=parent_id,
+                    started_at=started_at,
+                    input=_safe_value(input),
+                    attributes={
+                        "langchain.run_id": str(run_id),
+                        "langchain.parent_run_id": str(parent_run_id) if parent_run_id else None,
+                        "langchain.kind": kind,
+                    },
+                )
+                state.spans[run_id] = span
+                self._states[run_id] = state
+
+            self.client.runs.ingest_spans(
+                state.run_id,
+                [{
+                    "id": span.id,
+                    **({"parentId": parent_id} if parent_id else {}),
+                    "name": span.name,
+                    "type": span.type,
+                    "startedAt": span.started_at,
+                    **({"input": span.input} if input is not None else {}),
+                    "attributes": span.attributes,
+                }],
+            )
+        except Exception:
+            # Callback instrumentation must never break a LangChain invocation.
+            return
+
+    def _finish(
+        self,
+        run_id: UUID,
+        *,
+        error: Optional[BaseException] = None,
+        output: Any = None,
+        tokens: Optional[dict[str, int]] = None,
+        model: Optional[str] = None,
+    ) -> None:
+        try:
+            with self._lock:
+                state = self._states.get(run_id)
+                if state is None:
+                    return
+                is_root = state.root_langchain_id == run_id
+                span = state.spans[run_id]
+            status = "failed" if error else "succeeded"
+            self.client.runs.ingest_spans(
+                state.run_id,
+                [{
+                    "id": span.id,
+                    **({"parentId": span.parent_id} if span.parent_id else {}),
+                    "name": span.name,
+                    "type": span.type,
+                    "status": status,
+                    "startedAt": span.started_at,
+                    "endedAt": _now(),
+                    **({"tokens": tokens} if tokens else {}),
+                    **({"model": model} if model else {}),
+                    **({"input": span.input} if span.input is not None else {}),
+                    **({"output": _safe_value(output)} if output is not None else {}),
+                    **({"error": {"message": str(error)}} if error else {}),
+                    "attributes": span.attributes,
+                }],
+            )
+            if is_root:
+                self.client.runs.end(state.run_id, status=status, **({"output": _safe_value(output)} if output is not None else {}))
+                with self._lock:
+                    for langchain_id, mapped in list(self._states.items()):
+                        if mapped is state:
+                            del self._states[langchain_id]
+        except Exception:
+            return
+
+    def on_chain_start(self, serialized: dict[str, Any], inputs: dict[str, Any], *, run_id: UUID, parent_run_id: Optional[UUID] = None, tags: Optional[list[str]] = None, metadata: Optional[dict[str, Any]] = None, **_: Any) -> None:
+        self._start("workflow_step", run_id, parent_run_id, serialized.get("name", "chain"), inputs, tags, metadata)
+
+    def on_chain_end(self, outputs: dict[str, Any], *, run_id: UUID, **_: Any) -> None:
+        self._finish(run_id, output=outputs)
+
+    def on_chain_error(self, error: BaseException, *, run_id: UUID, **_: Any) -> None:
+        self._finish(run_id, error=error)
+
+    def on_llm_start(self, serialized: dict[str, Any], prompts: list[str], *, run_id: UUID, parent_run_id: Optional[UUID] = None, tags: Optional[list[str]] = None, metadata: Optional[dict[str, Any]] = None, **_: Any) -> None:
+        self._start("model_call", run_id, parent_run_id, serialized.get("name", "llm"), {"prompts": prompts}, tags, metadata)
+
+    def on_llm_end(self, response: Any, *, run_id: UUID, **_: Any) -> None:
+        tokens, model = _extract_llm_usage(response)
+        self._finish(run_id, output=getattr(response, "llm_output", None), tokens=tokens, model=model)
+
+    def on_llm_error(self, error: BaseException, *, run_id: UUID, **_: Any) -> None:
+        self._finish(run_id, error=error)
+
+    def on_tool_start(self, serialized: dict[str, Any], input_str: str, *, run_id: UUID, parent_run_id: Optional[UUID] = None, tags: Optional[list[str]] = None, metadata: Optional[dict[str, Any]] = None, **_: Any) -> None:
+        self._start("tool_call", run_id, parent_run_id, serialized.get("name", "tool"), input_str, tags, metadata)
+
+    def on_tool_end(self, output: Any, *, run_id: UUID, **_: Any) -> None:
+        self._finish(run_id, output=output)
+
+    def on_tool_error(self, error: BaseException, *, run_id: UUID, **_: Any) -> None:
+        self._finish(run_id, error=error)

anlyon_langchain-0.1.0/src/anlyon_langchain/vectorstore.py

@@ -0,0 +1,74 @@
+"""
+AnlyonVectorStore  LangChain VectorStore backed by Anlyon Memory.
+
+add_texts() → client.memory.remember_many()
+similarity_search() → client.memory.recall()
+
+Thin wrapper  calls the SDK, never re-implements API logic.
+"""
+
+from __future__ import annotations
+from typing import Any, Optional, Sequence
+
+from langchain_core.documents import Document
+from langchain_core.vectorstores import VectorStore
+
+from anlyon import Client
+
+
+class AnlyonVectorStore(VectorStore):
+    """Anlyon Memory as a LangChain VectorStore."""
+
+    def __init__(self, client: Client, *, collection: Optional[str] = None) -> None:
+        self._client = client
+        self._collection = collection
+
+    def add_texts(
+        self,
+        texts: Sequence[str],
+        metadatas: Optional[list[dict]] = None,
+        **kwargs: Any,
+    ) -> list[str]:
+        items: list[dict[str, Any]] = []
+        for i, text in enumerate(texts):
+            item: dict[str, Any] = {"content": text}
+            if self._collection:
+                item["collection"] = self._collection
+            if metadatas and i < len(metadatas):
+                item["metadata"] = metadatas[i]
+            items.append(item)
+
+        result = self._client.memory.remember_many(items=items)
+        ids: list[str] = []
+        for r in (result.get("results", []) if isinstance(result, dict) else []):
+            if r.get("memoryId"):
+                ids.append(r["memoryId"])
+        return ids
+
+    def similarity_search(
+        self,
+        query: str,
+        k: int = 4,
+        **kwargs: Any,
+    ) -> list[Document]:
+        result = self._client.memory.recall(
+            query=query,
+            collection=self._collection,
+            top_k=k,
+            mode="semantic",
+        )
+        results = result.get("results", []) if isinstance(result, dict) else []
+        return [
+            Document(page_content=r.get("content", ""), metadata={"score": r.get("score", 0), **r.get("metadata", {})})
+            for r in results
+        ]
+
+    def add_documents(self, documents: Sequence[Document], **kwargs: Any) -> list[str]:
+        return self.add_texts(
+            [d.page_content for d in documents],
+            metadatas=[d.metadata for d in documents],
+        )
+
+    @classmethod
+    def from_texts(cls, texts: Sequence[str], embedding: Any, metadatas: Optional[list[dict]] = None, **kwargs: Any) -> "AnlyonVectorStore":
+        raise NotImplementedError("AnlyonVectorStore does not use embeddings  Anlyon manages them internally. Use the constructor with a Client.")

anlyon_langchain-0.1.0/tests/test_chat_history.py

@@ -0,0 +1,147 @@
+"""
+AnlyonChatMessageHistory  an Anlyon Session behind LangChain's chat history.
+respx mocks the HTTP layer.
+"""
+
+import json
+
+import respx
+import httpx
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
+
+from anlyon import Client
+from anlyon_langchain import AnlyonChatMessageHistory
+
+BASE_URL = "https://api.anlyon.com"
+MESSAGES = f"{BASE_URL}/api/v2/sessions/ses_1/messages"
+
+
+def message(index, role, content, tool_call_id=None):
+    return {
+        "index": index,
+        "role": role,
+        "content": content,
+        "toolCallId": tool_call_id,
+        "tokenCount": 4,
+        "metadata": {},
+        "createdAt": "2026-01-01T00:00:00.000Z",
+    }
+
+
+def page(messages):
+    return httpx.Response(200, json={"success": True, "data": messages, "pagination": {}})
+
+
+@respx.mock
+def test_messages_maps_session_roles_to_langchain_types():
+    respx.get(MESSAGES).mock(
+        return_value=page(
+            [
+                message(0, "system", "You are helpful."),
+                message(1, "user", "Where is my order?"),
+                message(2, "assistant", "Let me check."),
+                message(3, "tool", "shipped", tool_call_id="call_1"),
+            ]
+        )
+    )
+
+    with Client(api_key="anlyon_live_test") as client:
+        history = AnlyonChatMessageHistory(client, "ses_1")
+        messages = history.messages
+
+    assert [type(m) for m in messages] == [SystemMessage, HumanMessage, AIMessage, ToolMessage]
+    assert messages[1].content == "Where is my order?"
+    assert messages[3].tool_call_id == "call_1"
+
+
+@respx.mock
+def test_add_messages_appends_the_batch_in_one_call():
+    route = respx.post(MESSAGES).mock(
+        return_value=httpx.Response(
+            201, json={"success": True, "data": {"sessionId": "ses_1", "appended": 2}}
+        )
+    )
+
+    with Client(api_key="anlyon_live_test") as client:
+        history = AnlyonChatMessageHistory(client, "ses_1")
+        history.add_messages([HumanMessage(content="hi"), AIMessage(content="hello")])
+
+    assert route.call_count == 1
+    assert json.loads(route.calls.last.request.content) == {
+        "messages": [
+            {"role": "user", "content": "hi"},
+            {"role": "assistant", "content": "hello"},
+        ]
+    }
+
+
+@respx.mock
+def test_add_messages_carries_the_tool_call_id():
+    route = respx.post(MESSAGES).mock(
+        return_value=httpx.Response(201, json={"success": True, "data": {"appended": 1}})
+    )
+
+    with Client(api_key="anlyon_live_test") as client:
+        AnlyonChatMessageHistory(client, "ses_1").add_messages(
+            [ToolMessage(content="shipped", tool_call_id="call_1")]
+        )
+
+    stored = json.loads(route.calls.last.request.content)["messages"][0]
+    assert stored == {"role": "tool", "content": "shipped", "toolCallId": "call_1"}
+
+
+@respx.mock
+def test_multimodal_content_is_stored_as_its_text_parts():
+    route = respx.post(MESSAGES).mock(
+        return_value=httpx.Response(201, json={"success": True, "data": {"appended": 1}})
+    )
+
+    with Client(api_key="anlyon_live_test") as client:
+        AnlyonChatMessageHistory(client, "ses_1").add_messages(
+            [
+                HumanMessage(
+                    content=[
+                        {"type": "text", "text": "What is in this image?"},
+                        {"type": "image_url", "image_url": {"url": "https://x/y.png"}},
+                    ]
+                )
+            ]
+        )
+
+    stored = json.loads(route.calls.last.request.content)["messages"][0]
+    assert stored["content"] == "What is in this image?"
+
+
+@respx.mock
+def test_add_messages_with_nothing_makes_no_call():
+    with Client(api_key="anlyon_live_test") as client:
+        # No routes registered  an HTTP call would fail the test.
+        AnlyonChatMessageHistory(client, "ses_1").add_messages([])
+
+
+@respx.mock
+def test_clear_truncates_the_thread_but_keeps_the_session():
+    route = respx.delete(MESSAGES).mock(
+        return_value=httpx.Response(
+            200, json={"success": True, "data": {"sessionId": "ses_1", "deleted": 3}}
+        )
+    )
+
+    with Client(api_key="anlyon_live_test") as client:
+        AnlyonChatMessageHistory(client, "ses_1").clear()
+
+    assert route.called
+
+
+@respx.mock
+def test_messages_pages_through_a_long_thread():
+    first = [message(i, "user", f"m{i}") for i in range(200)]
+    second = [message(200, "user", "m200")]
+    route = respx.get(MESSAGES).mock(side_effect=[page(first), page(second)])
+
+    with Client(api_key="anlyon_live_test") as client:
+        messages = AnlyonChatMessageHistory(client, "ses_1").messages
+
+    assert len(messages) == 201
+    assert route.call_count == 2
+    assert route.calls[1].request.url.params["offset"] == "200"

anlyon_langchain-0.1.0/tests/test_tracing.py

@@ -0,0 +1,115 @@
+from types import SimpleNamespace
+from uuid import UUID
+
+from anlyon_langchain import AnlyonTracer
+
+
+class _Runs:
+    def __init__(self) -> None:
+        self.started: list[dict] = []
+        self.spans: list[tuple[str, list[dict]]] = []
+        self.ended: list[tuple[str, dict]] = []
+
+    def start(self, **kwargs):
+        self.started.append(kwargs)
+        return SimpleNamespace(data={"id": "run_langchain"})
+
+    def ingest_spans(self, run_id, spans):
+        self.spans.append((run_id, spans))
+
+    def end(self, run_id, **kwargs):
+        self.ended.append((run_id, kwargs))
+
+
+class _Client:
+    def __init__(self) -> None:
+        self.runs = _Runs()
+
+
+def test_tracer_creates_a_run_and_parent_linked_chain_llm_tool_spans() -> None:
+    client = _Client()
+    tracer = AnlyonTracer(client, application="support-agent")
+    root = UUID("00000000-0000-0000-0000-000000000001")
+    llm = UUID("00000000-0000-0000-0000-000000000002")
+    tool = UUID("00000000-0000-0000-0000-000000000003")
+
+    tracer.on_chain_start({"name": "agent"}, {"question": "Where is my order?"}, run_id=root, tags=["prod"])
+    tracer.on_llm_start({"name": "gpt"}, ["answer"], run_id=llm, parent_run_id=root)
+    tracer.on_llm_end(SimpleNamespace(llm_output={"model": "gpt"}), run_id=llm)
+    tracer.on_tool_start({"name": "lookup_order"}, "123", run_id=tool, parent_run_id=root)
+    tracer.on_tool_end({"state": "shipped"}, run_id=tool)
+    tracer.on_chain_end({"answer": "shipped"}, run_id=root)
+
+    assert client.runs.started == [{"name": "LangChain run", "application": "support-agent", "tags": ["prod"], "metadata": {"framework": "langchain"}}]
+    written = [batch[0] for _, batch in client.runs.spans]
+    created = [span for span in written if "endedAt" not in span]
+    completed = [span for span in written if "endedAt" in span]
+    assert [span["type"] for span in created] == ["workflow_step", "model_call", "tool_call"]
+    assert created[1]["parentId"] == "lc_00000000000000000000000000000001"
+    assert created[2]["parentId"] == "lc_00000000000000000000000000000001"
+    assert completed[0]["type"] == "model_call"
+    assert completed[0]["startedAt"] == created[1]["startedAt"]
+    assert client.runs.ended == [("run_langchain", {"status": "succeeded", "output": {"answer": "shipped"}})]
+
+
+def test_tracer_captures_openai_style_token_usage_and_model() -> None:
+    client = _Client()
+    tracer = AnlyonTracer(client)
+    llm = UUID("00000000-0000-0000-0000-000000000002")
+
+    tracer.on_llm_start({"name": "gpt"}, ["hi"], run_id=llm)
+    tracer.on_llm_end(
+        SimpleNamespace(
+            llm_output={
+                "model_name": "gpt-4o",
+                "token_usage": {"prompt_tokens": 120, "completion_tokens": 30, "total_tokens": 150},
+            }
+        ),
+        run_id=llm,
+    )
+
+    completed = [span for _, batch in client.runs.spans for span in batch if "endedAt" in span]
+    assert completed[0]["tokens"] == {"input": 120, "output": 30, "total": 150}
+    assert completed[0]["model"] == "gpt-4o"
+
+
+def test_tracer_captures_usage_metadata_from_generations() -> None:
+    client = _Client()
+    tracer = AnlyonTracer(client)
+    llm = UUID("00000000-0000-0000-0000-000000000003")
+
+    tracer.on_llm_start({"name": "claude"}, ["hi"], run_id=llm)
+    generation = SimpleNamespace(
+        message=SimpleNamespace(usage_metadata={"input_tokens": 200, "output_tokens": 45, "total_tokens": 245})
+    )
+    tracer.on_llm_end(
+        SimpleNamespace(llm_output=None, generations=[[generation]]),
+        run_id=llm,
+    )
+
+    completed = [span for _, batch in client.runs.spans for span in batch if "endedAt" in span]
+    assert completed[0]["tokens"] == {"input": 200, "output": 45, "total": 245}
+
+
+def test_tracer_omits_tokens_when_provider_reports_none() -> None:
+    client = _Client()
+    tracer = AnlyonTracer(client)
+    llm = UUID("00000000-0000-0000-0000-000000000004")
+
+    tracer.on_llm_start({"name": "gpt"}, ["hi"], run_id=llm)
+    tracer.on_llm_end(SimpleNamespace(llm_output={"model": "gpt"}), run_id=llm)
+
+    completed = [span for _, batch in client.runs.spans for span in batch if "endedAt" in span]
+    assert "tokens" not in completed[0]
+    assert completed[0]["model"] == "gpt"
+
+
+def test_tracer_swallows_observability_failures() -> None:
+    class FailingRuns(_Runs):
+        def start(self, **kwargs):
+            raise RuntimeError("network unavailable")
+
+    client = _Client()
+    client.runs = FailingRuns()
+    tracer = AnlyonTracer(client)
+    tracer.on_chain_start({"name": "agent"}, {}, run_id=UUID("00000000-0000-0000-0000-000000000001"))