Persistent Memory for
Cline (VS Code) — MCP Setup Guide

Cline (formerly Claude Dev) is VS Code's most powerful AI coding extension, capable of writing, executing, and debugging code autonomously. But its context resets with every new task. Add the Kronvex MCP server and Cline will carry your project knowledge — decisions, bugs, conventions — into every new conversation.

What Cline is and why memory matters for it

Cline is a VS Code extension that wraps Claude (or other models) in a fully agentic loop: it can read and write files, run terminal commands, browse the web, and call external APIs — all autonomously, with your approval at each step. It is significantly more capable than simple autocomplete tools, which is precisely why the memory problem is so acute.

When you start a new Cline task, you have a choice: paste in all the relevant context manually (time-consuming, error-prone, limited by context window) or let Cline operate without it (leading to inconsistent code, repeated mistakes, and suggestions that contradict earlier decisions). Neither option scales.

With the Kronvex MCP server, Cline gets a third option: automatically query a persistent memory store at the start of a task, surface the most relevant historical context, and operate with full awareness of your project's history — without you having to paste anything.

Get your Kronvex API key

Before configuring Cline, you need a Kronvex API key and an Agent ID. Both are available on the free plan — no credit card required.

Configure the MCP server in Cline

Cline's MCP server configuration is managed through its settings panel in VS Code. Open the Cline sidebar (the robot icon in the activity bar), then click the MCP Servers tab at the top. Click Edit MCP Settings — this opens cline_mcp_settings.json in VS Code's editor.

Add the Kronvex server to the JSON object:

{
  "mcpServers": {
    "kronvex-memory": {
      "command": "npx",
      "args": ["-y", "@kronvex/mcp-server"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-api-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Save the file. Cline will automatically detect the new server configuration and attempt to connect. Within a few seconds, the MCP Servers tab should show kronvex-memory with a green status indicator.

Test the memory loop

Open Cline and start a new task. Type the following to test the full remember/recall cycle:

Use the kronvex-memory MCP server to store this:
"This project uses Tailwind CSS v4 with a custom design token
system. Tokens are defined in src/styles/tokens.css. Do NOT
use arbitrary Tailwind values like [#3a3a3a] — always reference
a token variable."

Cline will call the remember tool exposed by the Kronvex MCP server. You will see the tool call in Cline's task log, along with a confirmation from the server. Then test recall in a new task:

Before we start: check my memories for anything about
CSS and styling conventions in this project.

Cline will call recall or inject_context, surface the Tailwind token memory, and include it in its context for the rest of the task. Any component it generates will follow the convention — without you having to mention it again.

Real use cases for Cline + persistent memory

Persistent project context across agentic tasks

Cline's agentic tasks can span dozens of file edits and terminal commands. At the start of any significant task, inject context from memory:

Check my memories for:
- API patterns and conventions in this project
- Known bugs or issues we've encountered before
- Architecture decisions relevant to adding a new feature

Then proceed to implement the user dashboard page.

Cline will query Kronvex first, load the relevant context, and carry that awareness through the entire multi-step task — including file edits, terminal commands, and any browser actions.

Cross-session bug tracking

When Cline helps you debug an issue, have it store the root cause and fix for future reference:

Store this bug fix in memory:
Bug: Next.js App Router server components were importing
client-only modules, causing hydration errors.
Fix: Move all Zustand store imports to 'use client' components.
Never import Zustand directly in server components.
Files affected: app/dashboard/page.tsx, app/layout.tsx

The next time you or Cline encounters a hydration error, a quick memory check will surface this diagnosis immediately — potentially saving hours of debugging.

Remembered user preferences

Cline can remember how you like to work:

• Always ask for approval before running destructive commands (drop table, delete files)
• Prefer functional components with hooks — never class components
• Add JSDoc comments to all public functions
• Always write error boundaries around async data-fetching components
• Commit after each logical unit of work, not at end of task

Store these once and they persist forever. Every Cline task — today, next week, next month — will start with these preferences already loaded.

Dependency and library decisions

One of the most common sources of AI inconsistency is library selection. An AI that doesn't remember your choices might suggest installing a second date library when you already have one, or propose a state management pattern that conflicts with your existing architecture.

Store your key dependency decisions explicitly:

Store in memory:
- State management: Zustand (not Redux, not Context API)
- Forms: React Hook Form + Zod validation
- HTTP client: ky (not axios, not fetch directly)
- Date handling: date-fns (not dayjs, not moment)
- Icons: Lucide React (not heroicons, not react-icons)
Never suggest installing an alternative to these.

Workflow patterns — agentic tasks with memory

The memory-first task template

Establish a habit of starting every significant Cline task with a memory query. This template works well:

Before starting, recall memories relevant to:
[describe the area you're working in]

Then: [describe your actual task]

Cline will automatically use the Kronvex recall tool, surface the most relevant memories (scored by semantic similarity, recency, and access frequency), and proceed with full context.

End-of-task memory consolidation

At the end of a complex agentic task, ask Cline to summarise and store what it learned:

Summarise the key decisions and discoveries from this task
and store them as memories in kronvex-memory. Include:
- Any architecture decisions made
- Any bugs we encountered and how we fixed them
- Any patterns we established that should be followed in future

This builds a growing knowledge base over time. The more tasks Cline completes with memory enabled, the better it gets at working within your specific codebase.

Team knowledge sharing

If your team uses the same Kronvex agent (sharing the API key and Agent ID), every developer's Cline sessions contribute to and benefit from a shared memory pool. One developer's debugging session populates memories that help every other developer avoid the same pitfall.

Tips, best practices, and troubleshooting

The MCP server isn't connecting

If kronvex-memory shows as inactive or erroring in Cline's MCP Servers tab:

• Check node --version in the VS Code terminal — must be 18 or higher
• Try running the server directly: npx -y @kronvex/mcp-server in a terminal to see startup errors
• Verify the JSON in cline_mcp_settings.json is syntactically valid
• Ensure your API key has no extra spaces or quotes — it should be exactly kv-xxxx
• Restart VS Code entirely after making changes to the MCP settings file

Memory retrieval feels slow

Kronvex recall typically completes in 30–60ms for most queries. If you notice significant latency, check the Kronvex status page. For large memory stores (10,000+ memories), consider setting a threshold of 0.5+ to filter for high-confidence matches only, which reduces the result set and speeds up embedding comparison.

Memories getting stale

Some memories become obsolete — you refactored the auth system, deprecated a pattern, or changed libraries. Use the Kronvex dashboard to view and delete outdated memories. You can also ask Cline to update a memory: "Update the memory about our HTTP client — we switched from ky to ofetch."

Data privacy and compliance

All memory data is stored on Kronvex's EU infrastructure (Frankfurt). No data is processed outside the EU. For projects with strict data residency requirements, this matters: unlike US-based memory services, Kronvex is fully GDPR-compliant by design and stores everything in EU data centres. The privacy policy covers data retention and deletion rights in full.