⚠️ In Development — remem is evolving rapidly. Not yet recommended for mission-critical production workloads.

remem provides agents with persistent, reasoned memory that spans across sessions. It enhances AI assistants and agents with an intelligent memory layer that enables truly personalized AI interactions — it remembers user preferences, adapts to individual needs, and continuously learns over time, turning stateless AI tools into persistent, context-aware partners.

Unlike traditional vector stores that rely solely on semantic similarity, remem incorporates an LLM reasoning layer to distinguish between what is semantically close and what is actually useful for solving problems. Whether you're using Claude Code, Codex, Cursor, Copilot, Antigravity CLI, or OpenCode, remem gives your AI a durable, cross-session memory that grows smarter with every interaction.

Architecture

┌──────────────────────────────────────────────────────────────────────┐
│                        Agent Consumers                               │
│  Claude Code · Codex · Cursor · Copilot · Antigravity CLI · OpenCode │
│  Python agents · TypeScript agents · Any MCP-compatible client       │
└──────────┬──────────────────────┬────────────────────────────────────┘
           │ MCP stdio            │ REST API / SDK
┌──────────▼──────────────────────▼────────────────────────────────────┐
│                    Interface Layer (Rust)                            │
│       rememhq-mcp (stdio) · rememhq-api (Axum REST)                  │
│       Python SDK (httpx)  · TypeScript SDK (fetch)                   │
└────────────────────────────┬─────────────────────────────────────────┘
                             │
┌────────────────────────────▼─────────────────────────────────────────┐
│                Reasoning Engine (rememhq-core)                       │
│    Consolidation · Guided Retrieval · Contradiction Detection        │
│    Importance Scoring · Knowledge Graph · Preference Learning        │
└──────────┬─────────────────────────────┬──────────────────────────── ┘
           │                             │
┌──────────▼──────────┐       ┌──────────▼────────────────────────────┐
│ LLM Providers       │       │  Storage Layer                        │
│ OpenAI · Anthropic  │       │  SQLite + WAL (metadata)              │
│ Gemini · Local ONNX │       │  Vector Index (HNSW via libremem)     │
└─────────────────────┘       └───────────────────────────────────────┘

Supported Agent Consumers

remem integrates with the leading AI coding assistants and agent frameworks. Each consumer connects through either the MCP stdio protocol or the REST API / SDK, giving your AI tools a shared, persistent memory across sessions.

Why remem?

• Remembers preferences: Coding style, tool choices, architecture decisions — stored once, recalled every time.
• Adapts to you: The more you interact, the better remem understands your project context and working patterns.
• Learns continuously: Session consolidation extracts durable knowledge from every interaction, building an ever-growing understanding of your codebase and workflows.
• Reasons about relevance: Unlike naive vector search, remem uses LLM reasoning to return what is actually useful, not just what is semantically nearest.

Traditional vector stores suffer from "confident recall of irrelevant context." remem bridges this gap with reasoning-powered retrieval that understands context, importance, and domain-specific relevance.

Quickstart

Model Context Protocol (MCP) — Claude Code / Codex / Cursor / Copilot / Antigravity CLI / OpenCode

See our Quickstart Guide for more details, or explore our examples like examples/multi_agent.py and examples/rag_example.py.

remem works seamlessly with any MCP-compliant AI assistant. Add the following to your tool's MCP configuration:

{
  "mcpServers": {
    "remem": {
      "command": "rememhq",
      "args": ["mcp", "--project", "my-project"]
    }
  }
}

Python SDK

pip install rememhq

from rememhq import Memory

m = Memory(project="my-agent", reasoning_model="claude-sonnet-4-8")

# Store a durable preference
await m.store("The production database is PostgreSQL 15 on RDS", tags=["infra"])

# Recall with reasoning
results = await m.recall("what database are we using?")
for r in results:
    print(f"Content: {r.content}")
    print(f"Reasoning: {r.reasoning}")

TypeScript SDK

npm install @rememhq/sdk

import { Memory } from "@rememhq/sdk";

const m = new Memory({ project: "my-agent", reasoningModel: "gpt-5.5" });
await m.store("This repository uses trunk-based development", { tags: ["workflow"] });

const results = await m.recall("how do we manage branches?");

Usage Commands

Local Development (Building from Source)

# Build the entire workspace
cargo build --workspace

# Run all tests
cargo test --workspace

# Check formatting
cargo fmt --all -- --check

# Format code
cargo fmt

# Lint (clippy) — must pass with no warnings
cargo clippy --workspace --all-targets -- -D warnings

Running the pre-built binaries (Downloaded Releases)

If you downloaded the pre-built binary releases from GitHub, you can use the remem executable directly.
Here are some of the basic commands:

# Start the REST API server
remem serve --project my-project

# Start the MCP server (stdio transport)
remem mcp --project my-project

# Store a memory
remem store "The main branch is called 'main'"

# Recall memories with guided retrieval
remem recall "What is the main branch called?"

# Search memories (no LLM re-ranking)
remem search "main branch"

# Show database statistics
remem inspect

# Apply importance-weighted decay to all active memories
remem decay

# Start an interactive REPL mode
remem repl

# Start the Remem AI terminal agent (uses native tool calling to run shell commands)
# Ensure REMEM_PROVIDER is set to anthropic, openai, gemini, or local
remem agent

# List downloaded local models
remem models list

# Pull a local model for offline use
remem models pull nomic-embed-text

# Bulk import memories from a JSONL file
remem import data.jsonl

# Export all memories to a JSONL file
remem export backup.jsonl

# Initialize MCP configurations for all supported agents in your workspace
remem init all --project my-project

# Initialize MCP config for a specific agent (e.g. claude-code, windsurf, roocode)
remem init claude-code --project my-project

Running Services from Source

If you are developing locally, you can run the components via cargo:

# Start the API server (REST interface)
cargo run -p rememhq-api -- --project default

# Start the MCP server (stdio interface for Claude Code, Cursor, etc.)
cargo run -p rememhq-mcp

# Run the CLI tool
cargo run -p rememhq-cli -- --help

# Run the Remen AI terminal agent
cargo run -p rememhq-cli -- agent

SDKs

# Python SDK
cd sdk/python && pip install -e ".[dev]" && pytest tests/

# TypeScript SDK
cd sdk/typescript && npm install && npm run build

Contributing

We welcome contributions! Whether you're fixing a bug, improving the reasoning prompts, or adding a new provider, please check out our CONTRIBUTING.md.

1. Clone the repo: git clone https://github.com/remem-io/remem
2. Build: cargo build
3. Test: cargo test --workspace

License

remem is licensed under the Apache License 2.0. See LICENSE for details.