Sovseal Memory

Zero-knowledge, local-first AI memory for work you can't send to the cloud.

One private memory across Claude, ChatGPT, Cursor, and every MCP client — plaintext physically never leaves your machine.

@sovseal/mcp-server · @sovseal on npm · Quickstart · How it compares · Changelog

Why this exists

If you work with code, clients, or data you're not allowed to upload — healthcare, legal, fintech, defense, or anything under an NDA — every AI memory option today asks you to break that rule. Platform memory keeps your context on their cloud, in their walled garden, one platform at a time. Cloud memory layers route your raw conversations through third-party servers and extraction APIs.

sovseal takes the other path: all capture, embedding, and recall run on your device. Plaintext never crosses the network. The optional sync tier ships only AES-256-GCM ciphertext — the server cannot read your memories even if it wanted to. And because it speaks MCP and rides a browser extension, it's *one* memory across every AI you use, not six silos.

Measured Performance & Benchmarks (May 2026)

Cloud-hosted memory layers force a tradeoff between latency, privacy, and cost. Every recall is a 200–800 ms round-trip to someone else's database. sovseal collapses the tradeoff. LanceDB and Transformers.js run *inside* your agent's process.

All benchmarks reproduce with: pnpm --filter @sovseal/mcp-server run bench-v2 (10K pre-seeded memories, 1K sequential queries, CPU-bound ONNX embeddings on commodity hardware).

What makes it fast and private:

• Sub-25 ms p99 recall — semantic search is a local vector query, not an HTTP call.
• On-device embeddings — a pinned, hash-verified 384-dim MiniLM model (~22 MB quantized ONNX) runs locally. No embedding API, no per-call cost.
• Zero-knowledge sync — when replication is enabled, AES-256-GCM encryption happens before any byte leaves the device. The server stores ciphertext it cannot decrypt.
• Verified Semantic Recall (VSR) — every load re-derives sha256(canonicalize(payload)) and fails closed on mismatch.
• Deterministic lineage — snapshot graph enables byte-equal state restoration.

Introduction

sovseal gives AI assistants and autonomous agents persistent, portable context that you actually own. It drops into any MCP-compatible client, captures from the major chat platforms via a browser extension, and keeps your plaintext where it belongs: on your hardware.

Key Features & Use Cases

Core Capabilities:

• Local-First Semantic Memory: On-device LanceDB + 384-dim Transformers.js embeddings for 0-RTT recall.
• Cross-Platform Capture: The browser extension captures and recalls across ChatGPT, Claude, Perplexity, Grok, Gemini, and DeepSeek — one memory, six platforms, ⌘/Ctrl+M anywhere.
• Zero-Knowledge Sync (optional): Replication ships only end-to-end AES-256-GCM ciphertext. Local-only mode works fully offline with no account.
• Write-Behind Replication: Tool calls return on local commit; ciphertext sync happens asynchronously.
• Developer-Friendly: Drop-in MCP server, Node SDK, and self-hosted edge endpoints.

Who it's for:

• Privacy-Constrained Teams: Healthcare, legal, fintech, and defense-adjacent teams whose policies require plaintext to stay on-device.
• AI Power Users: People working across Claude Desktop, Cursor, ChatGPT, and more who are tired of six AIs with six separate amnesias.
• Agent Frameworks: ElizaOS, Hermes, CrewAI, and LangGraph consume the MCP server natively — local memory with no per-call API bill.

⚖️ How sovseal compares

An honest map, because you'll ask anyway:

What you give up with sovseal, stated plainly: there's no cloud LLM doing clever extraction on your behalf (by design — that's the leak we exist to prevent), and you are responsible for your own key (see Threat Model). If neither of those matters to you and you live inside one platform, its native memory may be all you need. If they do matter, nothing else in this table does what the right-hand column does.

🚀 Quickstart Guide

Choose your path

sovseal exposes one protocol with three delivery shapes. Pick by where your code runs:

MCP Server

The default for AI coding assistants and any agent framework that speaks MCP. One server binary, one config snippet, every client.

Claude Desktop, Cursor, Windsurf, Zed — add to mcp.json or claude_desktop_config.json:

{

"mcpServers": { "sovseal-memory": { "command": "npx", "args": ["-y", "@sovseal/mcp-server"] } } }

One-line install for Claude Code:

claude mcp add sovseal -- npx -y @sovseal/mcp-server

System Prompt Snippet (Claude Desktop / Cursor Project Instructions): To ensure the AI natively uses the memory server, paste this into your custom instructions:

This session has persistent memory via sovseal. At conversation start, check the sovseal://context/recent resource. Whenever the user shares preferences, plans, or personal context, store it via store_memory.

For always-on autonomous agents, switch to HTTP/SSE transport so the sovseal process outlives a single tool invocation:

SOVSEAL_TRANSPORT=sse SOVSEAL_PORT=4040 npx -y @sovseal/mcp-server

Browser Extension

For the AI platforms that don't speak MCP. The extension bridges ChatGPT, Claude.ai, Perplexity, Grok, Gemini, and DeepSeek to the same on-device engine over Native Messaging — capture-on-send as you chat, ⌘/Ctrl+M to recall anywhere, with per-site toggles and one-click delete.

1. Install from the Chrome Web Store, then run the one-time local host installer.
2. Confirm the popup shows "On-device engine connected."
3. Chat normally; press ⌘/Ctrl+M in any supported platform to recall.

Everything the extension captures lives in the same local database the MCP server reads — tell Claude.ai something once, and Claude Code already knows it.

Node SDK (Library)

When you're building a backend service and want to manage agent state persistence programmatically, import the Node SDK client. It performs end-to-end AES-256-GCM encryption client-side and replicates checkpoints to a sync endpoint you choose.

npm install @sovseal/sdk

import { AgentStateClient, CryptoService } from "@sovseal/sdk";

const client = new AgentStateClient({ endpoint: "https://your-project.supabase.co/functions/v1/v2-agent-state", apiKey: "sov_proj_your_project_uuid", });

const key = await CryptoService.generateAESKey();

// Client-side AES-GCM encrypted snapshot upload const receipt = await client.snapshot({ key, payload: { agent_id: "agent_a1b2c3", sequence_number: 0, parent_snapshot: null, policy_hash: "0000000000000000000000000000000000000000000000000000000000000000", timestamp: new Date().toISOString(), active_context: { project: "acme-migration", decisions: ["Postgres over Mongo — team expertise", "Cut scope: no SSO in v1"], open_question: "Client prefers staged rollout; confirm dates with their ops lead." } } });

// Restore the latest state snapshot const { receipt: latestReceipt, ciphertextUrl } = await client.restore({ agentId: "agent_a1b2c3", });

Self-Hosted Edge

The replication endpoint is a Deno edge function — open source, deployable to any Supabase project for full data-residency control.

# From the repo root

supabase functions deploy v2-agent-state supabase db push # applies the agent_state_snapshots schema

Point any client at it:

export SOVSEAL_ENDPOINT="https:// .supabase.co/functions/v1/v2-agent-state"

Source: supabase/functions/v2-agent-state/.

🔗 Integrations & Agent Frameworks

All of these consume the same MCP server through their first-class MCP support. No sovseal-specific adapter is required:

🛠️ MCP Tools Exposed to the LLM

| recall_memory | `{ query: string, topK?: