polypack-mcp 0.1.0__tar.gz

polypack_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: polypack-mcp
+Version: 0.1.0
+Summary: MCP server exposing Polypack as persistent adaptive memory
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp<1.11,>=1.10
+Requires-Dist: anyio<4.10,>=4.5
+Provides-Extra: polypack
+Requires-Dist: polypack-db>=3.1; extra == "polypack"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+
+# polypack-mcp
+
+An MCP server that exposes Polypack as persistent adaptive memory. MCP-specific
+tools live here; the database remains an independent dependency.
+
+## Run
+
+```sh
+pip install -e '.[polypack]'
+polypack-mcp --store ./polypack-data
+```
+
+The server exposes eight focused tools: `memory_store`, `memory_recall`,
+`memory_context`, `memory_feedback`, `memory_suppress`, `memory_supersede`,
+`memory_consolidate`, and `graph_query`. It also publishes context, active-memory,
+schema, and stats resources under `polypack://`.
+
+Pass `--store` to open a durable Polypack directory. Without it, the server uses
+the in-memory reference backend, which is convenient for smoke tests.
+
+## Development
+
+```sh
+pip install -e '.[dev]'
+pytest
+```
+
+The test suite includes an MCP client/server protocol smoke test covering tool
+discovery, memory storage, recall, and resource reads.

polypack_mcp-0.1.0/README.md

@@ -0,0 +1,29 @@
+# polypack-mcp
+
+An MCP server that exposes Polypack as persistent adaptive memory. MCP-specific
+tools live here; the database remains an independent dependency.
+
+## Run
+
+```sh
+pip install -e '.[polypack]'
+polypack-mcp --store ./polypack-data
+```
+
+The server exposes eight focused tools: `memory_store`, `memory_recall`,
+`memory_context`, `memory_feedback`, `memory_suppress`, `memory_supersede`,
+`memory_consolidate`, and `graph_query`. It also publishes context, active-memory,
+schema, and stats resources under `polypack://`.
+
+Pass `--store` to open a durable Polypack directory. Without it, the server uses
+the in-memory reference backend, which is convenient for smoke tests.
+
+## Development
+
+```sh
+pip install -e '.[dev]'
+pytest
+```
+
+The test suite includes an MCP client/server protocol smoke test covering tool
+discovery, memory storage, recall, and resource reads.

polypack_mcp-0.1.0/polypack_mcp/__init__.py

@@ -0,0 +1,7 @@
+"""Polypack's Model Context Protocol integration."""
+
+from .backend import InMemoryBackend, MemoryBackend, PolypackBackend
+from .service import MemoryService
+
+__all__ = ["InMemoryBackend", "MemoryBackend", "PolypackBackend", "MemoryService"]
+

polypack_mcp-0.1.0/polypack_mcp/backend.py

@@ -0,0 +1,217 @@
+"""Backend boundary between MCP semantics and Polypack implementations."""
+
+from __future__ import annotations
+
+import math
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+
+CLASSES = {"episodic", "semantic", "procedural", "entity"}
+
+
+@dataclass
+class Memory:
+    id: str
+    content: str
+    memory_class: str = "semantic"
+    context: str | None = None
+    confidence: float = 1.0
+    provenance: dict[str, Any] = field(default_factory=dict)
+    activation: float = 0.0
+    created_at: float = field(default_factory=time.time)
+    metadata: dict[str, Any] = field(default_factory=dict)
+    superseded_by: str | None = None
+
+    def as_dict(self) -> dict[str, Any]:
+        return {"id": self.id, "content": self.content, "class": self.memory_class,
+                "context": self.context, "confidence": self.confidence,
+                "provenance": self.provenance, "activation": round(self.activation, 6),
+                "createdAt": self.created_at, "metadata": self.metadata,
+                "supersededBy": self.superseded_by}
+
+
+class MemoryBackend(Protocol):
+    def store(self, content: str, **kwargs: Any) -> dict[str, Any]: ...
+    def recall(self, query: str, **kwargs: Any) -> list[dict[str, Any]]: ...
+    def context(self, context: str, **kwargs: Any) -> list[dict[str, Any]]: ...
+    def feedback(self, memory_id: str, useful: bool, **kwargs: Any) -> dict[str, Any]: ...
+    def suppress(self, memory_id: str, **kwargs: Any) -> dict[str, Any]: ...
+    def supersede(self, new_id: str, old_id: str) -> dict[str, Any]: ...
+    def consolidate(self, source_ids: list[str], content: str, **kwargs: Any) -> dict[str, Any]: ...
+    def graph_query(self, operation: str, **kwargs: Any) -> dict[str, Any]: ...
+    def stats(self) -> dict[str, Any]: ...
+
+
+class InMemoryBackend:
+    """Small reference backend; useful for tests and MCP smoke tests."""
+
+    def __init__(self) -> None:
+        self.memories: dict[str, Memory] = {}
+        self.edges: list[dict[str, Any]] = []
+
+    def _get(self, memory_id: str) -> Memory:
+        if memory_id not in self.memories:
+            raise ValueError(f"Unknown memory: {memory_id}")
+        return self.memories[memory_id]
+
+    def store(self, content: str, **kwargs: Any) -> dict[str, Any]:
+        memory = Memory(id=kwargs.get("id", str(uuid.uuid4())), content=content,
+                        memory_class=kwargs.get("memory_class", "semantic"),
+                        context=kwargs.get("context"), confidence=kwargs.get("confidence", 1.0),
+                        provenance=kwargs.get("provenance", {}), metadata=kwargs.get("metadata", {}),
+                        activation=kwargs.get("activation", 0.1))
+        self.memories[memory.id] = memory
+        return memory.as_dict()
+
+    def recall(self, query: str, **kwargs: Any) -> list[dict[str, Any]]:
+        terms = set(query.lower().split())
+        context, limit = kwargs.get("context"), kwargs.get("limit", 10)
+        ranked = []
+        for memory in self.memories.values():
+            if memory.superseded_by or (context and memory.context not in (None, context)):
+                continue
+            words = set(memory.content.lower().split())
+            lexical = len(terms & words) / max(len(terms), 1)
+            contextual = 0.15 if context and memory.context == context else 0
+            score = lexical * 0.65 + memory.activation * 0.25 + memory.confidence * 0.1 + contextual
+            if score > 0:
+                ranked.append((score, memory))
+        ranked.sort(key=lambda item: item[0], reverse=True)
+        return [{**memory.as_dict(), "score": round(score, 6)} for score, memory in ranked[:limit]]
+
+    def context(self, context: str, **kwargs: Any) -> list[dict[str, Any]]:
+        items = [m for m in self.memories.values() if (not context or m.context == context) and not m.superseded_by]
+        items.sort(key=lambda m: m.activation, reverse=True)
+        budget, used = kwargs.get("token_budget"), 0
+        result = []
+        for memory in items:
+            cost = len(memory.content.split())
+            if budget is not None and used + cost > budget:
+                continue
+            used += cost
+            result.append(memory.as_dict())
+            if len(result) >= kwargs.get("limit", 10):
+                break
+        return result
+
+    def feedback(self, memory_id: str, useful: bool, **kwargs: Any) -> dict[str, Any]:
+        memory = self._get(memory_id)
+        memory.activation = min(1.0, max(0.0, memory.activation + (0.1 if useful else -0.1)))
+        return {"id": memory_id, "useful": useful, "activation": memory.activation}
+
+    def suppress(self, memory_id: str, **kwargs: Any) -> dict[str, Any]:
+        memory = self._get(memory_id)
+        memory.activation = max(0.0, memory.activation - kwargs.get("amount", 0.5))
+        return {"id": memory_id, "activation": memory.activation}
+
+    def supersede(self, new_id: str, old_id: str) -> dict[str, Any]:
+        old = self._get(old_id); self._get(new_id); old.superseded_by = new_id; old.activation = 0.0
+        return {"superseded": old_id, "by": new_id}
+
+    def consolidate(self, source_ids: list[str], content: str, **kwargs: Any) -> dict[str, Any]:
+        for source_id in source_ids: self._get(source_id)
+        return self.store(content, memory_class=kwargs.get("memory_class", "semantic"),
+                          context=kwargs.get("context"), confidence=kwargs.get("confidence", 1.0),
+                          provenance={"derivedFrom": source_ids}, activation=0.7)
+
+    def graph_query(self, operation: str, **kwargs: Any) -> dict[str, Any]:
+        if operation == "add_edge":
+            self._get(kwargs["source"]); self._get(kwargs["target"])
+            edge = {"source": kwargs["source"], "type": kwargs["type"], "target": kwargs["target"]}
+            self.edges.append(edge); return edge
+        if operation == "neighbors":
+            node_id = kwargs["id"]
+            return {"id": node_id, "neighbors": [e for e in self.edges if e["source"] == node_id or e["target"] == node_id]}
+        if operation == "schema": return {"nodes": ["memory"], "edges": sorted({e["type"] for e in self.edges})}
+        raise ValueError(f"Unsupported graph operation: {operation}")
+
+    def stats(self) -> dict[str, Any]:
+        return {"memories": len(self.memories), "edges": len(self.edges)}
+
+
+class PolypackBackend(InMemoryBackend):
+    """Adapter using the real Python Polypack graph and activation engine."""
+
+    def __init__(self, graph: Any | None = None) -> None:
+        try:
+            from polypack import ActivationEngine, PolyGraph
+        except ImportError as exc:
+            raise RuntimeError("Install polypack-db or use InMemoryBackend") from exc
+        self.graph = graph or PolyGraph()
+        self.engine = ActivationEngine(self.graph)
+
+    def store(self, content: str, **kwargs: Any) -> dict[str, Any]:
+        now = int(time.time() * 1000); memory_id = kwargs.get("id", str(uuid.uuid4()))
+        node = {"id": memory_id, "type": "memory", "memoryClass": kwargs.get("memory_class", "semantic"),
+                "data": {"content": content, "context": kwargs.get("context"), "provenance": kwargs.get("provenance", {}),
+                         "confidence": kwargs.get("confidence", 1.0), "metadata": kwargs.get("metadata", {})},
+                "insertedAt": now, "updatedAt": now}
+        self.graph.add_node(node); self.graph.reinforce_node(memory_id, kwargs.get("activation", 0.1), "memory_store",
+                                                             context=kwargs.get("context"))
+        return self._node(memory_id)
+
+    def _node(self, memory_id: str) -> dict[str, Any]:
+        node = self.graph._nodes[memory_id]
+        return {"id": memory_id, "content": node.get("data", {}).get("content", ""), "class": node.get("memoryClass", "semantic"),
+                "context": node.get("data", {}).get("context"), "confidence": node.get("data", {}).get("confidence", 1.0),
+                "provenance": node.get("data", {}).get("provenance", {}), "activation": self.graph.get_activation(memory_id) or 0}
+
+    def feedback(self, memory_id: str, useful: bool, **kwargs: Any) -> dict[str, Any]:
+        self.engine.record_feedback(memory_id, useful)
+        self.graph.reinforce_node(memory_id, 0.1 if useful else -0.1, "mcp_feedback")
+        return {"id": memory_id, "useful": useful, "activation": self.graph.get_activation(memory_id)}
+
+    def suppress(self, memory_id: str, **kwargs: Any) -> dict[str, Any]:
+        self.graph.suppress_node(memory_id, kwargs.get("amount", 0.5), "mcp_suppress")
+        return {"id": memory_id, "activation": self.graph.get_activation(memory_id)}
+
+    def supersede(self, new_id: str, old_id: str) -> dict[str, Any]:
+        self.graph.supersede(new_id, old_id)
+        return {"superseded": old_id, "by": new_id}
+
+    def consolidate(self, source_ids: list[str], content: str, **kwargs: Any) -> dict[str, Any]:
+        memory_id = kwargs.get("id", str(uuid.uuid4()))
+        now = int(time.time() * 1000)
+        node = {"id": memory_id, "type": "memory", "memoryClass": kwargs.get("memory_class", "semantic"),
+                "data": {"content": content, "context": kwargs.get("context"),
+                         "confidence": kwargs.get("confidence", 1.0), "derivedFrom": source_ids},
+                "insertedAt": now, "updatedAt": now}
+        self.graph.consolidate(node, source_ids)
+        return self._node(memory_id)
+
+    def recall(self, query: str, **kwargs: Any) -> list[dict[str, Any]]:
+        # Embeddings are intentionally supplied by a future caller; lexical graph
+        # traversal remains a useful fallback for text-only MCP clients.
+        terms = set(query.lower().split())
+        context, limit = kwargs.get("context"), kwargs.get("limit", 10)
+        ranked = []
+        for node_id, node in self.graph._nodes.items():
+            item = self._node(node_id)
+            if context and item["context"] not in (None, context): continue
+            score = len(terms & set(item["content"].lower().split())) / max(len(terms), 1)
+            score += item["activation"] * 0.25
+            if score: ranked.append((score, item))
+        ranked.sort(key=lambda pair: pair[0], reverse=True)
+        return [{**item, "score": round(score, 6)} for score, item in ranked[:limit]]
+
+    def context(self, context: str, **kwargs: Any) -> list[dict[str, Any]]:
+        result = self.graph.top_activated(kwargs.get("limit", 10))
+        items = [self._node(node["id"]) for node in result if not context or self._node(node["id"])["context"] == context]
+        return items
+
+    def graph_query(self, operation: str, **kwargs: Any) -> dict[str, Any]:
+        if operation == "schema": return {"nodes": ["memory"], "edges": sorted({e.get("type") for e in self.graph._edges.values() for e in e.values()})}
+        if operation == "add_edge":
+            self.graph.add_edge(kwargs["source"], kwargs["type"], kwargs["target"])
+            return {"source": kwargs["source"], "type": kwargs["type"], "target": kwargs["target"]}
+        if operation == "neighbors":
+            node_id = kwargs["id"]
+            edges = [edge for grouped in self.graph._edges.values() for edge in grouped.values()
+                     if edge.get("source") == node_id or edge.get("target") == node_id]
+            return {"id": node_id, "neighbors": edges}
+        raise ValueError(f"Unsupported graph operation: {operation}")
+
+    def stats(self) -> dict[str, Any]:
+        return {"memories": self.graph.size, "edges": sum(len(edges) for edges in self.graph._edges.values())}

