Continue.dev is the leading open-source AI code assistant. Apache 2.0 licensed, 32K+ GitHub stars, 2.4M+ VS Code installs, with JetBrains support as well. Its defining advantage is model flexibility — you pick the provider. Claude, GPT-4, Gemini, local LLMs via Ollama, whatever fits your team or your budget. Chat with Cmd+L, autocomplete with Tab, edit inline, or hand off multi-file tasks to Agent mode. Rich context providers like @File, @Codebase, @Docs, @Web, and @Terminal give the model grounding in your actual project.

But Continue.dev has a gap. Every chat session starts from zero. It doesn't know what you built last week, what patterns your codebase follows, or why you chose one database over another three months ago. You explain the context. You move on. Next session, you explain it again.

That's not a flaw in Continue.dev. It's the underlying architecture. And there's a practical way to extend it.

What Continue.dev resets every time

The context loss is easy to underestimate until it compounds. Here's what disappears at the end of each session:

Project decisions. Why you chose Postgres over MongoDB. Why you ruled out GraphQL for this API. What trade-offs shaped your current service architecture.
Coding conventions. How you structure modules in this project. The error handling patterns your team has standardized. The test organization approach that isn't captured in any linter config.
Debugging history. That two-hour investigation into a race condition in your WebSocket handler. The root cause you eventually found. The fix and why it holds.
Accumulated context. Everything you re-established in the last conversation that you'll need to re-establish again tomorrow.

Developers choose Continue.dev because they want control — over models, over configuration, over their tooling. Many run it across diverse stacks and switch model providers depending on the task. That flexibility makes persistent context even more valuable: the project knowledge should stay consistent regardless of whether today's session uses Claude or GPT-4 or a local model.

Why this is a hard problem to solve alone

Continue.dev is built on large language models. LLMs process a context window and produce output — but they don't write to persistent storage between calls. When the conversation ends, the context window closes and what was in it is gone.

This is a property of how these models work, not something Continue.dev can simply configure away. Every coding agent on the market has the same constraint — GitHub Copilot, Cursor, Claude Code, Kiro, all of them. The reset is universal because the cause is universal.

For a deeper look at why this is architecturally hard to solve, see How AI coding assistants forget everything.

