Evolutiondb MCP Server

EvolutionDB — Powering Long-Term Memory for Agents

A single-process database that gives AI agent frameworks everything they need from one binary: SQL + vector search + JSON + temporal queries + reactive push streaming with first-class adapters for LangGraph, LangChain, LlamaIndex, CrewAI, AutoGen, and Mem0.

Replace the MongoDB + Pinecone dual-stack — and the polling loops that go with it — with a single Postgres-compatible server you run locally or on-prem.

Why EvolutionDB for agent memory

For the head-to-head against MongoDB / Pinecone / Zep / Mem0 / Weaviate see docs/comparison.md.

60-second quickstart

docker compose up -d              # PG:5433  EVO:9967

# Python (LangGraph drop-in via the bundled adapter)
export PYTHONPATH=$PWD/client/python-evosql-memory:$PYTHONPATH
python3 - <<'PY'
from evosql_memory import connect
from evosql_memory.adapters.langgraph_evosql import EvoCheckpointSaver, EvoBaseStore

c = connect("127.0.0.1", 9967, "admin", "admin")
saver = EvoCheckpointSaver(c, "demo_ck")
store = EvoBaseStore(c, "demo_mem")

cfg = {"configurable": {"thread_id": "agent-1", "checkpoint_ns": ""}}
saver.put(cfg, {"id": "cp-1", "channels": {"step": 1}})
print("latest:", saver.get(cfg))

store.put(("user_42", "memos"), "favourite", {"genre": "jazz"})
print("memo:",   store.get(("user_42", "memos"), "favourite"))
PY

The full quickstart (C SDK, ReAct demo, Mem0 drop-in, reactive subscription) is at docs/quickstart.md.

SQL surface (first-class objects)

-- LangGraph BaseCheckpointSaver
CREATE CHECKPOINT STORE agent_checkpoints;

-- LangGraph BaseStore + LangChain VectorStoreRetrieverMemory
CREATE MEMORY STORE agent_memories WITH (embedding_dim = 1536);

-- LangChain BaseChatMessageHistory + LlamaIndex ChatMemoryBuffer
CREATE MESSAGE LOG agent_chat;

-- Haystack DocumentStore + LlamaIndex BaseDocumentStore
CREATE DOCUMENT STORE agent_docs;

-- Zep Graphiti + Mem0 graph mode (bitemporal edges)
CREATE GRAPH STORE agent_kg;

-- LangChain ConversationEntityMemory + CrewAI EntityMemory
CREATE ENTITY STORE agent_entities;

Plus everything you'd expect from a relational engine: tables, indexes, constraints, JOINs, subqueries, transactions, MVCC, prepared statements, COPY, replication, RLS.

Clients

Compatibility tests for every adapter run on push and PR via framework-compat.yml.

Performance (single process, p99)

From bench/run_all.py (full report at docs/benchmarks/v1.md):

Push is roughly 2900× faster than a 1-second polling loop — the gap that lets reactive agents react in real time instead of every poll tick.

Build

Requirements: GCC, Bison, Flex, libreadline-dev. For TLS: libssl-dev.

make                  # core engine + adaptor + CLI
make adaptor TLS=1    # build with OpenSSL TLS support
make clean
make generate         # regenerate Flex/Bison parser from .y/.l files
make -C client/libevosql-memory   # build the C SDK

Docker

docker compose up -d                    # PG:5433  EVO:9967
docker compose down                     # stop (data preserved)
docker compose down -v                  # stop and delete data

docker run -d -p 5433:5433 -p 9967:9967 \
    -e EVOSQL_PASSWORD=mysecret evolutiondb/evolutiondb:latest

Run the whole stack (engine + agent)

One command brings up the SQL engine plus the standalone agent web UI:

./install.sh                            # bootstrap + build + up

install.sh is idempotent. It checks Docker is present, copies .env.example to .env (never overwriting an existing .env), generates a random EVOSQL_PASSWORD and EVOSQL_ENCRYPTION_KEY if those are still blank/admin, then runs the agent profile. To do it by hand:

cp .env.example .env                    # then edit secrets in .env
docker compose --profile agent up -d    # engine + agent web UI

