Documentation

pip install synapse-layer

pip install synapse-layer "mcp[cli]"

from synapse_memory.core import SynapseMemory

# Initialize with default security (all 3 layers active)
memory = SynapseMemory(
    agent_id="my-agent",
    sanitize_enabled=True,      # Layer 1: PII sanitization
    privacy_enabled=True,       # Layer 2: Differential privacy
    privacy_epsilon=0.5,        # Lower = stronger privacy
)

# Store a memory (PII is auto-stripped, DP noise injected)
result = memory.store(
    content="User prefers dark mode and lives in Berlin",
    confidence=0.9,
)

print(result.memory_id)        # SHA-256 hash
print(result.trust_quotient)   # Confidence x validation score
print(result.sanitized)        # True
print(result.privacy_applied)  # True

# Recall memories (self-healing resolves conflicts)
memories = memory.recall("user preferences", top_k=5)
for m in memories:
    print(f"{m.content} (similarity: {m.similarity:.4f})")

from __future__ import annotations
import os, json, logging
from typing import Optional
from mcp.server.fastmcp import FastMCP
from synapse_memory.core import SynapseMemory

AGENT_ID = os.getenv("SYNAPSE_AGENT_ID", "mcp-secure-memory")
PRIVACY_EPSILON = float(os.getenv("SYNAPSE_PRIVACY_EPSILON", "0.5"))

logging.basicConfig(level=logging.INFO)

memory = SynapseMemory(
    agent_id=AGENT_ID,
    sanitize_enabled=True,
    privacy_enabled=True,
    privacy_epsilon=PRIVACY_EPSILON,
)

mcp = FastMCP("Synapse Layer — Secure Memory", json_response=True)

@mcp.tool()
def store_memory(
    content: str,
    confidence: float = 0.9,
    metadata: Optional[str] = None,
) -> dict:
    """Store a memory with automatic PII sanitization
    and differential-privacy noise injection."""
    meta = json.loads(metadata) if metadata else None
    result = memory.store(content, confidence=confidence, metadata=meta)
    return {
        "memory_id": result.memory_id,
        "trust_quotient": round(result.trust_quotient, 4),
        "sanitized": result.sanitized,
        "privacy_applied": result.privacy_applied,
        "content_hash": result.content_hash,
        "timestamp": result.timestamp,
    }

@mcp.tool()
def recall_memory(query: str, top_k: int = 5) -> list[dict]:
    """Recall memories semantically similar to the query.
    Includes self-healing metadata."""
    results = memory.recall(query, top_k=top_k)
    return [
        {
            "memory_id": r.memory_id,
            "content": r.content,
            "similarity": round(r.similarity, 4),
            "trust_quotient": round(r.trust_quotient, 4),
            "self_healed": r.self_healed,
        }
        for r in results
    ]

if __name__ == "__main__":
    mcp.run(transport="stdio")

{
  "mcpServers": {
    "synapse-secure-memory": {
      "command": "python",
      "args": ["path/to/server.py"],
      "env": {
        "SYNAPSE_AGENT_ID": "claude-desktop",
        "SYNAPSE_PRIVACY_EPSILON": "0.5"
      }
    }
  }
}

┌──────────────────────────────────────────────┐
│              MCP Client                    │
│       (Claude / LangChain / CrewAI)        │
└───────────────────────┬──────────────────────┘
                        │ JSON-RPC (stdio)
                        ▼
┌──────────────────────────────────────────────┐
│     MCP Server (synapse-secure-memory)     │
│       store_memory  |  recall_memory        │
└───────────────────────┬──────────────────────┘
                        │
                        ▼
┌──────────────────────────────────────────────┐
│          Synapse Layer SDK                  │
│  Sanitizer → Validator → DP → Encrypt    │
└──────────────────────────────────────────────┘

result = memory.store("User data here", confidence=0.9)

# Audit fields available:
result.memory_id              # SHA-256 hash of sanitized content
result.content_hash           # Integrity fingerprint
result.sanitized              # True (PII was processed)
result.privacy_applied        # True (DP noise injected)
result.trust_quotient         # Confidence x validation score
result.timestamp              # Unix timestamp
result.sanitization_details   # {removed_items, risk_score, pii_count}
result.privacy_details        # {epsilon, delta, sigma, snr_db}
result.validation_details     # {intent, confidence, source_type}

from langchain_mcp_adapters.client import MultiServerMCPClient

async with MultiServerMCPClient(
    {
        "synapse-memory": {
            "command": "python",
            "args": ["path/to/server.py"],
            "env": {
                "SYNAPSE_AGENT_ID": "langchain-agent",
                "SYNAPSE_PRIVACY_EPSILON": "0.5",
            },
        }
    }
) as client:
    tools = client.get_tools()
    # tools includes store_memory and recall_memory
    # Use with create_react_agent, AgentExecutor, etc.

from crewai import Agent, Crew
from crewai_tools import MCPServerAdapter

mcp_tools = MCPServerAdapter(
    server_params={
        "command": "python",
        "args": ["path/to/server.py"],
        "env": {"SYNAPSE_AGENT_ID": "crewai-agent"},
    }
)

researcher = Agent(
    role="Research Analyst",
    goal="Gather and securely persist research findings",
    tools=mcp_tools.tools,
)

crew = Crew(agents=[researcher], tasks=[...])
crew.kickoff()

# Terminal 1: Start the server
python server.py

# Terminal 2: Launch MCP Inspector
npx -y @modelcontextprotocol/inspector

# Connect to stdio://python server.py
# Test store_memory and recall_memory interactively