🧠 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 Get hosted version → 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]"

Change one import. Every conversation is remembered automatically.

# Claude
from extremis.wrap import Anthropic  # drop-in for anthropic.Anthropic
from extremis import Extremis

client = Anthropic(api_key="sk-ant-...", memory=Extremis())

# Your existing code — unchanged
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": user_message}]
)
# ↑ extremis recalled context, injected it, saved the reply
#   nothing else needed
# OpenAI
from extremis.wrap import OpenAI

client = OpenAI(api_key="sk-...", memory=Extremis())
response = client.chat.completions.create(model="gpt-4o", messages=[...])

Install: pip3.11 install "extremis[wrap-anthropic]"  ·  pip3.11 install "extremis[wrap-openai]"

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 Render

One click deploys the server and provisions a free Postgres database automatically. Memory persists across restarts. Client has zero local footprint.

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.
Leave your email — we'll reach out when it's ready.

No spam. Just a ping when it launches.