What is ICM — Infinite Context Memory?

ICM is permanent persistent memory for AI agents. It is a single Rust binary with SQLite storage that exposes 22 MCP tools. ICM provides three memory systems: episodic memories with temporal decay (4 importance levels), semantic knowledge graphs with typed relations, and a correction feedback system. It auto-configures 14 AI editors including Claude Code, Cursor, Windsurf, VS Code, Gemini Code Assist, Zed, Amp, Amazon Q, Cline, Roo Code, Kilo Code, Codex CLI, and OpenCode. 100% local, zero API keys required, MIT licensed.

How does ICM memory decay work?

ICM uses 4 importance levels: critical (never decays), high (slow decay), medium (normal decay), and low (fast decay — fades in days). Memories are stored with a timestamp and importance score. Trivial details like debug notes fade naturally while critical architectural decisions remain permanently. This mirrors human memory prioritization without manual cleanup.

How does ICM compare to Mem0 and other AI memory tools?

Mem0 ($24M funded, 41K GitHub stars) requires cloud infrastructure and API keys. Zep/Graphiti (20K stars) requires Neo4j and an OpenAI API key. mcp-memory-service (1.3K stars) is MCP-native but lacks knowledge graphs and temporal decay. ICM offers a single Rust binary with SQLite — no Docker, no Python, no cloud. It combines hybrid BM25+vector search, knowledge graphs, and temporal decay in one zero-dependency binary that installs with a single cargo install command.

How do I install ICM and connect it to my AI editor?

Install with: cargo install icm — then run icm init to auto-configure your editors. ICM detects and configures 14 editors automatically. For Claude Code specifically, it registers ICM as an MCP server exposing all 22 tools. No manual JSON editing required.

Is ICM data stored locally or in the cloud?

ICM is 100% local. All data is stored in a SQLite file on your machine. Embeddings use BAAI/bge-small (384-dimensional vectors) running locally with no API calls. No data leaves your machine. No API keys required.

Open Source · MIT License · Written in Rust

Your AI forgets everything.
ICM fixes that.

ICM gives AI agents real persistent memory. Episodic memories with temporal decay, semantic knowledge graphs, hybrid search — in a single binary.

∞ session memory

0 context lost

22 MCP tools

1 single binary

Install ICM Star on GitHub Join Discord

Why ICM?

Your AI restarts from zero every session. ICM changes that.

Temporal Decay

Memories fade naturally based on importance. Critical decisions stay forever. Trivial details disappear. Like human memory.

Knowledge Graphs

Memoirs organize concepts with typed relations: depends_on, contradicts, refines. Structured knowledge, not flat notes.

Hybrid Search

BM25 keyword search (30%) + vector cosine similarity (70%) via sqlite-vec. Find memories by meaning, not just keywords.

MCP Native

22 tools exposed via Model Context Protocol. icm init auto-configures 14 editors: Claude Code, Cursor, Windsurf, VS Code/Copilot, Gemini Code Assist, Zed, Amp, Amazon Q, Cline, Roo Code, Kilo Code, Codex CLI, OpenCode, and more.

100% Local

Everything stays on your machine. SQLite storage, local embeddings (384-dim via BAAI/bge-small), no cloud, no API keys.

Single Binary

One cargo install. No Docker, no Python, no Qdrant, no Redis. Just a Rust binary and a SQLite file.

Feedback System

Record corrections when AI predictions are wrong. Search past feedback to avoid repeating mistakes. Track correction stats over time.

Auto-Extraction Hooks

Three lifecycle hooks — PostToolUse, PreCompact, UserPromptSubmit — automatically extract and store context at zero LLM cost.

Three memory systems

Three complementary systems for different types of knowledge.

Memories Episodic

Session context, decisions, resolved errors. Stored with importance levels. Fade naturally over time — critical stays forever, trivial disappears.

icm_memory_store

# topic: "decisions-auth"
# content: "JWT with RS256, 30-day expiry"
# importance: critical  # never decays

# topic: "debug-notes"
# content: "Tried port 3000, was busy"
# importance: low  # fades in days

