Built on Model Context Protocol

Memory that forgets like a mind, not a database.

HeurChain gives AI agents structured, temporal memory that persists across sessions. Three tiers with ACT-R decay rates. Sub-200ms hybrid retrieval. Three lines of code to integrate.

View on GitHub See Pricing
ops/
d=3.0 — fastest decay
notes/
d=1.0 — standard decay
self/
d=0.1 — near-permanent
Three memory tiers. Structurally enforced forgetting.
How it works

Three tiers that behave like memory, not a database.

Memory stored yesterday behaves differently from memory stored six months ago — enforced structurally, not by policy.

ops/ 3× decay

Hot operational context

Current session data, active task state, real-time debugging trails. Fades fast by design — noise from yesterday shouldn't pollute today's focus.

  • Active task tracking
  • Debug sessions
  • Short-horizon agent state
notes/ 1× decay

Reference knowledge

Cross-session knowledge, summaries, learned facts. Standard ACT-R decay rate — information persists proportionally to how often it's accessed.

  • User preferences
  • Project summaries
  • Recurring facts, domain knowledge
self/ 0.1× decay

Agent identity

Persona definitions, behavioral constraints, long-term preferences. Near-permanent — decays at one-tenth the baseline rate.

  • Agent persona
  • Hard constraints
  • Core identity outlasts the session
Architecture

Built for speed. Designed for scale.

<200ms
Hybrid retrieval P95
BM25+Qdrant fusion via RRF. Sub-200ms at P95 under typical agent load.
10M
Tokens per group/month
Workgroup plan covers typical agent teams at 4.5× headroom. Flat rate, no overages.
3-tier
Temporal memory
ops/ notes/ self/ with distinct ACT-R decay rates. Forgetting is a feature.
Compatible Agents API Layer Index Layer Context
Anthropic
Kimi
OpenAI
NNous
hc.add()
hc.search()
HeurChain API · MCP · Decay
Redis Qdrant BM25
Vector Index + BM25 Index
Context
RRF Fusion + ACT-R Decay Scheduler
Integration

Three lines of code. Full memory stack.

Python, TypeScript, Docker. MCP native — Claude Code, Cursor, Windsurf, any MCP client.

from heurchain import HeurChain

# Store a memory
hc = HeurChain(url="http://localhost:3010", token="your-token")

results = hc.search(
    "display preferences",
    user_id="user_123"
)
# Get proactive context at session start
context = hc.context(user_id="user_123")

# Returns: { "memories": [...], "decay_scores": [...], "relevance": 0.97 }
import { HeurChain } from "heurchain"

const hc = new HeurChain({
  url: "http://localhost:3010",
  token: "your-token"
})

// Store a memory
await hc.add(
  "User prefers dark mode",
  { userId: "user_123" }
)

// Get proactive context at session start
const context = await hc.context({ userId: "user_123" })
docker compose up -d

# Running in <10 min
→ BM25 + Qdrant hybrid search, fused via Reciprocal Rank Fusion
→ Session consolidation: ops/ compresses to 5–15 token cues automatically
→ Working-group isolation at vault level, Redis namespace, Qdrant collection
→ MCP native — Claude Code, Cursor, Windsurf, any MCP client

Every session, your agents start from zero. They don't have to.

HeurChain gives AI agents the memory infrastructure that survives across sessions, models, and machines — with no prompt engineering required. Structured, temporal, fast. Built on Model Context Protocol.

Deploy self-hosted Start Solo — $5/mo