Cursor forgets every Composer session. Fix that with one file.

Cursor's Agent is superb inside a session and amnesiac between them. Rules files hold static instructions, but nothing accumulates: the architecture decision you explained on Tuesday is gone by Thursday. Kognite connects over MCP and gives the Agent a durable memory it can search and extend — across sessions, projects, and every other MCP tool you use.

Rules files aren't memory

.cursor/rules is the right place for “always use our error helper” — standing instructions you author once. It is the wrong place for knowledge that accretes: which approaches you rejected and why, how your team names things, what the client asked for last month. That content changes daily and nobody is going to hand-edit a rules file to keep up.

With a memory server attached, the Agent writes those facts as they happen and retrieves them by meaning — “what did we decide about auth?” finds the OAuth-over-magic-links decision even though the word “auth” never appears in it.

One JSON file

Add the server — globally via Settings → MCP, or per-project. Cursor opens a browser tab the first time it connects, where you sign in and approve it; there is no key to create first, and you can revoke it later from the dashboard:

.cursor/mcp.json
{
  "mcpServers": {
    "Kognite": {
      "url": "https://mcp.kognite.dev/mcp",
      "type": "streamable-http"
    }
  }
}
  • Toggle the Kognite server ON in Settings → MCP — a green dot means its tools are loaded.
  • Open Composer in Agent mode; the memory_* tools are now callable.
  • No plugin, no npm install, no local process — the URL is the whole integration.

A rule that makes memory automatic

Cursor uses tools on its own judgment in Agent mode. One small rules file makes remembering and recalling the default instead of the exception:

.cursor/rules/kognite.md
Before answering anything that depends on project history or my
preferences, call memory_search first. When a durable fact, decision,
or preference is stated, persist it with memory_add.

From then on the loop closes itself: decisions made in one Composer session are context in the next one.

One memory across your whole toolchain

  • Cross-session continuity — the Agent recalls prior decisions instead of re-deriving (or contradicting) them.
  • Cross-tool continuity — the same store serves Claude Code, VS Code, Zed, Windsurf, and Claude Desktop. Explain something to one agent, and they all know it.
  • A knowledge graph, not a pile of notes — entities and relationships with temporal edges, included on every plan.
  • Scope isolation — personal, team, and per-agent scopes so client A's context never surfaces in client B's project.

Common questions

How is this different from Cursor's rules and project docs?

Rules are static instructions you write by hand. Kognite is accumulated knowledge the Agent writes and searches itself — it grows as you work, and retrieval is semantic, so nobody maintains a file.

Will it slow Composer down?

Memory tools are ordinary MCP calls made only when relevant, and searches are never metered — proactive recall costs no quota.

Can my team share one memory?

Yes — team scopes give every teammate's agent the same knowledge base; Studio adds role-based access control.

What does it cost?

Free: 5,000 new memories/mo, searches unmetered. Paid from $19/mo — graph included on every plan.

Ship the same context twice? Never again.

Free tier: 5,000 new memories a month, searches never metered. Setup is one JSON file.