🧠 Layered · RL-scored · Log-first · MCP-ready

Memory that gets smarter
the more your agent uses it

Stop rebuilding RAG pipelines. Extremis gives any AI agent layered, learning memory in two lines of config — local SQLite, Postgres, Chroma, or Pinecone.

Get started View on GitHub →
pip3.11 install extremis
Deploy to Render one click · auto-provisions Postgres · memory lives in the cloud

How it works

Every conversation logs durably. Every recalled memory gets scored. Every night the logs distil into structured knowledge.

Free · no LLM

remember()

Append to a fsync'd JSONL log and write to the episodic store in one call. Durable before any embedding happens.

Free · no LLM

recall()

Semantic search ranked by cosine × RL score × recency. Identity and procedural memories always included. Every result ships with a plain-English reason.

Free · no LLM

report_outcome()

Mark recalled memories useful (+1) or harmful (-1). Negative signals apply 1.5× weight — same asymmetry human threat-memory uses.

Uses Claude Haiku

consolidate()

The "dream pass" — reads new log entries, calls Claude Haiku to extract durable semantic and procedural facts, advances the checkpoint. Safe to re-run.

Install

No API key needed. No account required.

⚠️
Requires Python 3.11+. If pip install extremis says "no matching distribution found", your default python3 is older. Check: python3 --version

macOS fix: brew install python@3.11 then use pip3.11 install extremis
Linux: sudo apt install python3.11 python3.11-pip  ·  Windows: python.org/downloads
# First: confirm you have Python 3.11+
python3.11 --version

# Core — local SQLite, sentence-transformers (no API key)
pip3.11 install extremis

# + MCP server for Claude Desktop / Code
pip3.11 install "extremis[mcp]"

# + Postgres, Chroma, Pinecone, OpenAI embeddings, hosted server
pip3.11 install "extremis[all]"

Quick start

from extremis import Extremis, MemoryLayer

mem = Extremis()  # stores in ~/.extremis/ by default

# Store
mem.remember("User is building a WhatsApp AI", conversation_id="c1")
mem.remember_now("Always ask about deadlines first", layer=MemoryLayer.PROCEDURAL)

# Recall — every result explains why it ranked here
results = mem.recall("what is the user building?")
for r in results:
    print(r.memory.content)
    print(r.reason)  # "similarity 0.87 · score +2.0 · used 5× · 3d old"

# Reinforcement — good memories surface first over time
mem.report_outcome([r.memory.id for r in results[:2]], success=True)

# Try the demo
# $ extremis-demo

Why Extremis

Most memory systems are cosine search over a flat vector DB. Extremis is different in five ways.

🧬

Memory that forgets intelligently

Recency decay + 1.5× asymmetric RL weighting. Unimportant things fade. Mistakes stick harder. The same pattern human threat-memory uses.

🔍

Every recall explains itself

r.reason"similarity 0.91 · score +4.0 · used 8× · 3d old". Every result tells you exactly why it ranked there. Auditable. Debuggable. No black box.

🤝

Cross-agent shared memory

Multiple agents share one namespace. Research agent stores, writing agent recalls. Agent teams ship as one brain.

🔌

Backend-agnostic

SQLite locally. Postgres in staging. Pinecone in production. One env var. Migrate between any two with extremis-migrate.

🕸️

Knowledge graph built in

Entities, relationships, attributes. Answers "who does Alice work for" — the structural question vectors can't.

MCP-native

Plug into Claude Desktop or Claude Code with two lines of config. Nine tools, no code required.

How it compares

Feature Extremis Mem0 LangChain Raw Pinecone
RL-scored retrieval
Memory explains itself
Knowledge graph
Backend-agnostic✓ 4 backendsCloud onlyManual
MCP server✓ 9 tools
Self-hostable
Migration CLI
Open source (MIT)Partial

Where does your data live?

Local by default. Cloud when you need it. Nothing stored anywhere you didn't choose.

Default

📁 Local SQLite

Everything in ~/.extremis/ on your machine. Zero setup, zero cost, works offline.

