Skip to content
Cobalt Rentals

MCP Registry

Basic Memory

Your AI never forgets again.

Pick up right where you left off — in Claude, Codex, Cursor, ChatGPT, or
anything that speaks MCP. Your knowledge
lives as Markdown files that both you and your AI can read, write, and
search.

  • Local-first. Plain text on your disk. Forever.
  • Two-way. AI and humans write to the same files; sync keeps them in step.
  • A real knowledge graph. Observations and wikilinks compound into context.
  • Semantic search. Find notes by meaning, not just keywords, with optional
    cross-encoder reranking for higher-quality vector and hybrid results.
  • MCP-native. Works with every major AI client and IDE.
  • Progressive tool discovery. Every tool is tagged with behavior hints
    (read-only, destructive, idempotent) so agents pick the right tool on
    demand — no wasted context trying things to see what they do.
  • Cloud, optional. Sync across devices when you want — never required.

Get started

Pick the path that fits you. Both run the same product on the same Markdown.

  • 💻 Local install
    • 30 seconds. Sign up, connect your AI client, done.Works in any browserMobile, web, desktopCross-device sync built inWe handle hosting, backups, snapshots$15.00/mo locked for life · 7-day free trial · cancel any timeStart free trial →: 2 minutes. Install, configure your AI client, run.Free forever (AGPL-3.0)All data on your diskAir-gapped friendlyRequires Python via uvuv tool install basic-memory --prerelease=allow--prerelease=allow is required: Basic Memory 0.23 depends on a FastMCP 4 pre-release, and uv only accepts pre-releases of transitive dependencies when told to — without the flag it silently installs an older release. The same flag goes on every uvx / uv tool upgrade command below.For Postgres deployments that store semantic vectors in Milvus, install the first-party optional extra instead:uv tool install "basic-memory[milvus]" --prerelease=allowConfigure your client ↓

    What people are saying

    Basic Memory changed my whole relationship with LLMs. I switched from GPT
    and Gemini to exclusively Claude and Claude Code because of this
    integration and am completely revamping all our company's processes around
    a Basic Memory workflow.

    — Alex, TrainerDay

    Basic Memory is the missing 'wow' factor in AI chatbots. Now I can't
    imagine Claude or Claude Code without it.

    — Caleb, Caleb Picker Consulting

    I don't code without Basic Memory anymore. It's such a time saver to be
    able to refer to projects I don't currently have active and keep a running
    log of all my learnings and ProTips.

    — @groksrc, Developer

    Basic Memory Cloud

    The hosted version of Basic Memory. Same product, same Markdown files, same
    MCP tools — we just host the database, run the sync, and put it on your
    phone.

    What you get

    • Every device, same brain. Your knowledge graph on web, mobile, and
      desktop. No copy-paste between machines.
    • Connect any MCP client. Claude Desktop, Claude Code, Codex, Cursor,
      ChatGPT (Custom GPTs), VS Code — one-click connect from the web app.
    • Bidirectional sync to local. Edit on your phone, see it in Obsidian on
      your laptop. rclone-powered with conflict resolution.
    • Snapshots and backups. Point-in-time restore. Browse history. Never
      lose a note.
    • No lock-in. Your notes are plain Markdown. Export to local Markdown any
      time — same files, same format, same wikilinks. Cancel anytime, your data
      stays yours.

    Built on WorkOS AuthKit, Neon Postgres, and Tigris S3.

    Pricing

    $15.00/mo, locked in for the life of your subscription (regular price
    $19). Sign up during beta and the rate never goes up — as long as you stay
    subscribed, you keep the price. One plan, no tiers, no surprise upgrades.
    Unlimited notes, unlimited projects, every feature.

    • 7-day free trial. Cancel any time before day 7 if it's not for you.
    • Cancel anytime after that too — export your notes whenever you want.
    • OSS users: code BMFOSS for another 20% off for 3 months (~$11.40/mo).

    Start your 7-day free trial →

    Cloud vs. local

    • Cloud
      • Setup time: 30 seconds
      • Cost: $15.00/mo, locked for life (7-day trial)
      • Storage: We host (Tigris S3)
      • Cross-device sync: Built in
      • Mobile access: Yes (web + app)
      • Air-gapped: No
      • Your data stays yours: Yes — export anytime
      • Source code: AGPL-3.0
      • Snapshots & backups: Built in
      • Setup time: 2 minutes (requires Python)
      • Cost: Free
      • Storage: Your disk
      • Cross-device sync: Manual (Git, Syncthing, etc.)
      • Mobile access: No
      • Air-gapped: Yes
      • Your data stays yours: Yes — already there
      • Source code: AGPL-3.0
      • Snapshots & backups: Roll your own

      Both paths use the same OSS engine and the same Markdown files. There's no
      lock-in either way — flip between them when your needs change.

      Works with the tools you already use

      • Transport
        • Cloud web app: Sign in at basicmemory.com — no install
        • Claude Desktop: macOS / Windows / Linux
        • Claude Code: claude mcp add
        • Codex: OpenAI's coding agent
        • Cursor: .cursor/mcp.json
        • VS Code: Native MCP support
        • ChatGPT: Custom GPT actions (search / fetch)
        • Obsidian: Reads/writes the same Markdown directly
        • Anything MCP: If it speaks MCP, it works

        Official agent packages

        This repository is also the canonical home for Basic Memory's host-native
        agent packages. The core Python package, Claude Code plugin, shared skills,
        Hermes plugin, and OpenClaw plugin all ship from the same source tree.

        Maintainers can verify the whole consolidated surface from the repo root:

        just package-check

        Package-local justfiles are also available when working inside one host:

        just package-check-claude-code just package-check-skills just package-check-hermes just package-check-openclaw

        Claude Code plugin

        The Claude Code plugin is the bridge between Claude's working memory and Basic
        Memory — session-start briefings, pre-compaction checkpoints, an opt-in capture
        output style, and /basic-memory:bm-setup · :remember · :share · :status.

        Connect the Basic Memory MCP server first — see Connect your AI
        client        . The plugin's hooks and skills call it, so it's a
        hard prerequisite. Then install the plugin:

        bm install claude-code

        That registers the marketplace and installs the plugin through Claude Code. Add
        --scope project to declare both in the repository's settings for a team, or
        --dry-run to see the underlying claude plugin commands without running them.

        Source: plugins/claude-code.

        Shared skills

        Framework-agnostic SKILL.md files live in skills/. If your
        Skills CLI supports repository subdirectory sources:

        npx skills add basicmachines-co/basic-memory/skills -g

        For Claude and ChatGPT, upload basic-memory.zip or basic-memory-chatgpt.zip
        from the skills-latest
        release; see skills/README.md.

        If your installed Skills CLI cannot load that source, update the CLI or copy
        the memory-* directories from skills/ into your agent's skills directory.

        Hermes

        Hermes keeps its native plugin shape under integrations/hermes:

        hermes plugins install basicmachines-co/basic-memory/integrations/hermes

        Hermes does not install a plugin's Python dependencies, so also add the mcp
        package to the Hermes venv — see the plugin README
        for that step and the supported Hermes releases.

        OpenClaw

        OpenClaw stays package-native and publishes from
        integrations/openclaw:

        openclaw plugins install @basicmemory/openclaw-basic-memory

        Pick up where you left off

        https://github.com/user-attachments/assets/a55d8238-8dd0-454a-be4c-8860dbbd0ddc

        Connect your AI client

        If you went the Cloud route, the web app walks you through
        client connect. The snippets below are for local installs.

        Claude Desktop

        Edit ~/Library/Application Support/Claude/claude_desktop_config.json:

        { "mcpServers": { "basic-memory": { "command": "uvx", "args": ["--prerelease=allow", "basic-memory", "mcp"] } } }

        Restart Claude Desktop. Notes live in ~/basic-memory by default.

        Claude Code, Codex CLI, Cursor, VS Code, ChatGPT, Obsidian

        Claude Code

        claude mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp

        For the full memory bridge — session briefings, pre-compaction checkpoints, and
        the /basic-memory:* commands — also install the Claude Code
        plugin         on top of this.

        Codex CLI

        Add to ~/.codex/config.toml:

        [mcp_servers.basic-memory] command = "uvx" args = ["--prerelease=allow", "basic-memory", "mcp"]

        Codex can keep its default MCP approval behavior, or you can pre-approve eligible
        Basic Memory tools by adding this server-scoped setting to the same table:

        [mcp_servers.basic-memory] command = "uvx" args = ["--prerelease=allow", "basic-memory", "mcp"] default_tools_approval_mode = "approve"

        This does not disable Codex approvals globally or expand which Basic Memory
        projects the server can access. Codex still requires approval for tools that
        advertise a destructive annotation, including Basic Memory's writes, edits, and
        deletes. If you installed the Basic Memory Codex plugin, use its
        plugin-scoped configuration instead.

        Cursor

        Add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):

        { "mcpServers": { "basic-memory": { "command": "uvx", "args": ["--prerelease=allow", "basic-memory", "mcp"] } } }

        VS Code

        Add to your User Settings (JSON):

        { "mcp": { "servers": { "basic-memory": { "command": "uvx", "args": ["--prerelease=allow", "basic-memory", "mcp"] } } } }

        ChatGPT

        Basic Memory exposes OpenAI-compatible search and fetch tools for Custom
        GPT actions. See the ChatGPT integration
        guide        .

        Obsidian

        No setup. Point Obsidian at ~/basic-memory (or your project folder) and the
        same wikilinks, frontmatter, and Markdown your AI writes appear in your graph
        view. Edit either side — sync handles the rest.

        Try a prompt:

        "Create a note about our project architecture decisions." "Find information about JWT auth in my notes." "What have I been working on this week?"

        What's New

        • Automatic updates. Basic Memory keeps itself up to date for uv tool
          and Homebrew installs; bm update triggers a manual check.
        • Semantic vector search. Find notes by meaning, not just keywords.
          Hybrid full-text + vector ranking with FastEmbed embeddings, on SQLite or
          Postgres.
        • Optional search reranking. Rescore the strongest vector and hybrid
          candidates with a local FastEmbed cross-encoder or a LiteLLM-backed provider.
        • Schema system. Infer, validate, and diff the structure of your
          knowledge base with bm_schema(command="infer"), bm_schema(command="validate"), and
          bm_schema(command="diff").
        • Per-project cloud routing. Route individual projects through the cloud
          while others stay local, via API key (bm project set-cloud).
        • Explicit note changes. bm_edit updates existing notes; bm_write
          creates notes and guards against accidental overwrites.
        • Richer search results. Matched chunk text is included so the LLM gets
          context, not just hits.
        • FastMCP 3.0 + tool annotations. Every tool ships with MCP behavior
          hints (readOnlyHint, destructiveHint, idempotentHint,
          openWorldHint) so agents can discover capabilities progressively at
          runtime instead of guessing or burning tokens.
        • CLI overhaul. --json output for scripting, workspace-aware commands,
          and an htop-inspired project dashboard.

        Full CHANGELOG for v0.18 → v0.20.

        Optional cross-encoder reranking

        Reranking adds a second relevance pass after vector or hybrid retrieval. It is
        disabled by default because it adds inference latency and, for the local
        provider, a first-run model download. Text, title, and permalink searches keep
        their existing ranking.

        Enable the default local FastEmbed reranker:

        export BASIC_MEMORY_RERANKER_ENABLED=true

        The default model is jinaai/jina-reranker-v1-tiny-en. To use a hosted
        reranker through LiteLLM instead, first install the optional LiteLLM
        SDK        , then configure it:

        export BASIC_MEMORY_RERANKER_ENABLED=true export BASIC_MEMORY_RERANKER_PROVIDER=litellm export BASIC_MEMORY_RERANKER_MODEL=cohere/rerank-v3.5 export COHERE_API_KEY=...

        The feature fails fast on invalid configuration and does not silently fall
        back to retrieval order when an enabled provider fails. See the
        semantic search guide for
        provider setup, all settings, tuning, pagination, and failure behavior.

        Why Basic Memory

        Most LLM conversations are ephemeral. You ask a question, get an answer, then
        everything is forgotten. Workarounds have limits:

        • Chat history captures conversations but isn't structured knowledge.
        • RAG lets the LLM query your documents but not write back to them.
        • Vector DBs need complex infra and usually live in someone else's cloud.
        • Knowledge graphs need specialized tooling to maintain.

        Basic Memory takes a simpler path: structured Markdown files that humans
        and LLMs both read and write.

        • All knowledge stays in plain files you control.
        • Both sides read and write to the same files.
        • Familiar Markdown with semantic patterns — no new format to learn.
        • A traversable graph the LLM can follow link by link.
        • Works with the editors you already use (Obsidian, VS Code, anything).
        • Just files plus a local SQLite index. No servers required.

        How it works

        You're chatting normally about coffee:

        I've been experimenting with brewing methods. Pour over gives more clarity
        than French press, water at 205°F seems best, and freshly ground beans
        make a huge difference.

        Ask the LLM to capture it:

        "Make a note on coffee brewing methods."

        A Markdown file appears in your project directory in real time:

        --- title: Coffee Brewing Methods permalink: coffee-brewing-methods tags: [coffee, brewing] ---

        # Coffee Brewing Methods

        ## Observations - [method] Pour over highlights subtle flavors over body - [technique] Water at 205°F (96°C) extracts optimal compounds - [principle] Freshly ground beans preserve aromatics

        ## Relations - relates_to [[Coffee Bean Origins]] - requires [[Proper Grinding Technique]] - affects [[Flavor Extraction]]

        Next session, the LLM picks up the thread. It follows the relations to
        surface what you already know about Ethiopian beans and burr grinders, and
        builds on it instead of starting over. You see the same files in Obsidian or
        your editor. Edit them by hand — the AI sees your changes too.

        Real two-way flow: humans edit Markdown, LLMs read/write through MCP, sync
        keeps everything consistent, and the source of truth is always your files.