without engram
Every architecture decision, every convention, every critical fact… held somewhere safe.
Sub-millisecond hybrid retrieval (BM25 + Vectors + Fuzzy), dynamic knowledge graphs, and 243+ MCP tools. 100% local-first, zero-cloud lock-in, engineered for Gemini 3.7 Flash, DeepSeek-V4-Pro, Grok 4.6, Claude 5 Sonnet/Opus, GPT-5.6 Sol, Google Antigravity, and Cursor.
On the left, a model without memory. On the right, the same model backed by Engram. The words are identical — until two weeks pass.
A structured cognitive architecture built in Rust. Broad workspaces partition projects; sessions record time-based context; entity graphs link concepts; verbatim drawers preserve immutable decisions.
Strict cryptographic isolation per project. Distinct databases or segregated schemas prevent context contamination between repos.
Chronological units of time. Auto-indexed chat transcripts and scratchpads that decay dynamically unless promoted to permanent memory.
Bidirectional relationships linking facts. Canonical identity resolution unifies aliases (e.g. AuthService $\to$ auth-api).
The exact chunk of verbatim content. Full fidelity with timestamp, salience score, provenance, and contradiction guardrails.
The content stays verbatim — always. The index above it is compressed into 3-way hybrid embeddings and entity graphs that an agent can query in <2ms.
The decision, as recorded:
"We have decided to size the PostgreSQL connection pool to 25 connections with a 5s timeout. Use Tokio async/await for all I/O workers; reserve std::thread for CPU compute."
— immutable provenance: session_2026_07_14.jsonl
The pointer, as indexed in SQLite:
§ WS/backend/mem_98f4a1
@type decision ~ salience=0.95
@fts5 "postgresql connection pool size 25 timeout tokio"
@vec 384-dim cos_sim(query, v) [MiniLM ONNX]
@ent [PostgreSQL, ConnectionPool, Tokio, Rust]
@rel (configures) -> DatabaseWorker
§ ptr -> mem_98f4a1 (verbatim)Engineered from scratch in Rust for uncompromising privacy, performance, and determinism.
SQLite with Write-Ahead Logging on disk. Nothing is uploaded. Zero telemetry. Your memories live under a single directory on your machine.
3-way search (BM25 FTS5 + local MiniLM ONNX vectors + fuzzy distance) runs 100% on CPU. No OpenAI key or cloud embedding endpoint required.
Ingestion and indexing happen silently via lifecycle hooks on session end or compaction. Agents query durable context without rebuilding history.
Entity relations with valid-from and valid-to timestamps. Detects contradictions when requirements change and guides automated resolution.
Connect Engram seamlessly to coding assistants, agent swarms, and frontier LLM frameworks.
Native stdio/HTTP MCP integration for cross-session project memory, decision tracking, and repo context.
Real-time retrieval of architectural decisions and auto-discovered .cursorrules.
Persistent multi-agent memory and shared workspace context for complex agentic refactors.
Callable function tools for durable thread state, entity lookup, and fact verification.
Ultra-fast sub-millisecond memory lookups matching high-throughput reasoning loops.
Accurate code snippet indexing and entity-linked dependency knowledge graphs.
Stateful graph nodes that search, store, and compact memory across multi-agent workflows.
Shared crew memory with short-term, long-term, and entity memory adapters.
Test memory creation, hybrid retrieval, graph traversal, and contradiction checks in real time.
{
"jsonrpc": "2.0",
"result": {
"engine": "engram-wasm (WebAssembly in Browser)",
"status": "ready",
"message": "Click 'Run WASM Hybrid Search' to execute pure-Rust BM25, TF-IDF vector embeddings, and RRF fusion in real-time."
}
}
Engineered specifically for autonomous coding agents with local-first security and true hybrid retrieval.
| Feature | Engram | Mem0 | Zep (Graphiti) | Cognee | Generic MCP Memory |
|---|---|---|---|---|---|
| Core Runtime | Rust (Single Binary) | Python | Python / Cloud | Python | Node.js / Python |
| 100% Offline & Local-First | Partial (Cloud focus) | Partial | |||
| 3-Way Hybrid Search | Vector only | Vector + Graph | Graph + Vector | ||
| Knowledge Graph & Identity Resolution | Basic graph | ||||
| Memory Tiering & Salience Decay | |||||
| Contradiction Detection | Edge invalidation | ||||
| Transports Supported | REST API | REST / GraphQL | REST API | stdio only | |
| Active MCP Tools | 243 tools | ~6 tools | ~8 tools | ~10 tools | ~4 tools |
Use Engram from Rust, Python, TypeScript, CLI, or configure as an MCP server for your favorite agent.
// Cargo.toml: engram-core = "0.24.0"
use engram_core::{EngramEngine, MemoryBuilder, SearchQuery};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let engine = EngramEngine::open_local("~/.local/share/engram/memories.db")?;
// Create a permanent memory
let memory_id = engine.store_memory(
MemoryBuilder::new("PostgreSQL connection pool sized to 25 connections")
.workspace("backend")
.memory_type("decision")
.salience_boost(0.95)
.build()?
).await?;
// 3-way hybrid search (BM25 + Vectors + Fuzzy)
let results = engine.search(SearchQuery::new("postgres conn pool").workspace("backend")).await?;
for hit in results {
println!("Found [score {:.2}]: {}", hit.score, hit.content);
}
Ok(())
}One command to install. One to initialize. Your decisions and context — permanent, local, instantly recallable.
brew install aiconnai/engram/engram