sibyl-memory-mcp 0.1.0__tar.gz

sibyl_memory_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: sibyl-memory-mcp
+Version: 0.1.0
+Summary: MCP server for Sibyl Memory Plugin — wraps the local SQLite + FTS5 memory engine and exposes it to MCP-compatible agents (Claude Code, Codex, Cursor, Continue, anything that speaks MCP).
+Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
+License: MIT
+Project-URL: Homepage, https://sibyllabs.org/memory
+Project-URL: Documentation, https://docs.sibyllabs.org/memory/integrations
+Project-URL: Repository, https://github.com/sibyllabs/sibyl-memory-plugin
+Keywords: mcp,model-context-protocol,memory,agent,claude,claude-code,codex,sibyl
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: sibyl-memory-client>=0.3.2
+Requires-Dist: sibyl-memory-hermes>=0.2.2
+
+# sibyl-memory-mcp
+
+MCP server for [Sibyl Memory Plugin](https://sibyllabs.org/memory). Exposes the local SQLite + FTS5 memory engine to any MCP-compatible agent: **Claude Code, Codex CLI, Cursor, Continue**, anything that speaks Model Context Protocol.
+
+## Install
+
+```bash
+pip install sibyl-memory-mcp
+```
+
+You also need an activated Sibyl Memory account. If you haven't already:
+
+```bash
+sibyl init
+```
+
+This creates `~/.sibyl-memory/credentials.json` (server-issued, HMAC-signed) and a local SQLite database at `~/.sibyl-memory/memory.db`. The MCP server reads both automatically.
+
+## Add to Claude Code
+
+Edit `~/.claude/settings.json` (global) or `.mcp.json` (project-local):
+
+```json
+{
+  "mcpServers": {
+    "sibyl-memory": {
+      "command": "sibyl-memory-mcp"
+    }
+  }
+}
+```
+
+Restart Claude Code. The 8 memory tools (prefixed `memory_*`) become available immediately.
+
+## Add to Codex CLI
+
+Edit `~/.codex/config.toml`:
+
+```toml
+[[mcp_servers]]
+name = "sibyl-memory"
+command = "sibyl-memory-mcp"
+```
+
+Restart Codex.
+
+## Tools exposed
+
+| Tool | What it does |
+|------|--------------|
+| `memory_remember` | Store an entity by (category, name) |
+| `memory_recall` | Read an entity by exact key |
+| `memory_search` | FTS5 search across all entities |
+| `memory_list` | List entities in a category |
+| `memory_forget` | Archive an entity (recoverable) |
+| `memory_set_state` | Write a HOT-tier state doc |
+| `memory_get_state` | Read a HOT-tier state doc |
+| `memory_record_event` | Append a COLD-tier journal event |
+
+Full docs at [docs.sibyllabs.org/memory/integrations](https://docs.sibyllabs.org/memory/integrations).
+
+## Environment overrides
+
+| Var | Default | What it overrides |
+|-----|---------|--------------------|
+| `SIBYL_MEMORY_DB` | `~/.sibyl-memory/memory.db` | Local SQLite path |
+| `SIBYL_CREDENTIALS` | `~/.sibyl-memory/credentials.json` | Credentials file path |
+
+## Tier behavior
+
+- **Free tier**: 8 tools work. Hard-capped at 2 MB of local storage. Writes that would push past the cap return `CAP_EXCEEDED` with an `upgrade_url`. Self-learning and memory-check-up tools are not exposed on free tier.
+- **Paid tiers** (Sync / Stake / Lifetime / Enterprise): cap removed. All tools enabled.
+
+The cap-gate runs against the **server-authoritative** tier (verified via HMAC-signed credentials) — the MCP server can't bypass it by editing the local file.
+
+## License
+
+MIT — same as the rest of the `sibyl-memory-*` family.

sibyl_memory_mcp-0.1.0/README.md

@@ -0,0 +1,78 @@
+# sibyl-memory-mcp
+
+MCP server for [Sibyl Memory Plugin](https://sibyllabs.org/memory). Exposes the local SQLite + FTS5 memory engine to any MCP-compatible agent: **Claude Code, Codex CLI, Cursor, Continue**, anything that speaks Model Context Protocol.
+
+## Install
+
+```bash
+pip install sibyl-memory-mcp
+```
+
+You also need an activated Sibyl Memory account. If you haven't already:
+
+```bash
+sibyl init
+```
+
+This creates `~/.sibyl-memory/credentials.json` (server-issued, HMAC-signed) and a local SQLite database at `~/.sibyl-memory/memory.db`. The MCP server reads both automatically.
+
+## Add to Claude Code
+
+Edit `~/.claude/settings.json` (global) or `.mcp.json` (project-local):
+
+```json
+{
+  "mcpServers": {
+    "sibyl-memory": {
+      "command": "sibyl-memory-mcp"
+    }
+  }
+}
+```
+
+Restart Claude Code. The 8 memory tools (prefixed `memory_*`) become available immediately.
+
+## Add to Codex CLI
+
+Edit `~/.codex/config.toml`:
+
+```toml
+[[mcp_servers]]
+name = "sibyl-memory"
+command = "sibyl-memory-mcp"
+```
+
+Restart Codex.
+
+## Tools exposed
+
+| Tool | What it does |
+|------|--------------|
+| `memory_remember` | Store an entity by (category, name) |
+| `memory_recall` | Read an entity by exact key |
+| `memory_search` | FTS5 search across all entities |
+| `memory_list` | List entities in a category |
+| `memory_forget` | Archive an entity (recoverable) |
+| `memory_set_state` | Write a HOT-tier state doc |
+| `memory_get_state` | Read a HOT-tier state doc |
+| `memory_record_event` | Append a COLD-tier journal event |
+
+Full docs at [docs.sibyllabs.org/memory/integrations](https://docs.sibyllabs.org/memory/integrations).
+
+## Environment overrides
+
+| Var | Default | What it overrides |
+|-----|---------|--------------------|
+| `SIBYL_MEMORY_DB` | `~/.sibyl-memory/memory.db` | Local SQLite path |
+| `SIBYL_CREDENTIALS` | `~/.sibyl-memory/credentials.json` | Credentials file path |
+
+## Tier behavior
+
+- **Free tier**: 8 tools work. Hard-capped at 2 MB of local storage. Writes that would push past the cap return `CAP_EXCEEDED` with an `upgrade_url`. Self-learning and memory-check-up tools are not exposed on free tier.
+- **Paid tiers** (Sync / Stake / Lifetime / Enterprise): cap removed. All tools enabled.
+
+The cap-gate runs against the **server-authoritative** tier (verified via HMAC-signed credentials) — the MCP server can't bypass it by editing the local file.
+
+## License
+
+MIT — same as the rest of the `sibyl-memory-*` family.

sibyl_memory_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sibyl-memory-mcp"
+version = "0.1.0"
+description = "MCP server for Sibyl Memory Plugin — wraps the local SQLite + FTS5 memory engine and exposes it to MCP-compatible agents (Claude Code, Codex, Cursor, Continue, anything that speaks MCP)."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "SIBYL, Sibyl Labs LLC", email = "sibyl@sibyllabs.org" }]
+keywords = ["mcp", "model-context-protocol", "memory", "agent", "claude", "claude-code", "codex", "sibyl"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "mcp>=1.0.0",
+    "sibyl-memory-client>=0.3.2",
+    "sibyl-memory-hermes>=0.2.2",
+]
+
+[project.scripts]
+sibyl-memory-mcp = "sibyl_memory_mcp.__main__:main"
+
+[project.urls]
+Homepage = "https://sibyllabs.org/memory"
+Documentation = "https://docs.sibyllabs.org/memory/integrations"
+Repository = "https://github.com/sibyllabs/sibyl-memory-plugin"
+
+[tool.setuptools.packages.find]
+where = ["src"]

sibyl_memory_mcp-0.1.0/setup.cfg

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

sibyl_memory_mcp-0.1.0/src/sibyl_memory_mcp/__init__.py

@@ -0,0 +1,28 @@
+"""sibyl-memory-mcp — MCP server for Sibyl Memory Plugin.
+
+Wraps the local SQLite + FTS5 memory engine (sibyl-memory-client) and
+exposes it to any MCP-compatible agent: Claude Code, Codex CLI, Cursor,
+Continue, etc.
+
+Usage (Claude Code):
+    Add to ~/.claude/settings.json or project .mcp.json:
+        {
+          "mcpServers": {
+            "sibyl-memory": { "command": "sibyl-memory-mcp" }
+          }
+        }
+
+Usage (Codex CLI):
+    Add to ~/.codex/config.toml:
+        [[mcp_servers]]
+        name = "sibyl-memory"
+        command = "sibyl-memory-mcp"
+
+Both expect `sibyl init` to have been run first so credentials.json and
+memory.db exist at ~/.sibyl-memory/.
+"""
+
+from .server import build_server, run_stdio
+
+__version__ = "0.1.0"
+__all__ = ["build_server", "run_stdio", "__version__"]

sibyl_memory_mcp-0.1.0/src/sibyl_memory_mcp/__main__.py

@@ -0,0 +1,10 @@
+"""Entry point: `sibyl-memory-mcp` console script + `python -m sibyl_memory_mcp`."""
+from .server import run_stdio
+
+
+def main() -> None:
+    run_stdio()
+
+
+if __name__ == "__main__":
+    main()

sibyl_memory_mcp-0.1.0/src/sibyl_memory_mcp/server.py

@@ -0,0 +1,252 @@
+"""MCP server exposing Sibyl Memory Plugin tools.
+
+8 tools:
+  - memory_remember        store an entity
+  - memory_recall          read an entity by category+name
+  - memory_search          FTS5 search across all entities
+  - memory_list            list entities in a category
+  - memory_forget          delete an entity (archived, not destroyed)
+  - memory_set_state       write a HOT-tier state document
+  - memory_get_state       read a HOT-tier state document
+  - memory_record_event    append a COLD-tier journal event
+
+All operations run against the local SQLite at ~/.sibyl-memory/memory.db.
+The cap gate (free-tier 2 MB hard cap, paid-tier uncapped) is enforced
+automatically by the underlying sibyl-memory-client SDK — the MCP server
+just surfaces the typed errors back to the caller.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+from sibyl_memory_client import MemoryClient
+from sibyl_memory_client.exceptions import (
+    CapExceededError,
+    NotFoundError,
+    TierGateError,
+    TierVerificationError,
+    ValidationError,
+)
+
+# Default install location matches the rest of the plugin ecosystem.
+DEFAULT_DB_PATH = Path(os.environ.get(
+    "SIBYL_MEMORY_DB",
+    Path.home() / ".sibyl-memory" / "memory.db",
+))
+DEFAULT_CRED_PATH = Path(os.environ.get(
+    "SIBYL_CREDENTIALS",
+    Path.home() / ".sibyl-memory" / "credentials.json",
+))
+
+
+def _load_credentials() -> dict[str, Any]:
+    """Read credentials.json if present. Missing file = pre-activation, free tier."""
+    if not DEFAULT_CRED_PATH.exists():
+        return {}
+    try:
+        return json.loads(DEFAULT_CRED_PATH.read_text())
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _open_client() -> MemoryClient:
+    """Open a MemoryClient bound to the local DB + credentials.
+
+    Re-opens on every tool call so the server picks up tier changes from
+    `sibyl upgrade` without a restart. SQLite open is sub-millisecond.
+    """
+    creds = _load_credentials()
+    DEFAULT_DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    return MemoryClient.local(
+        str(DEFAULT_DB_PATH),
+        tenant_id=creds.get("tenant_id"),
+        account_id=creds.get("account_id"),
+        session_token=creds.get("session_token"),
+        tier=creds.get("tier", "free"),
+        credentials_claim={
+            "account_id": creds.get("account_id"),
+            "tenant_id": creds.get("tenant_id"),
+            "tier": creds.get("tier"),
+            "email": creds.get("email"),
+            "wallet": creds.get("wallet"),
+            "issued_at": creds.get("issued_at"),
+            "schema_version": creds.get("schema_version", 1),
+        } if creds.get("signature") else None,
+        credentials_signature=creds.get("signature"),
+    )
+
+
+def _err(e: Exception) -> dict[str, Any]:
+    """Map SDK exception → structured error payload the agent can reason about."""
+    cls = type(e).__name__
+    payload = {"error": cls, "message": str(e)}
+    if isinstance(e, CapExceededError):
+        payload["code"] = "CAP_EXCEEDED"
+        payload["recovery"] = "Run `sibyl upgrade` to lift the 2 MB free-tier cap."
+        payload["upgrade_url"] = getattr(e, "upgrade_url", "https://sibyllabs.org/plugin/upgrade")
+    elif isinstance(e, TierGateError):
+        payload["code"] = "TIER_GATED"
+        payload["recovery"] = "This feature requires a paid tier. Run `sibyl upgrade`."
+    elif isinstance(e, TierVerificationError):
+        payload["code"] = "TIER_VERIFICATION_FAILED"
+        payload["recovery"] = "The server couldn't verify your tier. Check connectivity and try again."
+    elif isinstance(e, NotFoundError):
+        payload["code"] = "NOT_FOUND"
+    elif isinstance(e, ValidationError):
+        payload["code"] = "VALIDATION_ERROR"
+    return payload
+
+
+def build_server() -> FastMCP:
+    """Build and return the MCP server. Tool names are prefixed with `memory_`."""
+    mcp = FastMCP("sibyl-memory")
+
+    @mcp.tool()
+    def memory_remember(category: str, name: str, body: dict[str, Any]) -> dict[str, Any]:
+        """Store an entity in long-term memory.
+
+        Use for facts, project state, person profiles, anything the agent
+        should remember across sessions. Idempotent on (category, name) —
+        a second call with the same key updates the entry.
+
+        Args:
+            category: Logical grouping (e.g. "people", "projects", "facts").
+            name: Unique-within-category identifier (e.g. "alice", "acme-deal").
+            body: Arbitrary JSON-serializable object. Become the entity body.
+        """
+        try:
+            client = _open_client()
+            client.set_entity(category, name, body)
+            return {"ok": True, "category": category, "name": name}
+        except Exception as e:
+            return _err(e)
+
+    @mcp.tool()
+    def memory_recall(category: str, name: str) -> dict[str, Any]:
+        """Read an entity by exact (category, name) lookup.
+
+        Returns the entity dict {name, category, body, created_at,
+        updated_at} or a NOT_FOUND error. Sub-millisecond against the
+        local SQLite.
+        """
+        try:
+            client = _open_client()
+            return {"ok": True, "entity": client.get_entity(category, name)}
+        except Exception as e:
+            return _err(e)
+
+    @mcp.tool()
+    def memory_search(query: str, limit: int = 10) -> dict[str, Any]:
+        """Full-text search across all entity bodies + names.
+
+        Uses SQLite FTS5. Returns up to `limit` matching entities ranked
+        by relevance. Best path when you know roughly what you're looking
+        for but not the exact (category, name) key.
+
+        Args:
+            query: Search terms. Supports FTS5 operators (AND, OR, NEAR/N).
+            limit: Maximum results to return (default 10, max 50).
+        """
+        try:
+            client = _open_client()
+            results = client.search_entities(query, limit=min(max(limit, 1), 50))
+            return {"ok": True, "query": query, "count": len(results), "results": results}
+        except Exception as e:
+            return _err(e)
+
+    @mcp.tool()
+    def memory_list(category: str, limit: int = 50) -> dict[str, Any]:
+        """List entities in a category, most-recently-updated first.
+
+        Useful for "show me everything I've stored about X" queries.
+
+        Args:
+            category: Which category to enumerate.
+            limit: Max entities to return (default 50).
+        """
+        try:
+            client = _open_client()
+            results = client.list_entities(category, limit=min(max(limit, 1), 200))
+            return {"ok": True, "category": category, "count": len(results), "results": results}
+        except Exception as e:
+            return _err(e)
+
+    @mcp.tool()
+    def memory_forget(category: str, name: str, reason: str | None = None) -> dict[str, Any]:
+        """Archive an entity (not destroyed — moved to archived_entities).
+
+        The body is preserved in the archive table for forensic recovery
+        but no longer appears in recall/list/search. Pass a `reason` to
+        record why; useful in audit reviews.
+        """
+        try:
+            client = _open_client()
+            client.archive_entity(category, name, reason=reason)
+            return {"ok": True, "archived": {"category": category, "name": name}}
+        except Exception as e:
+            return _err(e)
+
+    @mcp.tool()
+    def memory_set_state(key: str, body: dict[str, Any] | list[Any]) -> dict[str, Any]:
+        """Write a HOT-tier state document.
+
+        Use for ephemeral working state the agent updates frequently —
+        current focus, in-flight task list, working draft. Faster than
+        entity writes; one row per key, overwritten on each set.
+        """
+        try:
+            client = _open_client()
+            client.set_state(key, body)
+            return {"ok": True, "key": key}
+        except Exception as e:
+            return _err(e)
+
+    @mcp.tool()
+    def memory_get_state(key: str) -> dict[str, Any]:
+        """Read a HOT-tier state document by key."""
+        try:
+            client = _open_client()
+            doc = client.get_state(key)
+            if doc is None:
+                return {"ok": False, "code": "NOT_FOUND", "key": key}
+            return {"ok": True, "key": key, "body": doc}
+        except Exception as e:
+            return _err(e)
+
+    @mcp.tool()
+    def memory_record_event(
+        kind: str,
+        body: dict[str, Any],
+        category: str | None = None,
+        name: str | None = None,
+    ) -> dict[str, Any]:
+        """Append a COLD-tier journal event.
+
+        Use for things that happened — actions taken, decisions made,
+        observations recorded. Append-only; never overwrites. Best paired
+        with entities (the entity is the noun, the journal is the verb).
+
+        Args:
+            kind: Event class (e.g. "decision", "observation", "action").
+            body: JSON-serializable event payload.
+            category: Optional entity category this event is about.
+            name: Optional entity name this event is about.
+        """
+        try:
+            client = _open_client()
+            event_id = client.write_event(kind, body, category=category, name=name)
+            return {"ok": True, "event_id": event_id, "kind": kind}
+        except Exception as e:
+            return _err(e)
+
+    return mcp
+
+
+def run_stdio() -> None:
+    """Run the server on stdio transport (what Claude Code / Codex / Cursor expect)."""
+    mcp = build_server()
+    mcp.run()

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

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: sibyl-memory-mcp
+Version: 0.1.0
+Summary: MCP server for Sibyl Memory Plugin — wraps the local SQLite + FTS5 memory engine and exposes it to MCP-compatible agents (Claude Code, Codex, Cursor, Continue, anything that speaks MCP).
+Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
+License: MIT
+Project-URL: Homepage, https://sibyllabs.org/memory
+Project-URL: Documentation, https://docs.sibyllabs.org/memory/integrations
+Project-URL: Repository, https://github.com/sibyllabs/sibyl-memory-plugin
+Keywords: mcp,model-context-protocol,memory,agent,claude,claude-code,codex,sibyl
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: sibyl-memory-client>=0.3.2
+Requires-Dist: sibyl-memory-hermes>=0.2.2
+
+# sibyl-memory-mcp
+
+MCP server for [Sibyl Memory Plugin](https://sibyllabs.org/memory). Exposes the local SQLite + FTS5 memory engine to any MCP-compatible agent: **Claude Code, Codex CLI, Cursor, Continue**, anything that speaks Model Context Protocol.
+
+## Install
+
+```bash
+pip install sibyl-memory-mcp
+```
+
+You also need an activated Sibyl Memory account. If you haven't already:
+
+```bash
+sibyl init
+```
+
+This creates `~/.sibyl-memory/credentials.json` (server-issued, HMAC-signed) and a local SQLite database at `~/.sibyl-memory/memory.db`. The MCP server reads both automatically.
+
+## Add to Claude Code
+
+Edit `~/.claude/settings.json` (global) or `.mcp.json` (project-local):
+
+```json
+{
+  "mcpServers": {
+    "sibyl-memory": {
+      "command": "sibyl-memory-mcp"
+    }
+  }
+}
+```
+
+Restart Claude Code. The 8 memory tools (prefixed `memory_*`) become available immediately.
+
+## Add to Codex CLI
+
+Edit `~/.codex/config.toml`:
+
+```toml
+[[mcp_servers]]
+name = "sibyl-memory"
+command = "sibyl-memory-mcp"
+```
+
+Restart Codex.
+
+## Tools exposed
+
+| Tool | What it does |
+|------|--------------|
+| `memory_remember` | Store an entity by (category, name) |
+| `memory_recall` | Read an entity by exact key |
+| `memory_search` | FTS5 search across all entities |
+| `memory_list` | List entities in a category |
+| `memory_forget` | Archive an entity (recoverable) |
+| `memory_set_state` | Write a HOT-tier state doc |
+| `memory_get_state` | Read a HOT-tier state doc |
+| `memory_record_event` | Append a COLD-tier journal event |
+
+Full docs at [docs.sibyllabs.org/memory/integrations](https://docs.sibyllabs.org/memory/integrations).
+
+## Environment overrides
+
+| Var | Default | What it overrides |
+|-----|---------|--------------------|
+| `SIBYL_MEMORY_DB` | `~/.sibyl-memory/memory.db` | Local SQLite path |
+| `SIBYL_CREDENTIALS` | `~/.sibyl-memory/credentials.json` | Credentials file path |
+
+## Tier behavior
+
+- **Free tier**: 8 tools work. Hard-capped at 2 MB of local storage. Writes that would push past the cap return `CAP_EXCEEDED` with an `upgrade_url`. Self-learning and memory-check-up tools are not exposed on free tier.
+- **Paid tiers** (Sync / Stake / Lifetime / Enterprise): cap removed. All tools enabled.
+
+The cap-gate runs against the **server-authoritative** tier (verified via HMAC-signed credentials) — the MCP server can't bypass it by editing the local file.
+
+## License
+
+MIT — same as the rest of the `sibyl-memory-*` family.

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

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/sibyl_memory_mcp/__init__.py
+src/sibyl_memory_mcp/__main__.py
+src/sibyl_memory_mcp/server.py
+src/sibyl_memory_mcp.egg-info/PKG-INFO
+src/sibyl_memory_mcp.egg-info/SOURCES.txt
+src/sibyl_memory_mcp.egg-info/dependency_links.txt
+src/sibyl_memory_mcp.egg-info/entry_points.txt
+src/sibyl_memory_mcp.egg-info/requires.txt
+src/sibyl_memory_mcp.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

sibyl_memory_mcp-0.1.0/src/sibyl_memory_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sibyl-memory-mcp = sibyl_memory_mcp.__main__:main

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

@@ -0,0 +1,3 @@
+mcp>=1.0.0
+sibyl-memory-client>=0.3.2
+sibyl-memory-hermes>=0.2.2

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

@@ -0,0 +1 @@
+sibyl_memory_mcp