polypack_mcp-0.1.0/polypack_mcp/server.py

@@ -0,0 +1,88 @@
+"""FastMCP server for Polypack adaptive memory."""
+
+import argparse
+import json
+from .backend import InMemoryBackend, MemoryBackend
+from .service import MemoryService
+
+def create_server(backend: MemoryBackend | None = None):
+    try:
+        from mcp.server.fastmcp import FastMCP
+    except ImportError as exc:
+        raise RuntimeError("Install dependencies with: pip install -e '.[polypack]'") from exc
+    backend = backend or InMemoryBackend()
+    service = MemoryService(backend)
+    mcp = FastMCP("Polypack")
+
+    @mcp.tool()
+    def memory_store(content: str, memory_class: str = "semantic", context: str | None = None,
+                     confidence: float = 1.0, provenance: dict | None = None, metadata: dict | None = None) -> dict:
+        """Store durable adaptive memory with provenance and confidence."""
+        return service.store(content, memory_class, context, confidence, provenance, metadata)
+
+    @mcp.tool()
+    def memory_recall(query: str, context: str | None = None, limit: int = 10) -> list[dict]:
+        """Hybrid semantic, graph, and activation-weighted retrieval."""
+        return backend.recall(query, context=context, limit=max(1, min(limit, 100)))
+
+    @mcp.tool()
+    def memory_context(context: str, limit: int = 10, token_budget: int | None = None) -> list[dict]:
+        """Return a budgeted working-memory set for a context."""
+        return backend.context(context, limit=max(1, min(limit, 100)), token_budget=token_budget)
+
+    @mcp.tool()
+    def memory_feedback(memory_id: str, useful: bool, agent_id: str = "default") -> dict:
+        """Record whether a retrieved memory helped this agent session."""
+        return backend.feedback(memory_id, useful, agent_id=agent_id)
+
+    @mcp.tool()
+    def memory_suppress(memory_id: str, amount: float = 0.5) -> dict:
+        """Inhibit a stale or unhelpful memory without deleting it."""
+        return backend.suppress(memory_id, amount=amount)
+
+    @mcp.tool()
+    def memory_supersede(new_memory_id: str, old_memory_id: str) -> dict:
+        """Replace an outdated fact while retaining its history."""
+        return backend.supersede(new_memory_id, old_memory_id)
+
+    @mcp.tool()
+    def memory_consolidate(source_ids: list[str], content: str, context: str | None = None,
+                           memory_class: str = "semantic", confidence: float = 1.0) -> dict:
+        """Consolidate episodic memories into a durable higher-level memory."""
+        return backend.consolidate(source_ids, content, context=context, memory_class=memory_class, confidence=confidence)
+
+    @mcp.tool()
+    def graph_query(operation: str, id: str | None = None, source: str | None = None,
+                    target: str | None = None, type: str | None = None) -> dict:
+        """Escape hatch for narrowly scoped graph operations (neighbors, add_edge, schema)."""
+        args = {k: v for k, v in {"id": id, "source": source, "target": target, "type": type}.items() if v is not None}
+        return backend.graph_query(operation, **args)
+
+    @mcp.resource("polypack://memory/context/{context}")
+    def context_resource(context: str) -> str: return json.dumps(backend.context(context), indent=2)
+
+    @mcp.resource("polypack://memory/active")
+    def active_resource() -> str: return json.dumps(backend.context("", limit=20), indent=2)
+
+    @mcp.resource("polypack://graph/schema")
+    def schema_resource() -> str: return json.dumps(backend.graph_query("schema"), indent=2)
+
+    @mcp.resource("polypack://stats")
+    def stats_resource() -> str: return json.dumps(backend.stats(), indent=2)
+    return mcp
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Polypack adaptive-memory MCP server")
+    parser.add_argument("--transport", choices=("stdio", "sse"), default="stdio")
+    parser.add_argument("--store", help="Polypack directory for durable storage")
+    args = parser.parse_args()
+    backend = None
+    if args.store:
+        from .backend import PolypackBackend
+        from polypack import PolyGraph
+        backend = PolypackBackend(PolyGraph.open(args.store))
+    create_server(backend).run(transport=args.transport)
+
+
+if __name__ == "__main__":
+    main()