A plain docker compose up -d (no --profile agent) still brings up the engine only, exactly as before. After the stack is up:

• PostgreSQL wire : 127.0.0.1:5433
• EVO protocol : 127.0.0.1:9967
• Agent web UI : http://127.0.0.1:8800

Set ANTHROPIC_API_KEY in .env to enable the cloud LLM (without it the agent runs with no LLM turns).

Secure-by-default posture

• Loopback host ports. Every published port binds to 127.0.0.1, so a fresh install is not reachable from the LAN or internet.
• Set secrets in .env. EVOSQL_PASSWORD defaults to admin only when left blank; change it (or let install.sh generate one). The .env file is gitignored — never commit it.
• Exposing publicly is opt-in. To serve beyond loopback you must set EVOSQL_BIND=0.0.0.0 (the engine binds 127.0.0.1 by default), provide a TLS cert/key, and set EVOSQL_MCP_AUTH_TOKEN for the MCP HTTP transport. Drop the 127.0.0.1: prefix on the compose port mappings only after those are in place.

Data-handling notes (what is and isn't protected)

• PII masking is opt-in and field-level. At rest it runs per connector via protect_record(); at retrieval via EVOSQL_PII_RETRIEVAL; outbound to an LLM it masks only when EVOSQL_PII_EGRESS=on. Default off means enrichment text reaches the model provider unmasked. (The agent image always installs evolutiondb-pii, so turning egress masking on never fail-closes.) name/DOB rules ship disabled (heuristic only).
• Encryption at rest (TDE) needs both halves. Whole-DB AES-256-CTR page encryption activates only with a TLS=1 / EVO_ENCRYPTION build and an EVOSQL_ENCRYPTION_KEY passphrase. Without both, the DB file and the WAL are plaintext on disk. Page 0 (FileHeader) is always plaintext. CTR gives confidentiality, not tamper-detection.
• Send invariant (ADR-004). The agent never sends on its own; it drafts and queues, a human approves (approve_send), and delivery is dry-run unless explicitly opted in.
• Roadmap, not shipped: key rotation, per-tenant RLS, engine MASKING SQL, and reliable person-name redaction.
• Sub-processors depend on what you enable. Models: Anthropic (default, optional), OpenAI (optional embeddings), Gemini/Azure (named, not wired by default), Ollama (local, no egress). Connectors that call external APIs: Google (Gmail/Calendar/YouTube), Microsoft (Outlook/Teams), Slack, GitHub, Notion, Azure DevOps. Local-only (no sub-processor): iMessage, Apple Notes, Browser history, Claude sessions. Connector scopes are read-only by default; send scopes are opt-in.

Testing

docker compose up -d
python tests/test_memory_store.py
python tests/test_checkpoint_store.py
python tests/test_evo_protocol.py
python client/python-evosql-memory/python_tests/test_adapters.py
python tests/framework_compat/langgraph/test_lg_compat.py

Background

EvolutionDB started ~18 years ago as a personal C database project to learn how engines work internally — parser, storage, indexing, execution layer, all from scratch. It was archived on a DVD and sat dormant for over a decade.

Resumed in early 2026 with AI-assisted development, the engine matured into a Postgres-compatible relational core and then pivoted toward agent memory: storing the kind of structured, semi-structured, vector-indexed, and time-versioned state that AI agent frameworks need but currently get by stitching together MongoDB + Pinecone + custom polling + a hand-rolled checkpointer.

The agent-memory pivot is documented in ADR-002.

Documentation

• 60-second quickstart
• Comparison vs MongoDB / Pinecone / Zep / Mem0 / Weaviate
• Benchmarks
• ADR-002 — Agent Memory pivot
• Release notes 3.0.0
• Launch blog post

Architecture deep-dives live in the Wiki:

• Architecture Overview
• Unified Storage
• Storage Engine · B+ Tree · System Catalog
• SQL Parser · SQL Operations · Expression Engine
• Transactions
• PostgreSQL Wire Protocol · EVO Protocol
• Authentication and Security
• Server Architecture
• CLI Client