# zero config needed
from extremis import Extremis
mem = Extremis()
No local files

🐘 Hosted Postgres

Point at any cloud Postgres. Supabase and Neon both have free tiers with pgvector built in. Works from any machine.

pip3.11 install "extremis[postgres]"

EXTREMIS_STORE=postgres
EXTREMIS_POSTGRES_URL=postgresql://...
No local files

📌 Pinecone

Fully managed serverless vector store. Vectors live in Pinecone cloud. Free starter tier available.

pip3.11 install "extremis[pinecone]"

EXTREMIS_STORE=pinecone
EXTREMIS_PINECONE_API_KEY=pk_...
Zero footprint

☁️ extremis-server on Railway

Deploy the server to Railway. Memory lives in Railway's Postgres — persistent across restarts. Client has zero local footprint.

⚠️ Don't use SQLite on Railway — container filesystems are ephemeral. Always pair with Railway Postgres.

Render auto-provisions Postgres alongside the server via render.yaml. Memory lives in Render's managed Postgres — persistent across restarts.

Deploy to Render → or Railway / Fly.io (manual setup)

Getting your API key: On first startup, extremis prints a key in the server logs. Go to your service → Logs tab → look for extremis — FIRST START. The key starts with extremis_sk_....

from extremis import HostedClient
mem = HostedClient(
  api_key="extremis_sk_...",  # from logs
  base_url="https://your-app.onrender.com"
)
All four options use the same API — remember(), recall(), report_outcome(). Switch backends with one env var. Migrate between any two with extremis-migrate.

MCP setup — 30 seconds

Claude Desktop and Claude Code supported out of the box.

# Requires Python 3.11+  (check: python3.11 --version)

# 1. Install
pip3.11 install "extremis[mcp]"

# 2. Add to Claude Desktop config
# ~/Library/Application Support/Claude/
#   claude_desktop_config.json
{
  "mcpServers": {
    "extremis": {
      "command": "/opt/homebrew/bin/extremis-mcp"
    }
  }
}

# 3. Restart Claude Desktop
  • memory_rememberAppend to log + episodic store
  • memory_recallLayered semantic search with reasons
  • memory_report_outcome+1 / −1 RL signal
  • memory_remember_nowDirect write to any layer
  • memory_consolidateDream pass — log → structured facts
  • memory_kg_writeAdd entity / relationship / attribute
  • memory_kg_queryQuery the knowledge graph
  • memory_observe🔴🟡🟢 priority log compression
  • memory_score_attention0–100 message priority score

Your memory stays yours

No cloud. No tracking. No data leaving your machine unless you explicitly choose it.

🔒

Stored locally by default

All memories, logs, and knowledge graph data are written to ~/.extremis/ on your own machine. No account required. No sign-up. Nothing sent anywhere.

📋

Plain files you own

The conversation log is a JSONL file on your disk. The memory store is a SQLite database. Both are readable with any text editor. You can inspect, export, or delete them at any time.

🤖

When consolidation calls Claude

The optional memory_consolidate tool sends recent conversation log entries to Claude Haiku (via your own Anthropic API key) to extract structured memories. You control this — it only runs when you explicitly call it, and only uses your key, billed to you directly.

🏗️

You choose your backend

Switch to Postgres, Chroma, or Pinecone when you need scale — or keep SQLite forever. If you use an external backend, your data goes there under your own credentials. Extremis itself never sees it.

📡

Zero telemetry

Extremis collects no usage data, sends no analytics, and has no home-call behaviour. It's a library that runs entirely in your process. You can verify this — it's open source.

🖥️

Self-host the server too

Need a REST API for a team? Run extremis-server on your own infrastructure. The hosted server code is open source and ships with a Docker Compose file. We offer a managed cloud option for convenience, not necessity.

In short: your conversations never leave your machine unless you choose to consolidate (→ your Anthropic key) or use an external vector backend (→ your credentials). Extremis has no servers to breach because it doesn't have servers.

Want a hosted version?

No setup, no infrastructure, just an API key.

ashwanijha04@gmail.com