polypack_mcp-0.1.0/polypack_mcp/service.py

@@ -0,0 +1,18 @@
+"""Validated, agent-facing operations shared by MCP transports and tests."""
+
+from __future__ import annotations
+
+from typing import Any
+from .backend import CLASSES, MemoryBackend
+
+class MemoryService:
+    def __init__(self, backend: MemoryBackend): self.backend = backend
+
+    def store(self, content: str, memory_class: str = "semantic", context: str | None = None,
+              confidence: float = 1.0, provenance: dict[str, Any] | None = None, metadata: dict[str, Any] | None = None) -> dict[str, Any]:
+        if not content.strip(): raise ValueError("content must not be empty")
+        if memory_class not in CLASSES: raise ValueError(f"class must be one of {sorted(CLASSES)}")
+        if not 0 <= confidence <= 1: raise ValueError("confidence must be between 0 and 1")
+        return self.backend.store(content, memory_class=memory_class, context=context, confidence=confidence,
+                                  provenance=provenance or {}, metadata=metadata or {})
+

polypack_mcp-0.1.0/polypack_mcp.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: polypack-mcp
+Version: 0.1.0
+Summary: MCP server exposing Polypack as persistent adaptive memory
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp<1.11,>=1.10
+Requires-Dist: anyio<4.10,>=4.5
+Provides-Extra: polypack
+Requires-Dist: polypack-db>=3.1; extra == "polypack"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+
+# polypack-mcp
+
+An MCP server that exposes Polypack as persistent adaptive memory. MCP-specific
+tools live here; the database remains an independent dependency.
+
+## Run
+
+```sh
+pip install -e '.[polypack]'
+polypack-mcp --store ./polypack-data
+```
+
+The server exposes eight focused tools: `memory_store`, `memory_recall`,
+`memory_context`, `memory_feedback`, `memory_suppress`, `memory_supersede`,
+`memory_consolidate`, and `graph_query`. It also publishes context, active-memory,
+schema, and stats resources under `polypack://`.
+
+Pass `--store` to open a durable Polypack directory. Without it, the server uses
+the in-memory reference backend, which is convenient for smoke tests.
+
+## Development
+
+```sh
+pip install -e '.[dev]'
+pytest
+```
+
+The test suite includes an MCP client/server protocol smoke test covering tool
+discovery, memory storage, recall, and resource reads.

