cachly is a persistent AI memory platform for developers. It gives AI coding assistants like Claude Code, Cursor, GitHub Copilot and Windsurf a brain that remembers every lesson, fix, and architecture decision — forever. It connects via the MCP (Model Context Protocol) standard and includes 89 tools. Free tier available. Runs on German (EU) servers.

How does cachly work?

Run 'npx @cachly-dev/mcp-server@latest setup' once. The wizard auto-detects every AI editor you have installed (Claude Code, Cursor, Copilot, Windsurf, Cline, Zed) and writes the correct config for each. It then reads your entire git history with brain_from_git and loads years of team knowledge into your Brain before your first session. From that point, sessions start automatically, memory is shared across all your editors simultaneously, and a git post-commit hook teaches cachly from every commit.

Does cachly auto-detect my editors?

Yes. The cachly setup wizard automatically detects Claude Code, Cursor, GitHub Copilot, Windsurf, Cline, Zed, and Continue.dev — any editor that supports MCP. It writes the correct config file for each editor in one pass. You never manually edit JSON config files.

Is memory shared across all my AI editors?

Yes. cachly uses a single Brain that all your AI editors connect to simultaneously. A lesson remembered in Claude Code is instantly available in Cursor and GitHub Copilot. If your team uses different editors, all of you share the same persistent memory pool.

What is brain_from_git?

brain_from_git is a cachly tool that reads your entire git history before your first session and extracts lessons from every commit, PR, and revert. Your AI arrives knowing years of architectural decisions, bug fixes, and team conventions — without you writing a single line of documentation. Zero onboarding.

What is causal_trace?

causal_trace is a cachly tool that traces the history of any file or bug across your entire git history in seconds — replacing 30+ minutes of manual git blame. Describe a problem in plain English. It returns the root cause, the failure chain, and the exact fix that worked — with date, command, and file path.

What is brain_predict?

brain_predict is a cachly tool that scans your Brain for failure patterns before every deploy, migration, or dependency upgrade. It returns probability-weighted warnings based on your team's actual incident history — so you catch the next incident before it happens.

Does cachly work with Claude Code, Cursor, and GitHub Copilot?

Yes. cachly works with Claude Code, Cursor, GitHub Copilot, Windsurf, Cline, Zed, and Continue.dev — anywhere that supports MCP. Run 'npx @cachly-dev/mcp-server@latest setup' to configure all editors in one step. Memory is shared across all editors simultaneously.

Can cachly search memory across languages?

Yes. cachly uses semantic vector embeddings, not keyword search. A lesson stored in German appears when you search in English. A fix documented in Arabic matches a Japanese query about the same bug pattern. Supported languages include English, German, French, Spanish, Italian, Portuguese, Japanese, Chinese (Simplified and Traditional), Korean, Arabic, Hebrew, and more.

How is cachly different from mem0?

mem0 is a memory layer for Python LLM apps and chatbots — great for building AI products. cachly is built specifically for developer tooling: it connects to your AI editor via MCP, learns from your git history automatically, predicts failures before deploy, and gives your whole team shared memory. cachly runs on EU servers and is GDPR-native. For developers using Claude Code, Cursor, or Copilot, cachly is the right choice.

Is cachly GDPR compliant?

Yes. cachly runs exclusively on German servers (Hetzner). All data stays in the EU. No data is shared with third parties. cachly is fully GDPR compliant. An AVV (Auftragsverarbeitungsvertrag / Data Processing Agreement) is available for Business and Enterprise customers.

TUTORIALMay 14, 2026 · 5 min read

How to Give Cline Persistent Memory with MCP

Cline is a powerful agentic coding assistant for VS Code — but like every AI tool, it forgets everything between sessions. This guide shows you how to give Cline permanent memory in 30 seconds using cachly's MCP server.

The problem: Cline starts cold every session

Cline is great at executing multi-step tasks autonomously — but it has no memory between sessions. Every time you open VS Code, Cline starts with zero context:

✗Doesn't know your tech stack or architectural decisions
✗Can't recall bugs it helped you fix last week
✗Unaware of team conventions it learned in previous sessions
✗No knowledge of which approaches you tried and abandoned
✗Can't learn from past mistakes across runs

For an agentic tool like Cline, this is especially painful — it re-explores the same codebase structure, re-discovers the same patterns, and sometimes repeats the same mistakes.

The solution: cachly MCP server

cachly is an MCP (Model Context Protocol) server that gives Cline a persistent AI Brain. 89 memory tools that survive across sessions, across editors, across your entire team.

smart_recall

Auto-surfaces relevant context at the start of every Cline session

learn_from_attempts

Records what worked and what failed — so Cline doesn't repeat mistakes

causal_trace

Traces any bug through your full git history in one call

brain_predict

Warns Cline about failure patterns before it executes risky changes

brain_from_git

Pre-loads your entire git history before Cline's first run

team_broadcast

Shares discoveries across your whole team's AI assistants

Setup: one command

npx @cachly-dev/mcp-server@latest setup

The wizard detects VS Code (where Cline runs) and writes the MCP config automatically. For Cline, the config goes into your VS Code settings or Cline's MCP configuration:

// VS Code settings / Cline MCP config (auto-written by cachly setup)
{
  "mcpServers": {
    "cachly": {
      "command": "npx",
      "args": ["-y", "@cachly-dev/mcp-server@latest"],
      "env": {
        "CACHLY_JWT": "your-token-here"
      }
    }
  }
}

One browser click to sign in — no API keys to manage manually.

Why cachly is especially powerful for Cline

Cline runs autonomously across many steps — which makes persistent memory even more valuable:

`learn_from_attempts` across agent runs

When Cline tries an approach and it fails, cachly records that failure. The next time Cline runs — even days later — it already knows what not to do. No more repeating the same mistakes.

`brain_predict` before risky operations

Before Cline executes a destructive change, brain_predict checks it against past incidents. If a similar change caused a problem before, Cline gets warned automatically.

`brain_from_git` loads codebase history

On first setup, brain_from_git reads your entire git log and extracts lessons — bugs fixed, patterns chosen, decisions made. Cline arrives at every task already knowing your codebase history.

What a Cline session looks like with cachly

# Cline starts a new task: "refactor the payment service"
#
# cachly smart_recall fires automatically:
> Context loaded: payment service
>
> Previous sessions:
>   - Stripe webhook handler refactored (2026-04-18)
>   - idempotency_key required on all charge calls (2026-04-18)
>   - Webhook signature validation must happen before JSON parse
>
> brain_predict: ⚠️ Medium risk
>   Similar refactor in 2025-09 caused a race condition
>   in the retry queue. Recommend adding integration test.
>
# Cline now knows the full history — without you explaining anything.

Give Cline persistent memory in 30 seconds

npx @cachly-dev/mcp-server@latest setup

Auto-detects Cline in VS Code, plus Claude Code, Cursor, Windsurf, Copilot. Free tier, no credit card, German servers.

Get your free token →

cachly is a persistent AI Brain for developers — memory shared across Claude Code, Cursor, GitHub Copilot & Windsurf simultaneously. Auto-detects every editor. Bootstraps from your git history. 89 MCP tools. Free tier, EU servers, no credit card.

Your AI is forgetting everything right now.

Every session starts blank. Every bug re-discovered. Every deploy procedure re-explained. cachly fixes that in 30 seconds — your AI remembers every lesson, every fix, every teammate's hard-won knowledge. Forever.

Give your AI a memory →See how it works

🇪🇺 EU servers · GDPR-compliant🆓 Free tier — forever, no credit card⚡ 30-second setup via npx🔌 Claude Code · Cursor · Copilot · Windsurf