MenteDB Documentation

from mentedb import MenteDB

db = MenteDB("./my-agent-memory")

# Store memories with types
db.store("User prefers Python for backend work", memory_type="semantic", tags=["preference", "language"])
db.store("Sprint planning meeting scheduled Friday", memory_type="episodic", tags=["meeting"])

# Search by text (uses hash embedding)
results = db.search_text("programming language preference", k=5)

# Create relationships
mem1 = db.store("User prefers PostgreSQL", memory_type="semantic")
mem2 = db.store("User switched to SQLite", memory_type="semantic")
db.relate(mem2, mem1, "supersedes", weight=1.0)

# Retrieve a specific memory
memory = db.get_memory(mem1)

# Delete a memory
db.forget(mem1)

use mentedb::MenteDb;

let mut db = MenteDb::open("./data")?;

// Store a memory node
let id = db.store(memory_node)?;

// Search by similarity
let results = db.recall_similar(&embedding, k)?;

// Retrieve by ID
let node = db.get_memory(id)?;

// Delete a memory
db.forget(id)?;

// Create a relationship
db.relate(edge)?;

import { MenteDB } from "@mentedb/sdk";

const db = new MenteDB("./my-agent-memory");

// Store a memory
const id = await db.store("User prefers TypeScript", {
  memoryType: "semantic",
  tags: ["preference", "language"],
});

// Search by text
const results = await db.searchText("language preference", { k: 5 });

// Create a relationship
await db.relate(newId, oldId, "supersedes");

// Retrieve a memory
const memory = await db.getMemory(id);

// Delete a memory
await db.forget(id);

RECALL memories WHERE tag = preference LIMIT 5

RECALL memories WHERE content ~> "database" LIMIT 10

RECALL memories NEAR [0.1, 0.2, ...] LIMIT 10

cargo install mentedb-mcp

# GitHub Copilot CLI
mentedb-mcp setup copilot

# Claude Desktop
mentedb-mcp setup claude

# Cursor
mentedb-mcp setup cursor

mentedb-mcp --data-dir ./agent-memory

{
  "mcpServers": {
    "mentedb": {
      "command": "mentedb-mcp",
      "args": ["--data-dir", "~/.mentedb", "--llm-provider", "anthropic"],
      "env": {
        "MENTEDB_LLM_API_KEY": "sk-ant-..."
      }
    }
  }
}

{
  "mcpServers": {
    "mentedb": {
      "command": "mentedb-mcp",
      "args": ["--data-dir", "~/.mentedb", "--llm-provider", "anthropic"],
      "env": {
        "MENTEDB_LLM_API_KEY": "sk-ant-..."
      }
    }
  }
}

{
  "mcpServers": {
    "mentedb": {
      "command": "mentedb-mcp",
      "args": ["--data-dir", "~/.mentedb", "--llm-provider", "anthropic"],
      "env": {
        "MENTEDB_LLM_API_KEY": "sk-ant-..."
      }
    }
  }
}

{
  "mcpServers": {
    "mentedb": {
      "command": "mentedb-mcp",
      "args": ["--data-dir", "~/.mentedb"],
      "alwaysAllow": [
        "store_memory", "get_memory", "recall_memory", "search_memories",
        "relate_memories", "forget_memory", "forget_all", "ingest_conversation",
        "assemble_context", "get_related", "find_path", "get_subgraph",
        "find_contradictions", "propagate_belief", "consolidate_memories",
        "apply_decay", "compress_memory", "evaluate_archival", "extract_facts",
        "gdpr_forget", "process_turn", "record_pain", "detect_phantoms",
        "resolve_phantom", "record_trajectory", "predict_topics",
        "detect_interference", "check_stream", "write_inference",
        "register_entity", "get_cognitive_state", "get_stats"
      ]
    }
  }
}

# Memory

You have persistent memory via MenteDB. Use it automatically, never wait to be asked.

## Every turn (MANDATORY)

Call `process_turn` on EVERY conversation turn. This is the core memory loop:
- Pass the user's message and your response
- Increment `turn_id` each turn (start at 0)
- It automatically: searches relevant context, stores the conversation as searchable
  episodic memory, runs pain/contradiction checks, and returns context + warnings

On the FIRST turn, also call `get_cognitive_state` to check for active pain signals
or knowledge gaps.

## Store important facts yourself (MANDATORY)

YOU are the extraction engine. When you notice important information in the
conversation, call `store_memory` immediately:
- Preferences: "User prefers Rust for backends" → type: semantic, tags: [preference]
- Decisions: "Using PostgreSQL for the database" → type: semantic, tags: [decision]
- Corrections: "Actually the deadline is April" → type: correction
- Procedures: "Deploy with: cargo build --release" → type: procedural
- Mistakes: "Never retag releases" → type: anti_pattern

Don't store noise or chitchat. Store facts, preferences, decisions, and corrections.

## When to use other tools

- `search_memories`: Look up something specific outside of process_turn
- `record_pain`: When something goes wrong (bad advice, failed approach)
- `relate_memories`: When a fact changes, store new and relate with `supersedes`
- `forget_memory`: When the user says "forget" or "don't remember"

## Memory types

- semantic: facts, decisions, preferences, project details (most common)
- episodic: events, meetings, what happened (process_turn handles this)
- procedural: how to do things, workflows, commands
- correction: when the user corrects you
- anti_pattern: mistakes to avoid

## Tags

Always add tags. Use lowercase, descriptive tags like:
- Project names: project-mentedb, project-trading-bot
- Topics: database, deployment, testing, preference
- Context: decision, architecture, bug-fix