polypack_mcp-0.1.0/polypack_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+polypack_mcp/__init__.py
+polypack_mcp/backend.py
+polypack_mcp/server.py
+polypack_mcp/service.py
+polypack_mcp.egg-info/PKG-INFO
+polypack_mcp.egg-info/SOURCES.txt
+polypack_mcp.egg-info/dependency_links.txt
+polypack_mcp.egg-info/entry_points.txt
+polypack_mcp.egg-info/requires.txt
+polypack_mcp.egg-info/top_level.txt
+tests/test_mcp_protocol.py
+tests/test_service.py

polypack_mcp-0.1.0/polypack_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

polypack_mcp-0.1.0/polypack_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+polypack-mcp = polypack_mcp.server:main

polypack_mcp-0.1.0/polypack_mcp.egg-info/requires.txt

@@ -0,0 +1,8 @@
+mcp<1.11,>=1.10
+anyio<4.10,>=4.5
+
+[dev]
+pytest>=8
+
+[polypack]
+polypack-db>=3.1

polypack_mcp-0.1.0/polypack_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+polypack_mcp

polypack_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "polypack-mcp"
+version = "0.1.0"
+description = "MCP server exposing Polypack as persistent adaptive memory"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["mcp>=1.10,<1.11", "anyio>=4.5,<4.10"]
+
+[project.optional-dependencies]
+polypack = ["polypack-db>=3.1"]
+dev = ["pytest>=8"]
+
+[project.scripts]
+polypack-mcp = "polypack_mcp.server:main"
+
+[tool.setuptools.packages.find]
+include = ["polypack_mcp*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

polypack_mcp-0.1.0/setup.cfg

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

polypack_mcp-0.1.0/tests/test_mcp_protocol.py

@@ -0,0 +1,29 @@
+import asyncio
+import json
+
+from mcp.shared.memory import create_connected_server_and_client_session
+from polypack_mcp.server import create_server
+
+
+def test_stdio_protocol_lists_surface_and_round_trips_memory():
+    async def exercise():
+        server = create_server()
+        async with create_connected_server_and_client_session(server._mcp_server) as session:
+            tools = await session.list_tools()
+            assert {tool.name for tool in tools.tools} == {
+                "memory_store", "memory_recall", "memory_context", "memory_feedback",
+                "memory_suppress", "memory_supersede", "memory_consolidate", "graph_query",
+            }
+            stored = await session.call_tool("memory_store", {
+                "content": "Polypack MCP protocol works", "context": "test"
+            })
+            memory = json.loads(stored.content[0].text)
+            recalled = await session.call_tool("memory_recall", {
+                "query": "MCP protocol", "context": "test"
+            })
+            recalled_payload = [json.loads(block.text) for block in recalled.content]
+            assert recalled_payload[0]["id"] == memory["id"]
+            stats = await session.read_resource("polypack://stats")
+            assert '"memories": 1' in stats.contents[0].text
+
+    asyncio.run(exercise())

polypack_mcp-0.1.0/tests/test_service.py

@@ -0,0 +1,19 @@
+from polypack_mcp import InMemoryBackend, MemoryService
+
+def test_store_recall_feedback_and_supersede():
+    backend = InMemoryBackend(); service = MemoryService(backend)
+    old = service.store("Python graph queries need optimisation", context="polypack")
+    new = service.store("Python graph queries now use the native index", context="polypack")
+    found = backend.recall("What performance work remains?", context="polypack")
+    assert found and found[0]["id"] == old["id"]
+    backend.feedback(old["id"], True)
+    backend.supersede(new["id"], old["id"])
+    assert all(item["id"] != old["id"] for item in backend.recall("graph queries", context="polypack"))
+
+def test_context_budget_and_graph():
+    backend = InMemoryBackend(); service = MemoryService(backend)
+    a = service.store("one two", context="coding"); b = service.store("three four five", context="coding")
+    assert len(backend.context("coding", token_budget=2)) == 1
+    backend.graph_query("add_edge", source=a["id"], target=b["id"], type="related")
+    assert len(backend.graph_query("neighbors", id=a["id"])["neighbors"]) == 1
+