Setup Guide

Continue.dev +
MnemeBrain:
persistent developer memory

Continue.dev is the leading open-source AI coding plugin for VS Code and JetBrains. It's fully configurable, model-agnostic, and built for developers who want control. What it doesn't have — like every other AI coding tool — is memory between sessions.

Without MnemeBrain, Continue starts fresh every session. With it, your architecture decisions, patterns, and project conventions persist — and contradictions are caught before they cause bugs.

March 2026 ~5 min setup Continue.dev + MCP + MnemeBrain
continuemcpsetup guidemnemebrain-lite
Continue.dev chat — developer memory across sessions
# Week 1 You: we use React with TypeScript strict mode. No any types, ever. Continue: Stored. "React + TypeScript strict, no any" · confidence 0.95
# Week 4 — new session You: what are our TypeScript rules for this project? Continue: TypeScript strict mode, no any types. Stored in Week 1 (confidence: 0.95).
TL;DR
1pip install mnemebrain-lite then mnemebrain-lite serve
2Clone MCP bridge: git clone https://github.com/mnemebrain/mnemebrain-mcp then uv sync
3Add to ~/.continue/config.json under mcpServers
4Reload VS Code — Continue now has 13 persistent memory tools
Steps in this guide
Developer conventions that survive across VS Code sessions
Week 1
You: We're using Zustand for state management. Redux is explicitly banned — too much boilerplate for this team.

↳ believe() × 2 beliefs
"Zustand for state" (0.95)
"no Redux" (0.95)
Week 4 (fresh VS Code session)
You: How should I handle global state for the new dashboard feature?

↳ search() called
query: "state management"

Continue: Use Zustand (0.95). Redux is explicitly avoided on this project. Stored in Week 1.

Week 4 Continue had zero context from Week 1. The team convention was retrieved from MnemeBrain's persistent belief graph.

01

Why Continue.dev + MnemeBrain

Open source meets open source
🔓
Both projects are open source. Continue.dev is MIT licensed. MnemeBrain Lite is open source on GitHub. No proprietary lock-in, no cloud dependency, no usage telemetry.

Continue.dev's MCP support makes this integration clean: register MnemeBrain as an MCP server in ~/.continue/config.json, and Continue gains 13 new memory tools it can call mid-chat. The plugin architecture means adding memory doesn't change how you use Continue — it just makes it better.

Continue works with any LLM — OpenAI, Anthropic, local Ollama models, even your own hosted endpoints. MnemeBrain works alongside all of them: the belief graph is model-agnostic. Switch your LLM tomorrow and your project memory stays intact.

02

Install the backend

Local, no cloud dependencies
terminal
pip install mnemebrain-lite
mnemebrain-lite serve
# → MnemeBrain running at http://localhost:8000

Keep this terminal open while using Continue. For automatic startup, add to your shell profile:

~/.zshrc
mnemebrain-lite serve &> /tmp/mnemebrain.log &
03

Clone the MCP bridge

The subprocess Continue spawns on startup
terminal
git clone https://github.com/mnemebrain/mnemebrain-mcp
cd mnemebrain-mcp
uv sync
pwd   # note this path
No uv? Install with pip install uv. It's a fast Python package runner required by the MCP bridge.
04

Configure Continue.dev

One block in config.json

Open ~/.continue/config.json and add the mcpServers block:

~/.continue/config.json
{
  "models": [ ... ],
  "mcpServers": [
    {
      "name": "mnemebrain",
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/mnemebrain-mcp",
        "run",
        "mnemebrain-mcp"
      ],
      "env": {
        "MNEMEBRAIN_URL": "http://localhost:8000"
      }
    }
  ]
}

Replace /path/to/mnemebrain-mcp with the path from the pwd command above. Save and reload VS Code.

JetBrains users: The Continue JetBrains plugin uses the same ~/.continue/config.json. The MCP configuration is identical — no separate setup needed for IntelliJ, PyCharm, or WebStorm.
Team sharing: Add a .continue/config.json to your project root (MCP entry only, without personal LLM keys) and commit it. Team members get shared project memory configuration automatically.
05

Use persistent memory in Continue

The patterns developers use most

Store a code style convention:

Continue chat
Remember: all React components use functional style with hooks.
No class components. Prefer composition over inheritance throughout.

Store a dependency decision:

Continue chat
We use React Query for all data fetching. Never fetch directly
in components — always go through a custom hook that wraps React Query.

Ask what Continue remembers about the project:

Continue chat
What conventions do we follow for data fetching?

Contradiction detected when patterns change:

ATTACKS edge — data fetching pattern revised
Week 1: "use React Query for all data fetching"
Week 6: "we've switched to SWR for the new dashboard"

truth_state: BOTH ← coexisting beliefs, conflict surfaced
belief_1: "React Query" confidence: 0.95 → 0.33
belief_2: "SWR (dashboard)" confidence: 0.89

Continue: ⚡ Data fetching conflict. React Query stored Week 1, SWR now mentioned. Is this a full migration or scoped to the dashboard only?

Most retrieval-based memory systems cannot represent contradictions explicitly — they silently overwrite the old fact. MnemeBrain creates an ATTACKS edge, flags truth_state: BOTH, and lets Continue surface the conflict before giving you advice based on stale data.

What you've built

Continue.dev now has a persistent belief graph that survives across every VS Code session. Code style, library choices, architectural patterns, and team conventions are stored, tracked for contradictions, and retrieved semantically — using whichever LLM you already have configured in Continue.

The belief graph is model-agnostic: switch between GPT-4, Claude, or a local Ollama model without losing any stored beliefs. Typical belief lookup is <5ms on a local Kuzu store with ~100k beliefs.

GitHub: mnemebrain-lite →   PyPI →   BMB Leaderboard →