Skip to main content
Glama

๐Ÿง  Synapse Layer

RAG retrieves. Synapse remembers.

Persistent memory infrastructure for AI agents โ€” AES-256-GCM encrypted at rest, semantic search, MCP-native.

Synapse Layer is open-source persistent memory infrastructure for AI agents and assistants. Memories are encrypted at rest with AES-256-GCM, indexed via pgvector HNSW for semantic recall, and exposed through MCP JSON-RPC for native integration with Claude, GPT, Gemini, and any MCP-compatible client. Apache 2.0 licensed.

Status and limits: see FEATURES.md โ€” the public contract for what is shipped, gated, experimental or roadmap.

PyPI Python Downloads MCP Compatible Official MCP Registry CI License: Apache-2.0

Website ยท Docs ยท PyPI ยท Forge


โšก 30-Second Quickstart

Get your Connect Token at forge.synapselayer.org โ†’ Connect, then add the MCP endpoint to your client:

claude mcp add --transport http synapse-layer \
  https://forge.synapselayer.org/api/mcp \
  --header "x-connect-token: sk_connect_YOUR_TOKEN"

For Claude Desktop, Cursor and other clients, use the npx mcp-remote block under MCP Integration. Smithery's proxy/CLI was retired on 31 Oct 2026; the direct endpoint above is canonical.

Or use the Python SDK:

from synapse_layer import Synapse

s = Synapse(token="sk_connect_YOUR_TOKEN")

s.store("user likes coffee")
print(s.recall("what does user like?"))

Get your token at forge.synapselayer.org โ†’ Dashboard โ†’ Connect


Related MCP server: Sylex Memory

What is Synapse Layer?

The persistent memory layer for AI agents โ€” the missing piece between stateless LLMs and real continuity of context.

Your AI agents forget everything between sessions. Synapse Layer fixes that.

Feature

Description

๐Ÿ” Encrypted at rest

AES-256-GCM with per-operation random IV and HMAC-SHA-256 integrity

๐Ÿงฉ One-click connect

Claude Desktop, Cursor, LangChain, CrewAI, n8n

๐ŸŒ Cross-agent memory

Save in ChatGPT, recall in Claude

โšก MCP-native

Any MCP-compatible agent

๐Ÿ”’ Header-first auth

Tokens never in URLs or logs

๐ŸŽฏ Trust Quotient

Trust-weighted recall โ€” confidence, recency and usage combined with semantic relevance


Why Synapse Layer?

Your AI agents forget everything between sessions. Synapse Layer fixes that โ€” in one line.

Without Synapse Layer

With Synapse Layer

Agent forgets context every session

Persistent memory across all sessions

Memory locked to one model

Cross-agent: save in ChatGPT, recall in Claude

No audit trail

Append-only audit events for scope changes and curation decisions

Complex integration

pip install synapse-layer + 3 lines of code

Plaintext stored on servers

AES-256-GCM encrypted at rest


Use Cases

  • Long-term assistant memory โ€” persist user preferences, facts, and prior decisions across sessions.

  • Cross-agent continuity โ€” save context in one agent and recall it in another.

  • Secure memory for MCP clients โ€” connect Claude Desktop, Cursor, and other MCP-compatible tools to a governed memory layer.

  • Operational memory for teams โ€” maintain structured context, trust scoring, and searchable recall for production agents.


Install

pip install synapse-layer

Quick Start

Python Script

from synapse_layer import Synapse

client = Synapse(token="sk_connect_YOUR_TOKEN")

# Store
client.store("User prefers dark mode and concise answers")

# Recall
results = client.recall("user preferences")
for r in results:
    print(r["content"], r["trust_quotient"])

With Context Manager

from synapse_layer import Synapse

with Synapse(token="sk_connect_YOUR_TOKEN") as client:
    client.store("User prefers dark mode and concise answers")
    results = client.recall("user preferences")
    for r in results:
        print(r["content"])

Get your token at forge.synapselayer.org โ†’ Dashboard โ†’ Connect


13 MCP Tool Names at a Glance

Synapse Layer registers 13 public tool names (10 operations plus 3 aliases) for persistent memory workflows:

  • recall

  • save_to_synapse

  • process_text

  • search

  • health_check

  • initialize_context

  • save_memory

  • store_memory

  • recall_memory

  • list_memories

  • memory_feedback

  • neural_handover

  • slo_report

save_memory, store_memory and save_to_synapse are aliases; recall and recall_memory are aliases. These tools cover memory capture, semantic recall, structured storage, feedback loops, agent handoff, and operational observability.


Deployment Modes

The public package runs the client and local engine. The hosted Forge adds corporate organizations, projects, memberships, curation policies and audit. See FEATURES.md for what is OSS, hosted, gated or roadmap.

Python Script Mode

Use the SDK when you want direct Python access to Forge memory from your application.

Best for:

  • prototypes and scripts

  • Python-native workflows

  • fast integration into existing apps

Cloud / Forge API

Use Forge when you need persistent, cross-session, and cross-agent memory with managed access tokens.

Best for:

  • production assistants

  • multi-agent systems

  • MCP-based integrations

  • shared memory across tools and sessions


MCP Integration (one tested path per client)

Claude Code (CLI)

claude mcp add --transport http synapse-layer \
  https://forge.synapselayer.org/api/mcp \
  --header "x-connect-token: sk_connect_YOUR_TOKEN"

The URL is a positional argument โ€” claude mcp add --transport http <name> <url> โ€” there is no --url flag.

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "synapse-layer": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://forge.synapselayer.org/api/mcp",
        "--header",
        "x-connect-token: sk_connect_YOUR_TOKEN"
      ]
    }
  }
}

Cursor

Add to .cursor/mcp.json in your project root (same JSON block as above).