4 importance levels auto-decay hybrid search topic-based

Memoirs Knowledge Graph

Permanent knowledge containers. Concepts linked by typed edges form a graph. Never decay, only refined. Architecture decisions, domain models, project structure.

permanent typed relations BFS traversal revision tracking

Feedback Corrections

Record when AI predictions are wrong. Search past corrections to inform future decisions. Track accuracy improvements over time.

icm_feedback_record

# predicted: "port 3000 is available"
# actual: "port 3000 was in use"
# context: dev-server

$ icm_feedback_search \
    query="port configuration"
Found 2 corrections

$ icm_feedback_stats
12 corrections recorded

record corrections search feedback accuracy stats

See it in action

Simple MCP tools, powerful results.

Store & Recall

$ icm_memory_store \
    topic="decisions-auth" \
    content="JWT with RS256, 30d expiry" \
    importance=critical

$ icm_memory_recall \
    query="authentication token"
Found 3 memories (best: 0.92)

$ icm_memory_consolidate \
    topic="decisions-auth"
Consolidated 8 → 1 summary

Knowledge Graph

$ icm_memoir_create \
    name="backend-arch"

$ icm_memoir_add_concept \
    memoir="backend-arch" \
    name="auth-service" \
    definition="JWT RS256, Axum middleware"

$ icm_memoir_link \
    from="api-gateway" \
    to="auth-service" \
    relation=depends_on

Explore

$ icm_memoir_inspect \
    name="auth-service" depth=2
auth-service
  ←depends_on api-gateway
  →depends_on user-store
  ←part_of    jwt-tokens

$ icm_memoir_search_all \
    query="database schema"
Found 5 concepts across 2 memoirs

Shared memory, multiple agents

Watch how context flows between agents and sessions.

Agents

Memories

Click Auto to watch the demo or Step to go one action at a time.

The AI memory landscape

From flat files to $24M startups. Here's how they compare.

Mem0 $24M raised

Market leader. Cloud-first memory platform with managed API.

Python Docker Qdrant OpenAI API

41K GitHub stars

Requires API key + cloud infra

Not MCP native

Zep / Graphiti Open Source

Temporal knowledge graph with LLM extraction. Most sophisticated OSS approach.

Python Neo4j OpenAI API

20K stars, deep graph model

Requires Neo4j + API key

Heavy infrastructure

mcp-memory-service MCP

Community MCP memory server. Simple key-value store with ChromaDB.

Python ChromaDB pip install

1.3K stars, MCP native

No knowledge graphs

No temporal decay

Built-in Memory CLAUDE.md / Cursor / Windsurf

File-based instructions or basic cloud memory. Good enough for simple preferences.

Flat file Manual No search

Zero setup, built into tool

No semantic search

No cross-tool sharing

ICM The SQLite of AI memory

Rust SQLite Zero deps

Single binaryNo Docker, no Python, no cloud

Hybrid searchBM25 + 384-dim vectors, local embeddings

Knowledge graphsTyped relations, BFS traversal, revision tracking

22 MCP toolsAuto-configures 14 editors via icm init

Temporal decay4 importance levels, automatic memory aging

100% local & privateZero API keys, zero cloud, your data stays yours

Install in seconds

Single binary. No Docker, no Python, no external services.

Via Cargo

From crates.io

cargo install icm

From Source

Latest from GitHub

cargo install --git https://github.com/rtk-ai/icm

Pre-built Binaries

macOS, Linux, Windows

Download from Releases →

Then auto-configure your editor

icm init

Auto-detects and configures 14 editors: Claude Code, Cursor, Windsurf, VS Code/Copilot, Gemini Code Assist, Zed, Amp, Amazon Q, Cline, Roo Code, Kilo Code, Codex CLI, and OpenCode. Your AI agent can now store memories, build knowledge graphs, record feedback, and recall context across sessions.

Your AI starts from zero.
Every. Single. Time.

Install ICM. Give your AI agent a memory it deserves.

Install ICM Star on GitHub

Your AI forgets everything.ICM fixes that.