What `.continue/rules/` can do (and what it can't)

Continue.dev gives you a project-level rules system — .continue/rules/*.md files that the model follows during conversations. Rules can be always-on, triggered by file glob patterns, or requested by the agent on demand. This is the right place for stable project conventions: your preferred frameworks, code structure expectations, and style guidelines.

If you haven't created rules for your project, you should. They meaningfully reduce re-explanation for the things that don't change.

But rules are static text. You maintain them manually. They have no concept of time. They can't hold the reasoning behind a decision, or the three things you tried before arriving at the current architecture, or what you were in the middle of debugging last Friday. When the Continue.dev team closed the Memory Bank feature request (Issue #4615) as "Not Planned," they explicitly recommended MCP servers as the path forward for memory. Rules are a good starting point — not a memory system.

Setting up MemNexus with Continue.dev

Model Context Protocol (MCP) is a standard for connecting AI tools to external capabilities. Continue.dev has native MCP support with stdio, SSE, and streamable HTTP transports. MemNexus implements it. For a deeper look at why MCP is the right protocol for giving coding agents persistent memory, see MCP as a Memory Layer: Why Coding Agents Need More Than Context Windows.

When you connect MemNexus to Continue.dev via MCP, the AI gains access to a persistent, searchable memory store that lives outside any single session. It can pull relevant context at the start of a conversation. It can save decisions and findings during a session. And it can search what you already know when you hit a familiar problem.

1. Sign up and install the CLI

Create an account at memnexus.ai and grab your API key from the customer portal.

Then install the CLI:

npm install -g @memnexus-ai/cli

2. Run setup

mx setup

mx setup is an interactive CLI that detects Continue.dev and walks you through connecting it to MemNexus. Here's what it configures:

MCP server connection — writes the MemNexus MCP server entry to Continue.dev's config so it can communicate with your memory store. You'll paste your API key from the customer portal during this step.
Steering rules — adds rules to .continue/rules/ that teach Continue.dev how to use the memory tools effectively: when to search for relevant context, when to save important decisions, and how to format memories for maximum retrievability.
Slash commands — installs commands like /save, /search, and /recall that give you direct control over memory operations from within Continue.dev.
CommitContext — sets up a git hook that automatically captures the reasoning behind every commit into your memory store. When you commit, it reads your agent session, distills the decision trail into a structured memory, and enriches your commit message with the context. For a deeper look, see Every Commit Tells You What Changed. Now Your Agent Knows Why.

Restart Continue.dev after setup. Memory tools are available in Agent mode — note that MCP tools require Agent mode in Continue.dev, not regular Chat.

3. Create your first memory

In Continue.dev Agent mode, tell the agent something worth remembering:

"Save a memory: we chose Postgres over MongoDB for this service because our access patterns are relational, we need ACID transactions for the payment flow, and the ops team already runs Postgres in production."

MemNexus stores it with full semantic indexing — topics, entities, and facts are automatically extracted from the content.

4. Search for it in a new session

Close the conversation. Open a new one. Ask:

"Search my memories for why we chose our database."

Continue.dev queries your MemNexus memory store via MCP and surfaces the decision with its full reasoning — even though this is a completely new session with no prior context.

5. Browse it in the portal

Your memories are also browsable in the MemNexus customer portal. Search, filter by topic, view the knowledge graph that connects your decisions and entities, and watch your project knowledge grow over time.

What actually persists across sessions

Here's what MemNexus stores and surfaces across your Continue.dev sessions:

Coding conventions with context. Not just "we use Express" but how you structure middleware in this project, why you use a specific validation pattern, and the error response format your team settled on. Details that a linter can't capture.

Decisions with their reasoning. "We use TypeScript strict mode" is table stakes. "We enabled strict mode after catching three production bugs from implicit any types in our payment service, and the migration cost was worth it because our team was already writing type annotations" is what a coding agent actually needs to give relevant suggestions.

Debugging history. That investigation into memory leaks in your Node.js service you completed last week — root cause, fix, what you ruled out along the way — becomes a memory. When similar symptoms appear, Continue.dev can surface what you already found.

Growing project knowledge. After a month of active development, your memory store reflects the real shape of the project: the deployment gotchas, the dependency conflicts that took days to resolve, the things that bit you once and shouldn't bite you again. This knowledge persists regardless of which model provider you use on any given day — switch from Claude to GPT-4 to a local model and back, and the memory stays consistent.

The compound effect

The value isn't obvious on day one. It compounds.

After a few weeks, Continue.dev walks into each session with the actual history of your project — not just the rules you defined at the start, but the decisions you made under pressure, the bugs you traced to their root, the patterns that emerged from real use. Re-explanation drops. Discovery time drops. The things you've already figured out stay figured out.

The right tool for each job: Continue.dev's open-source flexibility, model provider choice, rich context providers, and Agent mode are hard to beat. MemNexus adds the one thing Continue.dev can't provide alone — memory that outlasts the session.

Using a different AI coding tool?

The same MCP-based approach works across the coding agent ecosystem:

GitHub Copilot Memory: How to Make Copilot Remember Your Project — persistent context for Copilot Chat
JetBrains AI Memory: How to Make JetBrains AI Remember Your Project — persistent memory for JetBrains AI Assistant
Kiro Memory: How to Make Kiro Remember Your Project — persistent memory for Kiro

If you want Continue.dev to actually remember your project, sign up at memnexus.ai and get started in under five minutes.

For a detailed look at how MemNexus compares to built-in memory features, see our comparison pages.

Continue.dev Memory: How to Make Continue Remember Your Project