How to Give Cursor Persistent Memory Across Projects

You open Cursor on Monday morning, start a new session, and immediately spend the first five minutes re-explaining things the agent already knew on Friday. Your project uses Zustand, not Redux. API errors follow a specific envelope pattern. The test suite needs a particular setup command. None of this is novel information — you've said it all before, maybe dozens of times — but the agent starts from zero every session.

This is the core limitation of working with any AI coding assistant: context resets between sessions and vanishes entirely between projects. Cursor is powerful, but out of the box it has no persistent memory. Every conversation is an island.

There's a fix. It takes about two minutes to set up, and it uses an open standard called MCP to give your Cursor agent memory that persists across sessions, across projects, and across machines.

The problem: Cursor forgets everything

Cursor's context window is powerful but ephemeral. When a session ends, everything the agent learned during that session disappears. Start a new chat or switch to a different project and you're back to square one.

In practice this means:

• You repeat your codebase conventions in every session. “We use path aliases. We put API routes in src/server/. Tests go next to the files they test.”
• Architectural decisions made in one conversation are invisible to the next. You spent 30 minutes working through the tradeoffs of a particular database schema — and the next session has no idea that discussion happened.
• Cross-project knowledge doesn't transfer. Your preferences for error handling, your preferred libraries, your opinions on TypeScript strictness — all of it has to be restated per project.

Cursor rules and .cursorrulesfiles help with static conventions, but they don't capture the dynamic knowledge that accumulates over weeks of working with an agent: the decisions you've made, the things you've tried and rejected, the context that makes your agent actually useful instead of generically helpful.

What MCP is (and why it matters here)

MCP stands for Model Context Protocol. It's an open standard created by Anthropic that lets AI tools connect to external services through a simple, standardized interface. Think of it as a plugin system for AI agents: the agent gets access to tools (functions it can call), and those tools can do anything — read files, query databases, call APIs, or in our case, store and retrieve memories.

Cursor has built-in MCP support. You add a server configuration, restart, and suddenly your agent has new capabilities. No extension to install, no plugin marketplace to navigate. It's a JSON config block and a restart.

Engram is an MCP memory server. It gives your Cursor agent two core capabilities: storing conversations and searching them later by meaning. When your agent has a conversation worth remembering, it writes the messages to Engram. When it needs to recall something, it searches Engram using natural language and gets back the relevant past conversations — verbatim, not summarized.

Setting up Engram in Cursor

The setup is four steps. Total time: about two minutes.

1. Get your API key. Sign up at getengram.app and copy your API key from the dashboard. The free tier gives you 1,000 messages per month, which is enough to get a feel for how memory changes your workflow.

2. Open Cursor Settings. Go to Cursor Settings > MCP. This is where Cursor manages its MCP server connections.

3. Add the Engram server config. Add a new global MCP server with the following configuration:

{
  "mcpServers": {
    "engram": {
      "command": "npx",
      "args": ["-y", "engram-mcp"],
      "env": {
        "ENGRAM_API_KEY": "your-api-key-here"
      }
    }
  }
}

Replace your-api-key-here with the API key you copied in step 1.

4. Restart Cursor.After adding the config, restart Cursor. You should see the Engram tools appear in your agent's available tool list. That's it — your agent now has persistent memory.

For the full walkthrough with screenshots, see the Cursor setup guide in our docs.

What changes once memory is connected

The difference is not dramatic in a single session. It's dramatic over a week. Your Cursor agent can now:

• Recall decisions from past sessions. You discussed a database migration strategy three days ago. Instead of re-deriving it from scratch, the agent searches its memory, finds the conversation, and picks up where you left off.
• Know your preferences without being told. You prefer named exports over default exports. You like your error messages to include the operation that failed. You always want TypeScript strict mode. These preferences, once expressed in any conversation, become retrievable in every future session.
• Transfer context between projects.The API error handling pattern you worked out in your backend project is available when you're working in your frontend project. Memory is not scoped to a single repo — it's scoped to you.
• Build on previous work instead of restarting. When you say “continue with the approach we discussed yesterday,” the agent actually can.

Real scenarios where this pays off

Here are concrete examples from how people actually use Engram with Cursor:

“Remember we decided to use Zustand instead of Redux last week.”You had a long conversation comparing state management options, weighing bundle size, API ergonomics, and your team's familiarity. The agent searches Engram, finds that exact conversation, and not only remembers the decision but remembers why— including the specific concerns about Redux Toolkit's boilerplate that tipped the scale.

“What was our API pattern for error handling?” Two weeks ago, you and the agent worked out an error envelope pattern for your REST API: { ok: boolean, data?: T, error?: { code: string, message: string } }. The agent retrieves that discussion and applies the same pattern to the new endpoint you're building today.

“We tried server components for this page but hit hydration issues — use the client component approach.” The agent finds the conversation where you debugged the hydration mismatch, sees what went wrong, and avoids making the same suggestion again. This is the kind of knowledge that .cursorrulescan't capture because it's not a static rule — it's a learned lesson from a specific context.

Switching between projects. You maintain a frontend app and a shared component library. In the library project, you decided on a specific prop naming convention. When you switch to the frontend project and ask the agent to consume one of those components, it remembers the convention without you needing to say anything.

How it works under the hood

Engram exposes a small set of MCP tools to your Cursor agent. The two that matter most:

search takes a natural language query and returns the most relevant past conversation messages. Under the hood, Engram embeds your query into a vector, performs a semantic similarity search against all your stored messages, and returns the closest matches — verbatim, not summarized. The agent gets back the actual words from your past conversations, preserving nuance and context that summaries would lose.

append_messages stores new messages in a conversation. When the agent has a discussion worth preserving — an architectural decision, a debugging session, a preference expressed — it writes the messages to Engram for future retrieval.

The search is semantic, not keyword-based. Searching for “state management decision” will find a conversation about “choosing between Zustand and Redux” even though there's no keyword overlap. This is what makes the memory actually useful — you don't need to remember the exact words you used; you describe what you're looking for and the relevant context surfaces.

Storage is verbatim by design. Other memory tools extract facts or build knowledge graphs, which sounds efficient until you need the original reasoning six weeks later. Engram keeps the full conversation so that when the agent retrieves a past decision, it gets the complete context: not just “we chose Zustand” but the entire discussion about why, including the tradeoffs considered and the alternatives rejected.

Getting started

Engram's free tier includes 1,000 messages per month — enough for a few weeks of active use to see how persistent memory changes your development workflow. No credit card required.

1. Sign up at getengram.app
2. Add the MCP config to Cursor (see above or the full Cursor setup guide)
3. Restart Cursor and start working

Your agent will start building memory from your very first conversation. Within a few sessions, you'll stop re-explaining things. Within a week, you'll wonder how you worked without it.

Written by the Engram team. Published June 10, 2026. Questions or feedback: hello@getengram.app.