Engram Server

⚡ Engram

Durable memory for AI agents — temporal knowledge graph, hybrid retrieval, SQLite or PostgreSQL.

java-ai-memory.dev · Main repo · JamJet docs · Discord

---

Engram is a durable memory layer for AI agents. It extracts facts from conversations, stores them in a temporal knowledge graph, and retrieves them with hybrid semantic + keyword search — backed by a single SQLite file or a PostgreSQL database.

It ships in two shapes:

• `jamjet-engram` — a Rust library you embed in your own application.
• `jamjet-engram-server` (this crate) — a standalone binary that speaks MCP over stdio and REST over HTTP, so Claude Desktop, Cursor, and any HTTP client can use it with no code.

Engram is provider-agnostic. Five LLM backends are wired in out of the box, and a sixth — command — lets you shell out to any external script, so you can plug in a provider Engram does not ship natively without touching Rust code:

Pick one with ENGRAM_LLM_PROVIDER=… — the same binary handles all of them.

State of the project, April 2026. Engram is new — v0.3.2, small community, no public LongMemEval / DMR numbers yet. The architecture below works, the tests pass, the Docker image runs. If you need production-scale memory today, Mem0 Cloud and Zep Cloud are more mature. If you need a tryable, self-hostable, single-binary memory layer that doesn't require Python, Postgres, Qdrant, or Neo4j, Engram is built for you.

Why Engram?

---

Quickstart — 30 seconds

Engram speaks to four LLM providers out of the box: Ollama (default — free, local), OpenAI, Anthropic Claude, and Google Gemini. Pick one.

Option A — Ollama (free, local, zero API keys)

Requirements: Ollama with llama3.2 and nomic-embed-text pulled:

ollama pull llama3.2

ollama pull nomic-embed-text

Docker (easiest):

docker run --rm -i \

-v engram-data:/data \ ghcr.io/jamjet-labs/engram-server:0.3.2

The container defaults to Ollama at host.docker.internal:11434 — works out of the box on Docker Desktop for Mac and Windows. Linux users need --add-host=host.docker.internal:host-gateway.

Option B — Anthropic Claude (hosted, highest quality)

docker run --rm -i \

-e ENGRAM_LLM_PROVIDER=anthropic \ -e ANTHROPIC_API_KEY=sk-ant-... \ -v engram-data:/data \ ghcr.io/jamjet-labs/engram-server:0.3.2

Defaults to claude-haiku-4-5-20251001. Override with -e ENGRAM_ANTHROPIC_MODEL=claude-sonnet-4-6.

Note: Anthropic has no native JSON mode, so Engram parses JSON from text responses. The llm_util::extract_json_payload helper strips markdown fences that Claude occasionally emits.

Option C — Google Gemini

docker run --rm -i \

-e ENGRAM_LLM_PROVIDER=google \ -e GOOGLE_API_KEY=AIza... \ -v engram-data:/data \ ghcr.io/jamjet-labs/engram-server:0.3.2

Defaults to gemini-flash-latest. Override with -e ENGRAM_GOOGLE_MODEL=gemini-2.5-flash.

Option D — Any OpenAI-compatible endpoint

docker run --rm -i \

-e ENGRAM_LLM_PROVIDER=openai-compatible \ -e OPENAI_API_KEY=sk-... \ -v engram-data:/data \ ghcr.io/jamjet-labs/engram-server:0.3.2

Defaults to OpenAI itself (https://api.openai.com/v1, gpt-4o-mini). Change one env var to point at any of these providers without recompiling:

openai is accepted as a backwards-compatible alias for openai-compatible.

Option E — command (shell out to anything)

For providers Engram does not ship natively — an internal model behind a custom RPC, a raw SOAP endpoint, a local inference binary, a quick wrapper over a Python SDK, or tomorrow's new provider — use the command backend. Engram will spawn your script per extraction call, pipe a JSON request to its stdin, and read a JSON response from its stdout.

The contract. Your script reads one JSON object from stdin:

{"system": "<extraction prompt>", "user": "<conversation text>", "structured": true}

Then writes one JSON value to stdout. Either a bare value:

{"facts": [{"text": "...", "entities": [...], "confidence": 0.95, "category": "..."}]}

Or an envelope (useful for surfacing errors):

{"content": {"facts": [...]}}

{"error": "rate limited, try again"}

Exit 0 on success, non-zero (with stderr) on failure.

Example Python wrapper (~15 lines):

#!/usr/bin/env python3

my-llm.py — wraps any Python SDK for Engram.

import json, sys from my_llm_sdk import chat # your SDK

req = json.loads(sys.stdin.read()) resp = chat( system=req["system"], user=req["user"], json_mode=req.get("structured", False), ) sys.stdout.write(json.dumps(resp))

Point Engram at it:

docker run --rm -i \

-e ENGRAM_LLM_PROVIDER=command \ -e ENGRAM_LLM_COMMAND="python /scripts/my-llm.py" \ -v $(pwd)/scripts:/scripts \ -v engram-data:/data \ ghcr.io/jamjet-labs/engram-server:0.3.2

Timeout is 120 seconds by default — override with ENGRAM_LLM_COMMAND_TIMEOUT=30.

Security: the command provider runs arbitrary commands as the Engram process user. Never use it in a multi-tenant deployment where untrusted users can set ENGRAM_LLM_COMMAND. It is a local and single-tenant feature.

Option F — cargo install (all providers same binary)

cargo install jamjet-engram-server

engram serve # ollama (default) ENGRAM_LLM_PROVIDER=anthropic ANTHROPIC_API_KEY=... engram serve ENGRAM_LLM_PROVIDER=command ENGRAM_LLM_COMMAND="python /path/to/wrapper.py" engram serve

Option G — REST mode for testing

engram serve --mode rest --port 9090

curl -X POST http://localhost:9090/v1/memory \

-H 'content-type: application/json' \ -d '{ "user_id": "alice", "messages": [ {"role": "user", "content": "I am allergic to peanuts and I love sourdough."} ] }'

curl 'http://localhost:9090/v1/memory/recall?q=food%20allergies&user_id=alice'

No server. No config. No Python sidecar. One binary.

---

MCP client configuration

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json)

{

"mcpServers": { "engram": { "command": "docker", "args": [ "run", "--rm", "-i", "-v", "engram-data:/data", "ghcr.io/jamjet-labs/engram-server:0.3.2" ] } } }

Cursor / any MCP-aware IDE

Point it at the same docker run command, or at a locally-installed engram serve binary. After restart, eleven tools are available to the model (seven memory_* + four messages_*).

---

MCP tools

Memory tools (7)

All scoped by (org_id, user_id, session_id) — org is the coarsest, session the finest.

Message store tools (4)

---

REST API

Thirteen endpoints, rooted at /v1/memory. Full OpenAPI-style surface: