neruva-record 0.1.0__tar.gz

neruva_record-0.1.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: neruva-record
+Version: 0.1.0
+Summary: Drop-in auto-record wrapper for the Anthropic Python SDK — every LLM turn captured to Neruva Memory. Recall later via the Neruva MCP / API. Cross-session, cross-vendor, portable.
+Author-email: Clouthier Simulation Labs <info@neruva.io>
+License: MIT
+Project-URL: Homepage, https://neruva.io/
+Project-URL: Documentation, https://neruva.io/docs/
+Project-URL: Source, https://github.com/CloutSimLabs/neruva
+Keywords: neruva,anthropic,claude,agent-memory,auto-record,observability,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.30; extra == "anthropic"
+
+# neruva-record
+
+Drop-in auto-record wrapper for the Anthropic Python SDK. Every
+`messages.create()` call captures both directions to a Neruva Memory
+namespace as a side-effect. Stop manually saving things; query the
+namespace later for "what did this agent do?"
+
+Pairs with [`@neruva/mcp`](https://www.npmjs.com/package/@neruva/mcp)
+(captures MCP tool calls). Together: full agent-loop capture.
+
+## Install
+
+```bash
+pip install neruva-record anthropic
+export NERUVA_API_KEY=...        # https://app.neruva.io
+```
+
+## Use
+
+```python
+import anthropic
+from neruva_record import auto_record
+
+client = auto_record(
+    anthropic.Anthropic(),
+    index="brain",                # one per user/account
+    namespace="main",             # one per agent (free-form)
+    ttl_days=30,                  # optional: auto-expire records after N days
+)
+
+# Drop-in: client behaves identically to bare Anthropic.
+response = client.messages.create(
+    model="claude-opus-4-7",
+    max_tokens=200,
+    messages=[{"role": "user", "content": "Hi!"}],
+)
+
+# Recording happened as a side-effect. Query it later via the MCP
+# or the REST API.
+```
+
+## Async
+
+```python
+from anthropic import AsyncAnthropic
+from neruva_record import auto_record
+
+client = auto_record(
+    AsyncAnthropic(),
+    index="brain", namespace="main",
+)
+
+response = await client.messages.create(
+    model="claude-opus-4-7", max_tokens=200,
+    messages=[{"role": "user", "content": "Hi!"}],
+)
+```
+
+## Naming convention
+
+| Field | What | Example |
+|---|---|---|
+| `index` | One per user/account. Agent-type-neutral. | `brain` |
+| `namespace` | One per agent the user runs. Free-form. | `main`, `support-bot`, `research` |
+
+```python
+# multi-agent setup -- same brain, one namespace per agent
+support  = auto_record(Anthropic(), index="brain", namespace="support-bot")
+research = auto_record(Anthropic(), index="brain", namespace="research")
+ops      = auto_record(Anthropic(), index="brain", namespace="orchestrator")
+```
+
+## What gets recorded
+
+Per LLM turn, one record:
+
+```json
+{
+  "id": "llm-<unix-ms>-<rand>",
+  "text": "USER: <user-message>\n\nASSISTANT: <response>",
+  "metadata": {
+    "kind": "llm_turn",
+    "vendor": "anthropic",
+    "model": "claude-opus-4-7",
+    "stop_reason": "end_turn",
+    "input_tokens": 12,
+    "output_tokens": 87,
+    "latency_ms": 1240,
+    "ts": <unix-ms>,
+    "_auto_expire_at": <unix-ms-or-omitted>
+  }
+}
+```
+
+User text is truncated at 600 chars, assistant at 1800 chars (for
+embedding quality and storage cost). The full conversation history
+isn't stored — only the most recent user message and the response.
+For full trace capture, also use
+[`@neruva/mcp`](https://www.npmjs.com/package/@neruva/mcp) which
+records every tool call alongside this.
+
+## Querying back
+
+Use the [Neruva MCP](https://www.npmjs.com/package/@neruva/mcp) or the
+REST API to query the recorded turns:
+
+```bash
+curl -X POST https://api.neruva.io/v1/indexes/brain/text/query \
+  -H "Api-Key: $NERUVA_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "namespace": "main",
+    "text": "what did I ask about deployment?",
+    "topK": 5,
+    "includeMetadata": true,
+    "filter": { "vendor": { "$eq": "anthropic" } }
+  }'
+```
+
+## Failure mode
+
+Recording is **fire-and-forget**. If the recording POST fails for any
+reason, your `messages.create()` call returns normally — the recorder
+swallows its own errors. You will never get fewer responses than you
+asked for; you may get fewer records than you'd see in a perfect world.
+
+## TTL / decay
+
+Set `ttl_days=N` and each record carries `_auto_expire_at = ts + N
+days`. The Neruva server-side decay sweep automatically removes
+records past their expiry on the next query/upsert touch (max once
+per 15 minutes per namespace). No background job to run.
+
+```python
+client = auto_record(
+    anthropic.Anthropic(),
+    index="brain", namespace="main",
+    ttl_days=7,    # only the last week is retained
+)
+```
+
+## Roadmap
+
+- v0.1: Anthropic Python (sync + async, non-streaming)
+- v0.2: Anthropic streaming + tool-use turn capture
+- v0.3: OpenAI Python
+- v0.4: Google Gemini Python
+- v0.5: TypeScript versions of all the above
+- v1.0: Stable API, security audit
+
+## Related
+
+- [`@neruva/mcp`](https://www.npmjs.com/package/@neruva/mcp) — MCP tool-call auto-record
+- [`neruva-mcp`](https://pypi.org/project/neruva-mcp/) — Python MCP server
+- [`neruva.io/docs`](https://neruva.io/docs/) — full documentation
+
+## License
+
+MIT — Clouthier Simulation Labs.

neruva_record-0.1.0/README.md

@@ -0,0 +1,159 @@
+# neruva-record
+
+Drop-in auto-record wrapper for the Anthropic Python SDK. Every
+`messages.create()` call captures both directions to a Neruva Memory
+namespace as a side-effect. Stop manually saving things; query the
+namespace later for "what did this agent do?"
+
+Pairs with [`@neruva/mcp`](https://www.npmjs.com/package/@neruva/mcp)
+(captures MCP tool calls). Together: full agent-loop capture.
+
+## Install
+
+```bash
+pip install neruva-record anthropic
+export NERUVA_API_KEY=...        # https://app.neruva.io
+```
+
+## Use
+
+```python
+import anthropic
+from neruva_record import auto_record
+
+client = auto_record(
+    anthropic.Anthropic(),
+    index="brain",                # one per user/account
+    namespace="main",             # one per agent (free-form)
+    ttl_days=30,                  # optional: auto-expire records after N days
+)
+
+# Drop-in: client behaves identically to bare Anthropic.
+response = client.messages.create(
+    model="claude-opus-4-7",
+    max_tokens=200,
+    messages=[{"role": "user", "content": "Hi!"}],
+)
+
+# Recording happened as a side-effect. Query it later via the MCP
+# or the REST API.
+```
+
+## Async
+
+```python
+from anthropic import AsyncAnthropic
+from neruva_record import auto_record
+
+client = auto_record(
+    AsyncAnthropic(),
+    index="brain", namespace="main",
+)
+
+response = await client.messages.create(
+    model="claude-opus-4-7", max_tokens=200,
+    messages=[{"role": "user", "content": "Hi!"}],
+)
+```
+
+## Naming convention
+
+| Field | What | Example |
+|---|---|---|
+| `index` | One per user/account. Agent-type-neutral. | `brain` |
+| `namespace` | One per agent the user runs. Free-form. | `main`, `support-bot`, `research` |
+
+```python
+# multi-agent setup -- same brain, one namespace per agent
+support  = auto_record(Anthropic(), index="brain", namespace="support-bot")
+research = auto_record(Anthropic(), index="brain", namespace="research")
+ops      = auto_record(Anthropic(), index="brain", namespace="orchestrator")
+```
+
+## What gets recorded
+
+Per LLM turn, one record:
+
+```json
+{
+  "id": "llm-<unix-ms>-<rand>",
+  "text": "USER: <user-message>\n\nASSISTANT: <response>",
+  "metadata": {
+    "kind": "llm_turn",
+    "vendor": "anthropic",
+    "model": "claude-opus-4-7",
+    "stop_reason": "end_turn",
+    "input_tokens": 12,
+    "output_tokens": 87,
+    "latency_ms": 1240,
+    "ts": <unix-ms>,
+    "_auto_expire_at": <unix-ms-or-omitted>
+  }
+}
+```
+
+User text is truncated at 600 chars, assistant at 1800 chars (for
+embedding quality and storage cost). The full conversation history
+isn't stored — only the most recent user message and the response.
+For full trace capture, also use
+[`@neruva/mcp`](https://www.npmjs.com/package/@neruva/mcp) which
+records every tool call alongside this.
+
+## Querying back
+
+Use the [Neruva MCP](https://www.npmjs.com/package/@neruva/mcp) or the
+REST API to query the recorded turns:
+
+```bash
+curl -X POST https://api.neruva.io/v1/indexes/brain/text/query \
+  -H "Api-Key: $NERUVA_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "namespace": "main",
+    "text": "what did I ask about deployment?",
+    "topK": 5,
+    "includeMetadata": true,
+    "filter": { "vendor": { "$eq": "anthropic" } }
+  }'
+```
+
+## Failure mode
+
+Recording is **fire-and-forget**. If the recording POST fails for any
+reason, your `messages.create()` call returns normally — the recorder
+swallows its own errors. You will never get fewer responses than you
+asked for; you may get fewer records than you'd see in a perfect world.
+
+## TTL / decay
+
+Set `ttl_days=N` and each record carries `_auto_expire_at = ts + N
+days`. The Neruva server-side decay sweep automatically removes
+records past their expiry on the next query/upsert touch (max once
+per 15 minutes per namespace). No background job to run.
+
+```python
+client = auto_record(
+    anthropic.Anthropic(),
+    index="brain", namespace="main",
+    ttl_days=7,    # only the last week is retained
+)
+```
+
+## Roadmap
+
+- v0.1: Anthropic Python (sync + async, non-streaming)
+- v0.2: Anthropic streaming + tool-use turn capture
+- v0.3: OpenAI Python
+- v0.4: Google Gemini Python
+- v0.5: TypeScript versions of all the above
+- v1.0: Stable API, security audit
+
+## Related
+
+- [`@neruva/mcp`](https://www.npmjs.com/package/@neruva/mcp) — MCP tool-call auto-record
+- [`neruva-mcp`](https://pypi.org/project/neruva-mcp/) — Python MCP server
+- [`neruva.io/docs`](https://neruva.io/docs/) — full documentation
+
+## License
+
+MIT — Clouthier Simulation Labs.

neruva_record-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "neruva-record"
+version = "0.1.0"
+description = "Drop-in auto-record wrapper for the Anthropic Python SDK — every LLM turn captured to Neruva Memory. Recall later via the Neruva MCP / API. Cross-session, cross-vendor, portable."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "Clouthier Simulation Labs", email = "info@neruva.io" },
+]
+keywords = [
+    "neruva",
+    "anthropic",
+    "claude",
+    "agent-memory",
+    "auto-record",
+    "observability",
+    "llm",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+anthropic = ["anthropic>=0.30"]
+
+[project.urls]
+Homepage = "https://neruva.io/"
+Documentation = "https://neruva.io/docs/"
+Source = "https://github.com/CloutSimLabs/neruva"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+neruva_record = ["py.typed"]

neruva_record-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

neruva_record-0.1.0/src/neruva_record/__init__.py

@@ -0,0 +1,39 @@
+"""Neruva auto-record SDK wrappers.
+
+Drop-in observability for LLM clients. Every turn is upserted to a
+Neruva Memory namespace as a side-effect, with rich metadata so you
+can recall, replay, and audit later.
+
+Currently supported:
+
+    auto_record(client, ...)   Anthropic Python SDK (sync + async)
+
+More vendors (OpenAI, Google, xAI/Mistral) ship in subsequent releases.
+
+Quick start:
+
+    import anthropic
+    from neruva_record import auto_record
+
+    client = auto_record(
+        anthropic.Anthropic(),
+        index="brain",
+        namespace="main",
+        ttl_days=30,        # optional: auto-expire records after N days
+    )
+
+    # client behaves identically to bare Anthropic; recording is a side-effect
+    response = client.messages.create(
+        model="claude-opus-4-7",
+        max_tokens=200,
+        messages=[{"role": "user", "content": "Hi!"}],
+    )
+
+Set ``NERUVA_API_KEY`` in the environment, or pass ``neruva_api_key=...``.
+"""
+from __future__ import annotations
+
+from .anthropic import auto_record
+
+__all__ = ["auto_record"]
+__version__ = "0.1.0"

neruva_record-0.1.0/src/neruva_record/_recorder.py

@@ -0,0 +1,112 @@
+"""Internal recorder: HTTP client + record formatting.
+
+Used by the per-vendor wrappers (anthropic, openai, ...) to ship
+captured turns to a Neruva Memory namespace via fire-and-forget HTTP
+POSTs. Failures are swallowed -- recording must never break the
+user's call.
+"""
+from __future__ import annotations
+
+import os
+import time
+from typing import Any, Optional
+from urllib.parse import quote
+
+import httpx
+
+
+_DEFAULT_URL = "https://api.neruva.io"
+
+
+class Recorder:
+    """Holds connection state for a single (index, namespace) target."""
+
+    def __init__(
+        self,
+        api_key: str,
+        index: str,
+        namespace: str = "",
+        ttl_days: Optional[int] = None,
+        base_url: Optional[str] = None,
+        timeout: float = 10.0,
+    ) -> None:
+        if not api_key:
+            raise ValueError(
+                "neruva-record requires NERUVA_API_KEY. "
+                "Set the env var or pass neruva_api_key=... to auto_record()."
+            )
+        if not index:
+            raise ValueError("auto_record(index=...) is required")
+        self.api_key = api_key
+        self.index = index
+        self.namespace = namespace or ""
+        self.ttl_days = ttl_days if (ttl_days and ttl_days > 0) else None
+        self.base_url = (base_url or os.environ.get(
+            "NERUVA_URL", _DEFAULT_URL,
+        )).rstrip("/")
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            headers={
+                "Api-Key": self.api_key,
+                "Content-Type": "application/json",
+            },
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        try:
+            self._client.close()
+        except Exception:
+            pass
+
+    def upsert_turn(
+        self,
+        record_id: str,
+        text: str,
+        metadata: dict[str, Any],
+    ) -> None:
+        """POST a single turn record. Swallows all errors silently."""
+        if self.ttl_days and "_auto_expire_at" not in metadata:
+            metadata = {
+                **metadata,
+                "_auto_expire_at": int(time.time() * 1000) + self.ttl_days * 86_400_000,
+            }
+        path = f"/v1/indexes/{quote(self.index, safe='')}/text/upsert"
+        try:
+            self._client.post(
+                path,
+                json={
+                    "namespace": self.namespace,
+                    "items": [{
+                        "id": record_id,
+                        "text": text,
+                        "metadata": metadata,
+                    }],
+                },
+            )
+        except Exception:
+            # Never break the caller.
+            pass
+
+
+def make_recorder(
+    *,
+    api_key: Optional[str],
+    index: str,
+    namespace: str = "",
+    ttl_days: Optional[int] = None,
+    base_url: Optional[str] = None,
+) -> Recorder:
+    """Build a Recorder, resolving API key from env if not passed."""
+    key = api_key or os.environ.get("NERUVA_API_KEY")
+    return Recorder(
+        api_key=key or "",
+        index=index,
+        namespace=namespace,
+        ttl_days=ttl_days,
+        base_url=base_url,
+    )
+
+
+def short(s: str, n: int) -> str:
+    return s if len(s) <= n else s[:n] + "..."

neruva_record-0.1.0/src/neruva_record/anthropic.py

@@ -0,0 +1,205 @@
+"""Anthropic Python SDK auto-record wrapper.
+
+Drop-in: every ``client.messages.create()`` call captures both the user
+message and the assistant response into a Neruva Memory namespace.
+
+Synchronous and async (``AsyncAnthropic``) clients are both supported.
+Streaming (``messages.stream()``) is not yet recorded -- coming in a
+later release.
+"""
+from __future__ import annotations
+
+import os
+import time
+import uuid
+from typing import Any, Optional, TypeVar
+
+from ._recorder import Recorder, make_recorder, short
+
+
+C = TypeVar("C")
+
+
+_USER_PREVIEW = 600
+_ASSISTANT_PREVIEW = 1800
+
+
+def _extract_user_text(messages: Any) -> str:
+    """Pull the most recent user-role message text out of a messages list."""
+    if not isinstance(messages, list):
+        return ""
+    for msg in reversed(messages):
+        if not isinstance(msg, dict) or msg.get("role") != "user":
+            continue
+        content = msg.get("content")
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts = []
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "text":
+                    parts.append(str(block.get("text", "")))
+            return " ".join(parts)
+        return str(content) if content is not None else ""
+    return ""
+
+
+def _extract_assistant_text(response: Any) -> str:
+    """Pull the assistant text out of an Anthropic Messages response."""
+    content = getattr(response, "content", None)
+    if not content:
+        return ""
+    parts = []
+    for block in content:
+        # Object form (anthropic SDK) or dict form (raw API).
+        btype = getattr(block, "type", None) or (
+            block.get("type") if isinstance(block, dict) else None
+        )
+        if btype == "text":
+            text = getattr(block, "text", None) or (
+                block.get("text") if isinstance(block, dict) else None
+            )
+            if text:
+                parts.append(str(text))
+    return "\n".join(parts)
+
+
+def _build_record(
+    request_kwargs: dict[str, Any],
+    response: Any,
+    latency_ms: int,
+) -> tuple[str, str, dict[str, Any]]:
+    """Return (record_id, text, metadata) for one turn."""
+    user_text = _extract_user_text(request_kwargs.get("messages"))
+    asst_text = _extract_assistant_text(response)
+    text = (
+        f"USER: {short(user_text, _USER_PREVIEW)}\n\n"
+        f"ASSISTANT: {short(asst_text, _ASSISTANT_PREVIEW)}"
+    )
+
+    usage = getattr(response, "usage", None)
+    input_tokens = getattr(usage, "input_tokens", None) if usage else None
+    output_tokens = getattr(usage, "output_tokens", None) if usage else None
+
+    meta: dict[str, Any] = {
+        "kind": "llm_turn",
+        "vendor": "anthropic",
+        "model": request_kwargs.get("model"),
+        "stop_reason": getattr(response, "stop_reason", None),
+        "input_tokens": int(input_tokens) if input_tokens is not None else None,
+        "output_tokens": int(output_tokens) if output_tokens is not None else None,
+        "latency_ms": int(latency_ms),
+        "ts": int(time.time() * 1000),
+    }
+    # Strip None values for clean storage
+    meta = {k: v for k, v in meta.items() if v is not None}
+
+    rid = f"llm-{int(time.time() * 1000)}-{uuid.uuid4().hex[:8]}"
+    return rid, text, meta
+
+
+def _wrap_messages_create(client: Any, recorder: Recorder) -> None:
+    """Replace client.messages.create with a recording version."""
+    original_create = client.messages.create
+
+    def wrapped(**kwargs):
+        t0 = time.perf_counter()
+        response = original_create(**kwargs)
+        latency_ms = int((time.perf_counter() - t0) * 1000)
+        try:
+            rid, text, meta = _build_record(kwargs, response, latency_ms)
+            recorder.upsert_turn(rid, text, meta)
+        except Exception:
+            pass  # never break the caller
+        return response
+
+    client.messages.create = wrapped
+
+
+def _wrap_messages_create_async(client: Any, recorder: Recorder) -> None:
+    """Replace AsyncAnthropic client.messages.create with a recording version."""
+    original_create = client.messages.create
+
+    async def wrapped(**kwargs):
+        t0 = time.perf_counter()
+        response = await original_create(**kwargs)
+        latency_ms = int((time.perf_counter() - t0) * 1000)
+        try:
+            rid, text, meta = _build_record(kwargs, response, latency_ms)
+            recorder.upsert_turn(rid, text, meta)
+        except Exception:
+            pass
+        return response
+
+    client.messages.create = wrapped
+
+
+def auto_record(
+    client: C,
+    *,
+    index: str,
+    namespace: str = "",
+    ttl_days: Optional[int] = None,
+    neruva_api_key: Optional[str] = None,
+    neruva_url: Optional[str] = None,
+) -> C:
+    """Wrap an Anthropic ``Anthropic`` or ``AsyncAnthropic`` client so every
+    ``messages.create()`` call upserts the turn into Neruva Memory.
+
+    The wrapped client behaves identically to the original; recording
+    happens as a side-effect via fire-and-forget HTTP POST. Errors in
+    recording are swallowed silently and never propagate to the caller.
+
+    Parameters
+    ----------
+    client : anthropic.Anthropic or anthropic.AsyncAnthropic
+        The client to wrap. The instance is mutated in place; the same
+        object is returned for chaining convenience.
+    index : str
+        Neruva Memory index name. Use one per user/account.
+    namespace : str, optional
+        Neruva namespace. Use one per agent (e.g. "main", "support-bot",
+        "research"). Defaults to empty string (the default namespace).
+    ttl_days : int, optional
+        If set, each recorded turn carries ``_auto_expire_at`` metadata
+        and the Neruva server-side decay sweep removes records older
+        than ``ttl_days`` days.
+    neruva_api_key : str, optional
+        Neruva API key. Falls back to the ``NERUVA_API_KEY`` env var.
+    neruva_url : str, optional
+        Neruva API base URL. Falls back to the ``NERUVA_URL`` env var
+        or ``https://api.neruva.io``.
+
+    Returns
+    -------
+    The same client instance, with ``messages.create`` wrapped.
+
+    Example
+    -------
+    >>> import anthropic
+    >>> from neruva_record import auto_record
+    >>> client = auto_record(
+    ...     anthropic.Anthropic(),
+    ...     index="brain", namespace="main", ttl_days=30,
+    ... )
+    >>> response = client.messages.create(
+    ...     model="claude-opus-4-7", max_tokens=200,
+    ...     messages=[{"role": "user", "content": "Hi"}],
+    ... )
+    """
+    recorder = make_recorder(
+        api_key=neruva_api_key, index=index, namespace=namespace,
+        ttl_days=ttl_days, base_url=neruva_url,
+    )
+
+    # Detect sync vs async by class name -- avoids requiring anthropic
+    # to be installed at import time.
+    cls_name = type(client).__name__
+    if "Async" in cls_name:
+        _wrap_messages_create_async(client, recorder)
+    else:
+        _wrap_messages_create(client, recorder)
+
+    # Stash recorder on the client so users can introspect / close it.
+    setattr(client, "_neruva_recorder", recorder)
+    return client

neruva_record-0.1.0/src/neruva_record.egg-info/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: neruva-record
+Version: 0.1.0
+Summary: Drop-in auto-record wrapper for the Anthropic Python SDK — every LLM turn captured to Neruva Memory. Recall later via the Neruva MCP / API. Cross-session, cross-vendor, portable.
+Author-email: Clouthier Simulation Labs <info@neruva.io>
+License: MIT
+Project-URL: Homepage, https://neruva.io/
+Project-URL: Documentation, https://neruva.io/docs/
+Project-URL: Source, https://github.com/CloutSimLabs/neruva
+Keywords: neruva,anthropic,claude,agent-memory,auto-record,observability,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.30; extra == "anthropic"
+
+# neruva-record
+
+Drop-in auto-record wrapper for the Anthropic Python SDK. Every
+`messages.create()` call captures both directions to a Neruva Memory
+namespace as a side-effect. Stop manually saving things; query the
+namespace later for "what did this agent do?"
+
+Pairs with [`@neruva/mcp`](https://www.npmjs.com/package/@neruva/mcp)
+(captures MCP tool calls). Together: full agent-loop capture.
+
+## Install
+
+```bash
+pip install neruva-record anthropic
+export NERUVA_API_KEY=...        # https://app.neruva.io
+```
+
+## Use
+
+```python
+import anthropic
+from neruva_record import auto_record
+
+client = auto_record(
+    anthropic.Anthropic(),
+    index="brain",                # one per user/account
+    namespace="main",             # one per agent (free-form)
+    ttl_days=30,                  # optional: auto-expire records after N days
+)
+
+# Drop-in: client behaves identically to bare Anthropic.
+response = client.messages.create(
+    model="claude-opus-4-7",
+    max_tokens=200,
+    messages=[{"role": "user", "content": "Hi!"}],
+)
+
+# Recording happened as a side-effect. Query it later via the MCP
+# or the REST API.
+```
+
+## Async
+
+```python
+from anthropic import AsyncAnthropic
+from neruva_record import auto_record
+
+client = auto_record(
+    AsyncAnthropic(),
+    index="brain", namespace="main",
+)
+
+response = await client.messages.create(
+    model="claude-opus-4-7", max_tokens=200,
+    messages=[{"role": "user", "content": "Hi!"}],
+)
+```
+
+## Naming convention
+
+| Field | What | Example |
+|---|---|---|
+| `index` | One per user/account. Agent-type-neutral. | `brain` |
+| `namespace` | One per agent the user runs. Free-form. | `main`, `support-bot`, `research` |
+
+```python
+# multi-agent setup -- same brain, one namespace per agent
+support  = auto_record(Anthropic(), index="brain", namespace="support-bot")
+research = auto_record(Anthropic(), index="brain", namespace="research")
+ops      = auto_record(Anthropic(), index="brain", namespace="orchestrator")
+```
+
+## What gets recorded
+
+Per LLM turn, one record:
+
+```json
+{
+  "id": "llm-<unix-ms>-<rand>",
+  "text": "USER: <user-message>\n\nASSISTANT: <response>",
+  "metadata": {
+    "kind": "llm_turn",
+    "vendor": "anthropic",
+    "model": "claude-opus-4-7",
+    "stop_reason": "end_turn",
+    "input_tokens": 12,
+    "output_tokens": 87,
+    "latency_ms": 1240,
+    "ts": <unix-ms>,
+    "_auto_expire_at": <unix-ms-or-omitted>
+  }
+}
+```
+
+User text is truncated at 600 chars, assistant at 1800 chars (for
+embedding quality and storage cost). The full conversation history
+isn't stored — only the most recent user message and the response.
+For full trace capture, also use
+[`@neruva/mcp`](https://www.npmjs.com/package/@neruva/mcp) which
+records every tool call alongside this.
+
+## Querying back
+
+Use the [Neruva MCP](https://www.npmjs.com/package/@neruva/mcp) or the
+REST API to query the recorded turns:
+
+```bash
+curl -X POST https://api.neruva.io/v1/indexes/brain/text/query \
+  -H "Api-Key: $NERUVA_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "namespace": "main",
+    "text": "what did I ask about deployment?",
+    "topK": 5,
+    "includeMetadata": true,
+    "filter": { "vendor": { "$eq": "anthropic" } }
+  }'
+```
+
+## Failure mode
+
+Recording is **fire-and-forget**. If the recording POST fails for any
+reason, your `messages.create()` call returns normally — the recorder
+swallows its own errors. You will never get fewer responses than you
+asked for; you may get fewer records than you'd see in a perfect world.
+
+## TTL / decay
+
+Set `ttl_days=N` and each record carries `_auto_expire_at = ts + N
+days`. The Neruva server-side decay sweep automatically removes
+records past their expiry on the next query/upsert touch (max once
+per 15 minutes per namespace). No background job to run.
+
+```python
+client = auto_record(
+    anthropic.Anthropic(),
+    index="brain", namespace="main",
+    ttl_days=7,    # only the last week is retained
+)
+```
+
+## Roadmap
+
+- v0.1: Anthropic Python (sync + async, non-streaming)
+- v0.2: Anthropic streaming + tool-use turn capture
+- v0.3: OpenAI Python
+- v0.4: Google Gemini Python
+- v0.5: TypeScript versions of all the above
+- v1.0: Stable API, security audit
+
+## Related
+
+- [`@neruva/mcp`](https://www.npmjs.com/package/@neruva/mcp) — MCP tool-call auto-record
+- [`neruva-mcp`](https://pypi.org/project/neruva-mcp/) — Python MCP server
+- [`neruva.io/docs`](https://neruva.io/docs/) — full documentation
+
+## License
+
+MIT — Clouthier Simulation Labs.

neruva_record-0.1.0/src/neruva_record.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/neruva_record/__init__.py
+src/neruva_record/_recorder.py
+src/neruva_record/anthropic.py
+src/neruva_record/py.typed
+src/neruva_record.egg-info/PKG-INFO
+src/neruva_record.egg-info/SOURCES.txt
+src/neruva_record.egg-info/dependency_links.txt
+src/neruva_record.egg-info/requires.txt
+src/neruva_record.egg-info/top_level.txt

neruva_record-0.1.0/src/neruva_record.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

neruva_record-0.1.0/src/neruva_record.egg-info/requires.txt

@@ -0,0 +1,4 @@
+httpx>=0.27
+
+[anthropic]
+anthropic>=0.30

neruva_record-0.1.0/src/neruva_record.egg-info/top_level.txt

@@ -0,0 +1 @@
+neruva_record