muninn-python 0.1.0__tar.gz → 0.2.4__tar.gz

muninn_python-0.2.4/.gitignore

@@ -0,0 +1,73 @@
+# Compiled binaries
+/muninn
+/muninndb
+/muninndb-server
+/bench
+/bench-test
+/eval
+/diag
+/muninndb-test
+
+# Embed assets — downloaded via `make fetch-assets`, not committed (too large)
+internal/plugin/embed/assets/*.dylib
+internal/plugin/embed/assets/*.so
+internal/plugin/embed/assets/*.dll
+internal/plugin/embed/assets/*.onnx
+internal/plugin/embed/assets/tokenizer.json
+
+# Binary artifacts — never commit
+*.muninn
+*.dylib
+*.so
+*.dll
+*.onnx
+*.exe
+
+# Local data directories
+muninndb-data/
+**/muninndb-data/
+/tmp/
+
+# Dependencies — install locally, never commit
+**/node_modules/
+**/.venv/
+**/venv/
+**/__pycache__/
+*.pyc
+*.bak
+
+# macOS
+.DS_Store
+
+# Go test cache
+*.test
+*.out
+
+# Worktrees
+.worktrees/
+
+# Bible eval testdata (downloaded via scripts/eval-bible-setup.sh)
+testdata/bible/kjv.json
+testdata/bible/cross-refs.tsv
+testdata/bible/cross-refs.csv
+testdata/bible/*.muninn
+
+# Planning and design docs — not committed
+docs/plans/
+
+# Evaluation tools and results — internal development only
+cmd/eval*/
+eval-results/
+scripts/eval-*
+/eval-bible
+/eval-temporal
+/eval-expert
+/eval-paraphrase
+/eval
+sdk/node/node_modules/
+sdk/node/dist/
+sdk/python/dist/
+sdk/python/*.egg-info/
+sdk/muninndb/dist/
+sdk/muninndb/*.egg-info/
+sdk/php/vendor/

{muninn_python-0.1.0 → muninn_python-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muninn-python
-Version: 0.1.0
+Version: 0.2.4
 Summary: Python SDK for MuninnDB — the cognitive memory database
 Project-URL: Homepage, https://muninndb.com
 Project-URL: Repository, https://github.com/scrypster/muninndb

{muninn_python-0.1.0 → muninn_python-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "muninn-python"
-version = "0.1.0"
+version = "0.2.4"
 description = "Python SDK for MuninnDB — the cognitive memory database"
 readme = "README.md"
 license = { text = "Apache-2.0" }

muninn_python-0.1.0/.gitignore

@@ -1,17 +0,0 @@
-# Binaries (root-level only, not cmd/muninndb/ directory)
-/muninndb
-/muninndb-server
-
-# Data directories
-muninndb-data/
-/tmp/
-
-# macOS
-.DS_Store
-
-# Go test cache
-*.test
-*.out
-
-# Worktrees
-.worktrees/

muninn_python-0.1.0/muninn/__init__.py

@@ -1,57 +0,0 @@
-"""MuninnDB Python SDK - Async client for cognitive memory database."""
-
-from .client import MuninnClient
-from .errors import (
-    MuninnAuthError,
-    MuninnConflict,
-    MuninnConnectionError,
-    MuninnError,
-    MuninnNotFound,
-    MuninnServerError,
-    MuninnTimeoutError,
-)
-from .types import (
-    ActivateRequest,
-    ActivateResponse,
-    ActivationItem,
-    BriefSentence,
-    CoherenceResult,
-    Push,
-    ReadResponse,
-    StatResponse,
-    WriteRequest,
-    WriteResponse,
-)
-
-__version__ = "0.1.0"
-
-# LangChain integration — only imported if langchain-core is installed.
-# Usage: from muninn.langchain import MuninnDBMemory
-def __getattr__(name: str):
-    if name == "MuninnDBMemory":
-        from .langchain import MuninnDBMemory
-        return MuninnDBMemory
-    raise AttributeError(f"module 'muninn' has no attribute {name!r}")
-
-__all__ = [
-    "MuninnClient",
-    "MuninnError",
-    "MuninnAuthError",
-    "MuninnConnectionError",
-    "MuninnNotFound",
-    "MuninnConflict",
-    "MuninnServerError",
-    "MuninnTimeoutError",
-    "WriteRequest",
-    "WriteResponse",
-    "ActivateRequest",
-    "ActivateResponse",
-    "ActivationItem",
-    "BriefSentence",
-    "ReadResponse",
-    "StatResponse",
-    "CoherenceResult",
-    "Push",
-    # Optional (requires langchain-core):
-    "MuninnDBMemory",
-]

muninn_python-0.1.0/muninn/client.py

@@ -1,499 +0,0 @@
-"""Async MuninnDB client."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import random
-
-import httpx
-
-from .errors import (
-    MuninnAuthError,
-    MuninnConnectionError,
-    MuninnConflict,
-    MuninnError,
-    MuninnNotFound,
-    MuninnServerError,
-    MuninnTimeoutError,
-)
-from .sse import SSEStream
-from .types import (
-    ActivateResponse,
-    ActivationItem,
-    BriefSentence,
-    CoherenceResult,
-    ReadResponse,
-    StatResponse,
-    WriteResponse,
-)
-
-
-class MuninnClient:
-    """Async client for MuninnDB REST API.
-
-    The client uses httpx for async HTTP and supports automatic retry with
-    exponential backoff for transient failures.
-
-    Usage:
-        async with MuninnClient("http://localhost:8476") as client:
-            eng_id = await client.write(
-                vault="default",
-                concept="memory concept",
-                content="memory content"
-            )
-            results = await client.activate(
-                vault="default",
-                context=["search query"]
-            )
-            async for push in client.subscribe(vault="default"):
-                print(f"New engram: {push.engram_id}")
-                break
-
-    Args:
-        base_url: Base URL of MuninnDB server (default: http://localhost:8476)
-        token: Optional Bearer token for authentication
-        timeout: Request timeout in seconds (default: 5.0)
-        max_retries: Maximum retry attempts for transient errors (default: 3)
-        retry_backoff: Initial backoff multiplier for retries (default: 0.5)
-        max_connections: Max concurrent connections (default: 20)
-        keepalive_connections: Max keepalive connections (default: 10)
-    """
-
-    def __init__(
-        self,
-        base_url: str = "http://localhost:8476",
-        token: str | None = None,
-        timeout: float = 5.0,
-        max_retries: int = 3,
-        retry_backoff: float = 0.5,
-        max_connections: int = 20,
-        keepalive_connections: int = 10,
-    ):
-        self._base_url = base_url.rstrip("/")
-        self._token = token
-        self._timeout = timeout
-        self._max_retries = max_retries
-        self._retry_backoff = retry_backoff
-        self._max_connections = max_connections
-        self._keepalive_connections = keepalive_connections
-        self._http: httpx.AsyncClient | None = None
-
-    async def __aenter__(self):
-        """Enter async context."""
-        self._http = httpx.AsyncClient(
-            base_url=self._base_url,
-            timeout=self._timeout,
-            limits=httpx.Limits(
-                max_connections=self._max_connections,
-                max_keepalive_connections=self._keepalive_connections,
-            ),
-            headers=self._default_headers(),
-        )
-        return self
-
-    async def __aexit__(self, *args):
-        """Exit async context."""
-        if self._http:
-            await self._http.aclose()
-
-    async def write(
-        self,
-        vault: str = "default",
-        concept: str = "",
-        content: str = "",
-        tags: list[str] | None = None,
-        confidence: float = 0.9,
-        stability: float = 0.5,
-    ) -> str:
-        """Write an engram to the database.
-
-        Args:
-            vault: Vault name (default: "default")
-            concept: Concept/title for this engram
-            content: Main content/body
-            tags: Optional list of tags for categorization
-            confidence: Confidence score 0-1 (default: 0.9)
-            stability: Stability score 0-1 (default: 0.5)
-
-        Returns:
-            ULID string ID of the created engram
-
-        Raises:
-            MuninnError: If write fails
-        """
-        body = {
-            "vault": vault,
-            "concept": concept,
-            "content": content,
-            "confidence": confidence,
-            "stability": stability,
-        }
-        if tags:
-            body["tags"] = tags
-
-        response = await self._request("POST", "/api/engrams", json=body)
-        return response.get("id", "")
-
-    async def activate(
-        self,
-        vault: str = "default",
-        context: list[str] | None = None,
-        max_results: int = 10,
-        threshold: float = 0.1,
-        max_hops: int = 0,
-        include_why: bool = False,
-        brief_mode: str = "auto",
-    ) -> ActivateResponse:
-        """Activate memory using semantic search and graph traversal.
-
-        Args:
-            vault: Vault name (default: "default")
-            context: List of query terms/context
-            max_results: Max results to return (default: 10)
-            threshold: Min activation score threshold (default: 0.1)
-            max_hops: Max graph hops to traverse (default: 0)
-            include_why: Include reasoning/why field (default: False)
-            brief_mode: Brief extraction mode - "auto", "extractive", "abstractive" (default: "auto")
-
-        Returns:
-            ActivateResponse with activations and optional brief
-
-        Raises:
-            MuninnError: If activation fails
-        """
-        if context is None:
-            context = []
-
-        body = {
-            "vault": vault,
-            "context": context,
-            "max_results": max_results,
-            "threshold": threshold,
-            "max_hops": max_hops,
-            "include_why": include_why,
-            "brief_mode": brief_mode,
-        }
-
-        response = await self._request("POST", "/api/activate", json=body)
-
-        # Support both snake_case (new) and PascalCase (old) field names for
-        # backward compatibility with servers that have not yet been updated.
-        raw_activations = response.get("activations") or response.get("Activations") or []
-        activations = [
-            ActivationItem(
-                id=item.get("id") or item.get("ID", ""),
-                concept=item.get("concept") or item.get("Concept", ""),
-                content=item.get("content") or item.get("Content", ""),
-                score=item.get("score") or item.get("Score", 0.0),
-                confidence=item.get("confidence") or item.get("Confidence", 0.0),
-                why=item.get("why") or item.get("Why"),
-                hop_path=item.get("hop_path") or item.get("HopPath"),
-                dormant=item.get("dormant") or item.get("Dormant", False),
-            )
-            for item in raw_activations
-        ]
-
-        brief = None
-        raw_brief = response.get("brief") or response.get("Brief")
-        if raw_brief:
-            brief = [
-                BriefSentence(
-                    engram_id=sent.get("engram_id") or sent.get("EngramID", ""),
-                    text=sent.get("text") or sent.get("Text", ""),
-                    score=sent.get("score") or sent.get("Score", 0.0),
-                )
-                for sent in raw_brief
-            ]
-
-        return ActivateResponse(
-            query_id=response.get("query_id") or response.get("QueryID", ""),
-            total_found=response.get("total_found") or response.get("TotalFound", 0),
-            activations=activations,
-            latency_ms=response.get("latency_ms") or response.get("LatencyMs", 0.0),
-            brief=brief,
-        )
-
-    async def read(self, id: str, vault: str = "default") -> ReadResponse:
-        """Read a specific engram by ID.
-
-        Args:
-            id: Engram ULID
-            vault: Vault name (default: "default")
-
-        Returns:
-            ReadResponse with engram details
-
-        Raises:
-            MuninnNotFound: If engram doesn't exist
-            MuninnError: If read fails
-        """
-        response = await self._request("GET", f"/api/engrams/{id}", params={"vault": vault})
-
-        coherence = response.get("coherence")
-        return ReadResponse(
-            id=response.get("id", ""),
-            concept=response.get("concept", ""),
-            content=response.get("content", ""),
-            confidence=response.get("confidence", 0.0),
-            relevance=response.get("relevance", 0.0),
-            stability=response.get("stability", 0.0),
-            access_count=response.get("access_count", 0),
-            tags=response.get("tags", []),
-            state=response.get("state", ""),
-            created_at=response.get("created_at", 0),
-            updated_at=response.get("updated_at", 0),
-            last_access=response.get("last_access"),
-        )
-
-    async def forget(self, id: str, vault: str = "default", hard: bool = False) -> bool:
-        """Delete an engram (soft or hard delete).
-
-        Args:
-            id: Engram ULID
-            vault: Vault name (default: "default")
-            hard: If True, hard delete (cannot recover). If False, soft delete (default: False)
-
-        Returns:
-            True if deletion successful
-
-        Raises:
-            MuninnNotFound: If engram doesn't exist
-            MuninnError: If deletion fails
-        """
-        if hard:
-            await self._request(
-                "POST",
-                f"/api/engrams/{id}/forget",
-                params={"vault": vault, "hard": "true"},
-            )
-        else:
-            await self._request(
-                "DELETE",
-                f"/api/engrams/{id}",
-                params={"vault": vault},
-            )
-        return True
-
-    async def link(
-        self,
-        source_id: str,
-        target_id: str,
-        vault: str = "default",
-        rel_type: int = 5,
-        weight: float = 1.0,
-    ) -> bool:
-        """Create an association/link between two engrams.
-
-        Args:
-            source_id: Source engram ULID
-            target_id: Target engram ULID
-            vault: Vault name (default: "default")
-            rel_type: Relationship type code (default: 5)
-            weight: Link weight/strength (default: 1.0)
-
-        Returns:
-            True if link created successfully
-
-        Raises:
-            MuninnError: If link creation fails
-        """
-        body = {
-            "vault": vault,
-            "source_id": source_id,
-            "target_id": target_id,
-            "rel_type": rel_type,
-            "weight": weight,
-        }
-        await self._request("POST", "/api/link", json=body)
-        return True
-
-    async def stats(self) -> StatResponse:
-        """Get database statistics including coherence scores.
-
-        Returns:
-            StatResponse with engram count, vault count, storage bytes, and coherence
-
-        Raises:
-            MuninnError: If stats request fails
-        """
-        response = await self._request("GET", "/api/stats")
-
-        coherence = None
-        if response.get("coherence"):
-            coherence = {
-                vault_name: CoherenceResult(
-                    score=data.get("score", 0.0),
-                    orphan_ratio=data.get("orphan_ratio", 0.0),
-                    contradiction_density=data.get("contradiction_density", 0.0),
-                    duplication_pressure=data.get("duplication_pressure", 0.0),
-                    decay_variance=data.get("decay_variance", 0.0),
-                    total_engrams=data.get("total_engrams", 0),
-                )
-                for vault_name, data in response["coherence"].items()
-            }
-
-        return StatResponse(
-            engram_count=response.get("engram_count", 0),
-            vault_count=response.get("vault_count", 0),
-            storage_bytes=response.get("storage_bytes", 0),
-            coherence=coherence,
-        )
-
-    def subscribe(
-        self,
-        vault: str = "default",
-        push_on_write: bool = True,
-        threshold: float = 0.0,
-    ) -> SSEStream:
-        """Subscribe to vault events via Server-Sent Events (SSE).
-
-        This returns an async iterable that yields Push events when engrams are
-        written to the vault. The stream automatically reconnects on network errors.
-
-        Usage:
-            stream = client.subscribe(vault="default")
-            async for push in stream:
-                print(f"New engram: {push.engram_id}")
-                if condition:
-                    await stream.close()
-
-        Args:
-            vault: Vault to subscribe to (default: "default")
-            push_on_write: Emit push events on new writes (default: True)
-            threshold: Min activation threshold for push events (default: 0.0)
-
-        Returns:
-            SSEStream async iterable
-
-        Raises:
-            MuninnError: If subscription fails
-        """
-        params = {
-            "vault": vault,
-            "push_on_write": str(push_on_write).lower(),
-        }
-        if threshold:
-            params["threshold"] = str(threshold)
-
-        return SSEStream(self, "/api/subscribe", params)
-
-    async def health(self) -> bool:
-        """Check if MuninnDB server is healthy.
-
-        Returns:
-            True if server responds with 200 OK
-
-        Raises:
-            MuninnError: If health check fails
-        """
-        try:
-            response = await self._request("GET", "/health")
-            return response.get("status") == "ok"
-        except MuninnError:
-            return False
-
-    async def _request(self, method: str, path: str, **kwargs) -> dict:
-        """Make an HTTP request with automatic retry logic.
-
-        Retries on transient errors (502, 503, 504, connection/read errors).
-        Does not retry on 4xx errors. Uses exponential backoff with jitter.
-
-        Args:
-            method: HTTP method (GET, POST, DELETE, etc)
-            path: URL path relative to base_url
-            **kwargs: Additional arguments to pass to httpx
-
-        Returns:
-            Parsed JSON response as dict
-
-        Raises:
-            MuninnAuthError: 401 Unauthorized
-            MuninnNotFound: 404 Not Found
-            MuninnConflict: 409 Conflict
-            MuninnServerError: 5xx errors
-            MuninnTimeoutError: Request timeout
-            MuninnConnectionError: Connection error
-            MuninnError: Other HTTP errors
-        """
-        if not self._http:
-            raise MuninnError("Client not initialized. Use 'async with' context manager.")
-
-        attempt = 0
-        while attempt <= self._max_retries:
-            try:
-                response = await self._http.request(method, path, **kwargs)
-                self._raise_for_status(response)
-                return response.json()
-
-            except (httpx.ConnectError, httpx.ReadError, httpx.RemoteProtocolError) as e:
-                if attempt >= self._max_retries:
-                    raise MuninnConnectionError(f"Connection failed: {str(e)}")
-                await self._backoff(attempt)
-                attempt += 1
-
-            except httpx.ReadTimeout as e:
-                if attempt >= self._max_retries:
-                    raise MuninnTimeoutError(f"Request timeout: {str(e)}")
-                await self._backoff(attempt)
-                attempt += 1
-
-            except httpx.HTTPStatusError as e:
-                # Don't retry on 4xx (except certain ones), do retry on 5xx
-                if 500 <= e.response.status_code < 600:
-                    if attempt >= self._max_retries:
-                        self._raise_for_status(e.response)
-                    await self._backoff(attempt)
-                    attempt += 1
-                else:
-                    self._raise_for_status(e.response)
-
-            except MuninnError:
-                raise
-
-        raise MuninnError("Max retries exceeded")
-
-    async def _backoff(self, attempt: int):
-        """Wait with exponential backoff + jitter.
-
-        Args:
-            attempt: Attempt number (0-indexed)
-        """
-        delay = self._retry_backoff * (2 ** attempt) + random.uniform(0, 0.1)
-        await asyncio.sleep(delay)
-
-    def _default_headers(self) -> dict:
-        """Build default request headers."""
-        headers = {"Content-Type": "application/json"}
-        if self._token:
-            headers["Authorization"] = f"Bearer {self._token}"
-        return headers
-
-    def _raise_for_status(self, response: httpx.Response):
-        """Convert httpx response to appropriate MuninnError.
-
-        Args:
-            response: httpx Response object
-
-        Raises:
-            Appropriate MuninnError subclass
-        """
-        if response.status_code == 401:
-            raise MuninnAuthError(
-                "Authentication required. Provide token= parameter to MuninnClient.",
-                401,
-            )
-        elif response.status_code == 404:
-            raise MuninnNotFound(f"Not found: {response.text}", 404)
-        elif response.status_code == 409:
-            raise MuninnConflict(f"Conflict: {response.text}", 409)
-        elif 500 <= response.status_code < 600:
-            raise MuninnServerError(
-                f"Server error {response.status_code}: {response.text}",
-                response.status_code,
-            )
-        elif response.status_code >= 400:
-            raise MuninnError(
-                f"Client error {response.status_code}: {response.text}",
-                response.status_code,
-            )

muninn_python-0.1.0/muninn/errors.py

@@ -1,47 +0,0 @@
-"""MuninnDB error types."""
-
-from typing import Optional
-
-
-class MuninnError(Exception):
-    """Base exception for all MuninnDB errors."""
-
-    def __init__(self, message: str, status_code: Optional[int] = None):
-        super().__init__(message)
-        self.status_code = status_code
-
-
-class MuninnConnectionError(MuninnError):
-    """Connection-related errors (network, SSL, DNS)."""
-
-    pass
-
-
-class MuninnAuthError(MuninnError):
-    """Authentication failed (401 Unauthorized)."""
-
-    pass
-
-
-class MuninnNotFound(MuninnError):
-    """Resource not found (404 Not Found)."""
-
-    pass
-
-
-class MuninnConflict(MuninnError):
-    """Request conflict (409 Conflict)."""
-
-    pass
-
-
-class MuninnServerError(MuninnError):
-    """Server error (5xx)."""
-
-    pass
-
-
-class MuninnTimeoutError(MuninnError):
-    """Request timeout."""
-
-    pass

muninn_python-0.1.0/muninn/langchain.py

@@ -1,184 +0,0 @@
-"""LangChain memory integration for MuninnDB.
-
-Provides MuninnDBMemory, a drop-in replacement for any LangChain memory backend.
-Unlike traditional backends (ConversationBufferMemory, etc.), MuninnDB applies
-cognitive primitives to retrieved context: relevance decays over time, frequently
-recalled memories strengthen, and associations form automatically from co-activation.
-
-Install:
-    pip install muninn-python[langchain]
-
-Usage:
-    from muninn.langchain import MuninnDBMemory
-    from langchain.chains import ConversationChain
-    from langchain_anthropic import ChatAnthropic
-
-    memory = MuninnDBMemory(vault="my-agent")
-    chain = ConversationChain(llm=ChatAnthropic(model="claude-haiku-4-5-20251001"), memory=memory)
-    chain.predict(input="What did we discuss about the payment service?")
-"""
-
-from __future__ import annotations
-
-import asyncio
-import concurrent.futures
-import textwrap
-from typing import Any, Dict, List, Optional
-
-try:
-    from langchain_core.memory import BaseMemory
-except ImportError:
-    try:
-        from langchain.memory import BaseMemory  # type: ignore[no-redef]
-    except ImportError as e:
-        raise ImportError(
-            "LangChain is required for MuninnDBMemory. "
-            "Install it with: pip install muninn-python[langchain]"
-        ) from e
-
-from .client import MuninnClient
-from .types import ActivationItem
-
-
-def _run_sync(coro: Any) -> Any:
-    """Run an async coroutine synchronously.
-
-    Handles both contexts where there is no event loop (plain scripts, pytest)
-    and contexts where one is already running (FastAPI, Jupyter, async test runners).
-    """
-    try:
-        asyncio.get_running_loop()
-        # Already inside an event loop — run in a fresh thread with its own loop.
-        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-            return pool.submit(asyncio.run, coro).result()
-    except RuntimeError:
-        # No running event loop — safe to call asyncio.run() directly.
-        return asyncio.run(coro)
-
-
-class MuninnDBMemory(BaseMemory):
-    """LangChain memory backend powered by MuninnDB.
-
-    Each conversation turn is stored as a single engram (human input + AI output).
-    On every load, MuninnDB activates the most relevant memories for the current
-    input using semantic similarity, Hebbian association weights, and decay curves —
-    returning only what is genuinely relevant right now, not a raw chat buffer.
-
-    Attributes:
-        base_url:       MuninnDB server URL (default: http://localhost:8475)
-        token:          Optional Bearer token if MCP auth is enabled
-        vault:          Vault name to store memories in (default: "default")
-        max_results:    Max memories to surface per activation (default: 10)
-        memory_key:     Key injected into chain inputs (default: "history")
-        input_key:      Input dict key holding the human message. Auto-detected
-                        if None (looks for "input", "question", "human_input", etc.)
-        human_prefix:   Prefix for human turns in stored engrams (default: "Human")
-        ai_prefix:      Prefix for AI turns in stored engrams (default: "AI")
-        return_docs:    If True, return ActivationItem objects instead of a string.
-                        Useful when you want to inspect scores or metadata.
-    """
-
-    base_url: str = "http://localhost:8475"
-    token: Optional[str] = None
-    vault: str = "default"
-    max_results: int = 10
-    memory_key: str = "history"
-    input_key: Optional[str] = None
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    return_docs: bool = False
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    # ── Public LangChain interface ───────────────────────────────────────────
-
-    @property
-    def memory_variables(self) -> List[str]:
-        return [self.memory_key]
-
-    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
-        """Retrieve relevant memories for the current input (synchronous)."""
-        return _run_sync(self.aload_memory_variables(inputs))
-
-    async def aload_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
-        """Retrieve relevant memories for the current input (async)."""
-        query = self._extract_input(inputs)
-        if not query:
-            return {self.memory_key: [] if self.return_docs else ""}
-
-        async with MuninnClient(self.base_url, token=self.token) as client:
-            result = await client.activate(
-                vault=self.vault,
-                context=[query],
-                max_results=self.max_results,
-                threshold=0.05,
-            )
-
-        if self.return_docs:
-            return {self.memory_key: result.activations}
-
-        return {self.memory_key: self._format_activations(result.activations)}
-
-    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, Any]) -> None:
-        """Store the current conversation turn (synchronous)."""
-        _run_sync(self.asave_context(inputs, outputs))
-
-    async def asave_context(
-        self, inputs: Dict[str, Any], outputs: Dict[str, Any]
-    ) -> None:
-        """Store the current conversation turn (async)."""
-        human_input = self._extract_input(inputs) or ""
-        ai_output = self._extract_output(outputs) or ""
-
-        # Concept = first 60 chars of the human turn (readable in the Web UI).
-        concept = (human_input[:57] + "...") if len(human_input) > 60 else human_input
-        content = f"{self.human_prefix}: {human_input}\n{self.ai_prefix}: {ai_output}"
-
-        async with MuninnClient(self.base_url, token=self.token) as client:
-            await client.write(vault=self.vault, concept=concept, content=content)
-
-    def clear(self) -> None:
-        """No-op: MuninnDB uses natural decay rather than explicit truncation.
-
-        Memories fade on their own as they stop being recalled. If you need
-        a hard reset, create a new vault or use a different vault name per session.
-        """
-
-    # ── Internal helpers ────────────────────────────────────────────────────
-
-    def _extract_input(self, inputs: Dict[str, Any]) -> Optional[str]:
-        """Extract the human message from the chain's input dict."""
-        if self.input_key:
-            return str(inputs.get(self.input_key, ""))
-        for key in ("input", "question", "human_input", "query", "message", "text"):
-            if key in inputs:
-                return str(inputs[key])
-        # Fall back to first string value.
-        for v in inputs.values():
-            if isinstance(v, str):
-                return v
-        return None
-
-    def _extract_output(self, outputs: Dict[str, Any]) -> Optional[str]:
-        """Extract the AI response from the chain's output dict."""
-        for key in ("output", "response", "answer", "text", "result", "generation"):
-            if key in outputs:
-                return str(outputs[key])
-        for v in outputs.values():
-            if isinstance(v, str):
-                return v
-        return None
-
-    def _format_activations(self, activations: List[ActivationItem]) -> str:
-        """Format activated memories as a context string for the LLM prompt."""
-        if not activations:
-            return ""
-
-        lines = ["[Relevant memory context from MuninnDB]"]
-        for item in activations:
-            # Wrap long content so it's readable in prompts.
-            wrapped = textwrap.fill(item.content, width=120, subsequent_indent="  ")
-            lines.append(f"- {wrapped}")
-        lines.append("[End of memory context]")
-        return "\n".join(lines)

muninn_python-0.1.0/muninn/sse.py

@@ -1,122 +0,0 @@
-"""Async SSE (Server-Sent Events) stream implementation with auto-reconnect."""
-
-import asyncio
-import json
-
-import httpx
-
-from .errors import MuninnConnectionError
-from .types import Push
-
-
-class SSEStream:
-    """Async SSE stream with automatic reconnection and Last-Event-ID tracking.
-
-    Usage:
-        stream = client.subscribe(vault="default")
-        async for push in stream:
-            print(push.engram_id)
-            if should_stop:
-                await stream.close()
-    """
-
-    def __init__(self, client_ref, url: str, params: dict):
-        self._client = client_ref
-        self._url = url
-        self._params = params
-        self._last_event_id: str | None = None
-        self._closed = False
-
-    async def close(self):
-        """Close the SSE stream."""
-        self._closed = True
-
-    def __aiter__(self):
-        """Iterate over SSE events."""
-        return self._stream()
-
-    async def _stream(self):
-        """Internal stream loop with automatic reconnection."""
-        backoff = 0.5
-        while not self._closed:
-            try:
-                headers = {"Accept": "text/event-stream"}
-                if self._last_event_id:
-                    headers["Last-Event-ID"] = self._last_event_id
-                if self._client._token:
-                    headers["Authorization"] = f"Bearer {self._client._token}"
-
-                async with self._client._http.stream(
-                    "GET",
-                    self._url,
-                    params=self._params,
-                    headers=headers,
-                    # connect + write have bounded timeouts; read=None allows
-                    # indefinite streaming without spurious disconnects.
-                    timeout=httpx.Timeout(connect=10.0, read=None, write=10.0, pool=5.0),
-                ) as resp:
-                    if resp.status_code != 200:
-                        raise httpx.HTTPStatusError(
-                            f"SSE stream failed with {resp.status_code}",
-                            request=resp.request,
-                            response=resp,
-                        )
-
-                    backoff = 0.5  # reset on successful connect
-                    event_type = "message"
-                    data_lines = []
-
-                    async for line in resp.aiter_lines():
-                        if self._closed:
-                            return
-
-                        line = line.strip()
-
-                        if line.startswith("event:"):
-                            event_type = line[6:].strip()
-                        elif line.startswith("data:"):
-                            data_lines.append(line[5:].strip())
-                        elif line.startswith("id:"):
-                            self._last_event_id = line[3:].strip()
-                        elif line == "":
-                            # Empty line marks end of event
-                            if data_lines:
-                                data_str = "\n".join(data_lines)
-                                try:
-                                    data = json.loads(data_str)
-                                    if event_type == "push":
-                                        yield Push(
-                                            subscription_id=data.get("subscription_id", ""),
-                                            trigger=data.get("trigger", ""),
-                                            push_number=data.get("push_number", 0),
-                                            engram_id=data.get("engram_id"),
-                                            at=data.get("at"),
-                                        )
-                                    # ignore subscribed and other event types
-                                except json.JSONDecodeError:
-                                    pass
-
-                            event_type = "message"
-                            data_lines = []
-
-            except httpx.HTTPStatusError as e:
-                # Fatal status codes: don't retry — surface immediately.
-                if e.response.status_code in (401, 403, 404):
-                    raise MuninnConnectionError(
-                        f"SSE stream failed with {e.response.status_code}: "
-                        f"{e.response.text}"
-                    ) from e
-                # 5xx and other server errors: backoff and retry.
-                if self._closed:
-                    return
-                await asyncio.sleep(min(backoff, 30.0))
-                backoff = min(backoff * 2, 30.0)
-            except (
-                httpx.ConnectError,
-                httpx.ReadError,
-                httpx.RemoteProtocolError,
-            ):
-                if self._closed:
-                    return
-                await asyncio.sleep(min(backoff, 30.0))
-                backoff = min(backoff * 2, 30.0)

muninn_python-0.1.0/muninn/types.py

@@ -1,132 +0,0 @@
-"""MuninnDB type definitions."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-
-@dataclass
-class WriteRequest:
-    """Request to write an engram."""
-
-    vault: str
-    concept: str
-    content: str
-    tags: Optional[List[str]] = None
-    confidence: float = 0.9
-    stability: float = 0.5
-    embedding: Optional[List[float]] = None
-    associations: Optional[Dict[str, Any]] = None
-
-
-@dataclass
-class WriteResponse:
-    """Response from writing an engram."""
-
-    id: str
-    created_at: int
-
-
-@dataclass
-class ActivateRequest:
-    """Request to activate memory."""
-
-    vault: str
-    context: List[str]
-    max_results: int = 10
-    threshold: float = 0.1
-    max_hops: int = 0
-    include_why: bool = False
-    brief_mode: str = "auto"
-
-
-@dataclass
-class ActivationItem:
-    """A single activated memory item."""
-
-    id: str
-    concept: str
-    content: str
-    score: float
-    confidence: float
-    score_components: Optional[Dict[str, float]] = None
-    why: Optional[str] = None
-    hop_path: Optional[List[str]] = None
-    dormant: bool = False
-
-
-@dataclass
-class BriefSentence:
-    """A sentence extracted by brief mode."""
-
-    engram_id: str
-    text: str
-    score: float
-
-
-@dataclass
-class ActivateResponse:
-    """Response from activating memory."""
-
-    query_id: str
-    total_found: int
-    activations: List[ActivationItem]
-    latency_ms: float = 0.0
-    brief: Optional[List[BriefSentence]] = None
-
-
-@dataclass
-class ReadResponse:
-    """Response from reading an engram."""
-
-    id: str
-    concept: str
-    content: str
-    confidence: float
-    relevance: float
-    stability: float
-    access_count: int
-    tags: List[str]
-    state: str
-    created_at: int
-    updated_at: int
-    last_access: Optional[int] = None
-    coherence: Optional[Dict[str, "CoherenceResult"]] = None
-    summary: Optional[str] = None
-    key_points: Optional[List[str]] = None
-    memory_type: Optional[int] = None
-    classification: Optional[int] = None
-
-
-@dataclass
-class CoherenceResult:
-    """Coherence metrics for a vault."""
-
-    score: float
-    orphan_ratio: float
-    contradiction_density: float
-    duplication_pressure: float
-    decay_variance: float
-    total_engrams: int
-
-
-@dataclass
-class StatResponse:
-    """Response from stats endpoint."""
-
-    engram_count: int
-    vault_count: int
-    storage_bytes: int
-    coherence: dict[str, CoherenceResult] | None = None
-
-
-@dataclass
-class Push:
-    """SSE push event from subscription."""
-
-    subscription_id: str
-    trigger: str
-    push_number: int
-    engram_id: Optional[str] = None
-    at: Optional[int] = None