Any MCP client

Any host that runs npx can use the mcp-remote block above unchanged โ€” it bridges local stdio to the remote endpoint.

Config file locations:

  • Claude Desktop โ€” macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Claude Desktop โ€” Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Claude Desktop โ€” Linux: ~/.config/Claude/claude_desktop_config.json


API โ€” Header-First Auth

# Health check
curl -H "x-connect-token: sk_connect_YOUR_TOKEN" \
  https://forge.synapselayer.org/api/connect/health

# Save memory
curl -X POST \
  -H "x-connect-token: sk_connect_YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"content": "User is a Python developer"}' \
  https://forge.synapselayer.org/api/v1/capture

Security

Feature

Implementation

Encryption

AES-256-GCM at rest with per-operation random IV

Integrity

HMAC-SHA-256 on content

Auth

Header-first (x-connect-token) โ€” tokens never in URLs or logs

Privacy

Content sanitization + tenant-scoped encrypted storage

Isolation

Personal: 1 user = 1 private mind. Corporate: organization โ†’ projects โ†’ memberships, with tenant-scoped queries

See SECURITY.md for vulnerability reporting.


Project

Description

synapse-sdk-python

Python SDK โ€” LangChain, CrewAI, and A2A protocol adapters

synapse-layer-skill

MCP skill configuration for Claude Desktop, Cursor, Windsurf

synapse-layer-langgraph

LangGraph checkpoint saver with encrypted state persistence


Governance

  • Public features and limits follow FEATURES.md.

  • Internal governance follows the Public Claims Matrix.

  • Architecture details that reveal benefits are public; mechanisms that enable them are private.

  • Claim = Reality. If it's not implemented, it's not in the README.


License

Apache-2.0 ยฉ Synapse Layer

Available Tools

13 tools
health_checkA
Read-only
Inspect

Check service availability, engine version, and storage health. Public method.

Inputs: no named parameters. Returns: status, version, dbLatencyMs

initialize_contextA
Read-only
Inspect

Initialize a persistent memory context for a conversation or agent session. Returns REDACTED metadata by default (detail="summary"). Use detail="full" with a reason (10โ€“200 chars) to retrieve plaintext content under MEMORY_EXPORT_GOVERNANCE_V1.

Inputs: detail, reason. Returns: scope, agent_id, memories

list_memoriesA
Read-only
Inspect

List memory metadata with pagination and governance limits.

Inputs: limit, scope, agent_id. Returns: count, total, memories

memory_feedbackAInspect

Submit feedback to adjust trust scoring for stored memories.

Inputs: signal (required), memoryId, memory_id, sessionId, +1 more. Returns: trust, applied, memoryId

neural_handoverAInspect

Transfer contextual state between agents with continuity controls.

Inputs: token (required), reason (required), consuming_agent. Returns: status, handoverId

process_textAInspect

Extract candidate memories from free-form text with governance filters and sanitization.

Inputs: text (required), source, project, agent_id. Returns: extracted, storedCount

recallA
Read-only
Inspect

Retrieve relevant persisted memory using semantic, temporal, priority, or hybrid routing. Governance: requires reason (10โ€“200 chars). Rate limit: 20/min.

Inputs: query (required), reason (required), mode, limit, +2 more. Returns: count, scope, memories

recall_memoryA
Read-only
Inspect

Recall persisted memory by query. Alias of recall.

Inputs: query (required), reason (required), mode, limit, +2 more. Returns: count, scope, memories

save_memoryC
Idempotent
Inspect

Save a memory entry to the persistent store. Alias of save_to_synapse.

Inputs: content (required), tags, agent_id, force_intent, +1 more. Returns: id, scope, stored

save_to_synapseA
Idempotent
Inspect

Persist memory with encryption at rest, sanitization, and deduplication controls.

Inputs: content (required), tags, type, project, +4 more. Returns: id, scope, stored

slo_reportB
Read-only
Inspect

Return uptime and SLO metrics for the MCP service.

Inputs: admin_token (required), window_hours. Returns: p50, p95, uptime, window, +1 more

store_memoryB
Idempotent
Inspect

Store structured memory with metadata and trust scoring.

Inputs: content (required), tags, agent_id, force_intent, +1 more. Returns: id, scope, stored

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelogโ€ฆ

    TDQS

    B3.4/5.0

    Scored across 13 tools

    Disambiguation3/5

    There is overlap between `save_memory` and `save_to_synapse` (aliases), and `recall_memory` and `recall` (aliases), which creates ambiguity. `save_to_synapse` and `store_memory` also have very similar purposes, potentially causing misselection.

    Naming Consistency3/5

    Most tools use a verb_noun pattern (e.g., list_memories, save_memory, recall_memory), but `neural_handover` breaks this pattern by using an adjective_noun. `slo_report` is a contraction that doesn't follow the strict verb_noun structure, introducing inconsistency.

    Tool Count4/5

    With 13 tools, the count is within the well-scoped range (3-15). The presence of aliases inflates the number slightly, but otherwise, each non-alias tool serves a distinct purpose, making the count appropriate.

    Completeness4/5

    The tool surface covers core CRUD operations (save, recall, list, search) and lifecycle operations (initialize, feedback, handover). Minor gaps exist, such as missing explicit update or delete tools for memories, but the domain coverage is generally strong.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to store and semantically retrieve durable memories across sessions via MCP or REST, with tools for remembering, recalling, asking, updating, and forgetting memories.
      17 npm
      MIT
    • F
      license
      A
      quality
      B
      maintenance
      Shared fleet memory for AI agents โ€” what one agent learns, the whole fleet knows. Nightly self-correction: stale facts rewritten in place, duplicates merged. Recall pushed into every prompt in supported coding agents. Self-hosted.
      11
      3
      -