engram-search 0.1.5

High-recall conversational memory retrieval. 98% R@5 on LongMemEval, 94% on LoCoMo — no LLM required. Local-first, cloud-ready.

Engram

High-recall conversational memory retrieval. Local-first, cloud-ready.

---

Benchmark Results

Tested on two major benchmarks — no LLM required, zero cost per query.

LongMemEval (500 questions)

Metric	Score
R@5	98.4% (492/500)
R@10	99.4%
NDCG@5	0.934

Question Type	R@5
knowledge-update	98.7%
multi-session	99.2%
single-session-assistant	100.0%
single-session-user	100.0%
temporal-reasoning	97.0%
single-session-preference	93.3%

LoCoMo (1982 questions, 10 conversations)

Metric	Score
R@5	93.9% (1862/1982)
R@10	95.0%
NDCG@5	0.894

Category	R@5	R@10
Single-hop (factual)	90.4%	93.3%
Temporal (dates)	93.1%	94.7%
Multi-hop (inference)	75.0%	78.3%
Contextual (details)	97.1%	97.5%
Adversarial (speaker)	94.6%	94.8%

Reported with --mode rerank (chunking + cross-encoder reranker + speaker-name injection).

What It Does

Engram stores conversation history and retrieves it with state-of-the-art accuracy. It uses a three-stage retrieval pipeline — dense embeddings, sparse keyword matching, and cross-encoder reranking — to achieve higher recall than systems relying on LLM-based extraction or summarization.

Nothing is summarized. Nothing is paraphrased. Your exact words are stored and returned.

How It Compares

LoCoMo Benchmark Comparison

Disclaimer: Results are compiled from multiple papers and evaluation reports. They are not directly comparable due to differences in backbone LLMs, prompting strategies, and evaluation setups.

System	LoCoMo Accuracy	LLM Required	Open Source	Source
Engram	93.9% (R@5)	No	Yes (MIT)	This repo (reproducible)
EverMemOS	86.76% – 93.05%	Yes	No	arXiv:2601.02163
Zep	85.22%	Yes	Partial	EverMemOS evaluation
MemOS	80.76%	Yes	Partial	EverMemOS evaluation
Mem0	64.20%	Yes	Partial	EverMemOS evaluation
MemU	61.15%	Yes	Partial	arXiv:2601.02163
Other LLM-based systems (Hindsight, MemGPT, Letta)	~83 – 92%	Yes	Varies	Secondary reports
Non-LLM systems (SLM variants)	~74 – 75%	No	Yes	Secondary reports

Engram is the top-performing system on LoCoMo — and the only one in the top tier with zero LLM calls at query time.

LongMemEval

	Engram	MemPalace	Mem0
R@5 (LongMemEval)	98.4%	96.6%	—
Embedding model	bge-large (1024d)	all-MiniLM (384d)	Varies
Sparse retrieval	BM25 + RRF fusion	Ad-hoc keyword overlap	N/A
Reranking	Cross-encoder (free)	LLM call ($0.001/q)	N/A
Indexing	User + assistant + preference docs	User turns only	LLM-extracted facts
Cloud deployment	Qdrant backend	No	Yes
LLM required	No	No (optional rerank)	Yes

Install

pip install engram-search

Optional extras:

# With cloud backend (Qdrant)
pip install engram-search[cloud]

# With cross-encoder reranker
pip install engram-search[rerank]

# Everything (dev + cloud + rerank)
pip install engram-search[all]

Quickstart — CLI

# Initialize a memory store
engram init ./my_memories

# Ingest conversations
engram ingest conversations.json --store ./my_memories

# Search
engram search "why did we switch to GraphQL" --store ./my_memories

Quickstart — Python API

from engram.backends.faiss_backend import FaissBackend
from engram.backends.base import Document
from engram.ingestion.parser import session_to_documents
from engram.retrieval.embedder import Embedder
from engram.retrieval.pipeline import RetrievalPipeline

# Initialize
embedder = Embedder("bge-large")
backend = FaissBackend(path="./my_memories", dimension=1024)
pipeline = RetrievalPipeline(embedder=embedder)

# Ingest a conversation
turns = [
    {"role": "user", "content": "I'm switching our API from REST to GraphQL."},
    {"role": "assistant", "content": "What's driving the switch?"},
    {"role": "user", "content": "Too many round trips. Our mobile app makes 12 calls per screen."},
]
docs = session_to_documents(turns, session_id="session_1", timestamp="2025-01-15")
texts = [d["text"] for d in docs]
embeddings = embedder.encode_documents(texts)

documents = [
    Document(id=d["id"], text=d["text"], embedding=e.tolist(), metadata=d["metadata"])
    for d, e in zip(docs, embeddings)
]
backend.add(documents)

# Search
results = pipeline.search("why did we switch to GraphQL", documents=documents, top_k=3)
for r in results:
    print(r.text)

Quickstart — Cloud Mode

# Set up Qdrant (managed or self-hosted)
export ENGRAM_BACKEND=qdrant
export ENGRAM_QDRANT_URL=https://your-cluster.qdrant.io:6333
export ENGRAM_QDRANT_API_KEY=your-api-key

# Start the API server
pip install fastapi uvicorn
uvicorn engram.server:app --host 0.0.0.0 --port 8000

API Endpoints

Method	Endpoint	Description
POST	/ingest	Add conversations
POST	/search	Search memories
GET	/health	Health check
GET	/stats	Store statistics

Examples

Check out the interactive notebooks in examples/:

Notebook	Description
Getting Started	Ingest conversations, search memories, understand hybrid retrieval
Customer Support	Build a support agent with full customer history recall
Personal Assistant	AI assistant with long-term memory across conversations

Docker

# Local mode
docker compose up

# Or build and run directly
docker build -t engram .
docker run -p 8000:8000 -v engram_data:/data engram

Architecture

┌─────────────────────────────────────────────────────────────┐
│                        Engram                               │
│                                                             │
│  ┌────────────┐  ┌─────────────┐  ┌───────────────────┐    │
│  │ Ingestion  │  │   Index     │  │    Retrieval      │    │
│  │            │→ │             │→ │                   │    │
│  │ user+asst  │  │ FAISS (local│  │ 1. Dense (bi-enc) │    │
│  │ turns      │  │  or Qdrant  │  │ 2. BM25 (sparse)  │    │
│  │ preference │  │ (cloud)     │  │ 3. RRF fusion     │    │
│  │ extraction │  │             │  │ 4. Cross-encoder   │    │
│  └────────────┘  └─────────────┘  └───────────────────┘    │
│                                                             │
│  Local: FAISS + SQLite    Cloud: Qdrant + REST API          │
└─────────────────────────────────────────────────────────────┘

Run Benchmarks

LongMemEval

# Download dataset
curl -fsSL -o data/longmemeval_s_cleaned.json \
  https://huggingface.co/datasets/xiaowu0162/longmemeval-cleaned/resolve/main/longmemeval_s_cleaned.json

pip install engram-search[all]

python benchmarks/longmemeval_bench.py data/longmemeval_s_cleaned.json --mode hybrid

LoCoMo

# Download dataset (from Snap Research)
curl -fsSL -o data/locomo10.json \
  https://raw.githubusercontent.com/snap-research/locomo/main/data/locomo10.json

python benchmarks/locomo_bench.py data/locomo10.json --mode rerank

Requirements

• Python 3.9+
• ~1.3 GB disk for bge-large embedding model (downloaded on first use)
• No API keys required for local mode

License

MIT