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 121 tools. Free tier available. Runs on German (EU) servers.

How does cachly work?

Run 'npx @cachly-dev/mcp-server@latest autopilot' 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 autopilot' 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.

Free, Private Embeddings for Your AI Dev Brain — Powered by Ollama

The problem we kept hearing

When we launched the Cachly AI Dev Brain — persistent cross-session memory for AI coding assistants — the most common question was:

"Do I need an OpenAI API key just for memory? I'm already using Claude/Copilot/Cursor…"

Short answer: you shouldn't have to. Memory is infrastructure. You don't pay Stripe every time you write to a database. So we fixed it.

What we built

We now run nomic-embed-text via Ollama directly on our cachly infrastructure (Hetzner, Germany). Every embedding operation for the AI Brain — index_project, smart_recall, learn_from_attempts, remember_context — goes through this local model.

✅ No OPENAI_API_KEY needed — just your CACHLY_JWT

✅ No prompts, code snippets, or filenames leave Germany

✅ 768-dimension embeddings, cosine similarity search via pgvector

✅ Sub-10ms embedding latency (model stays hot in memory)

✅ Works even in air-gapped or restricted corporate environments

nomic-embed-text: Why we chose it

Model	Dims	Size	MTEB Score	License
nomic-embed-text ★	768	274 MB	62.4	Apache 2.0
text-embedding-3-small	1536	API	~62.0	OpenAI ToS
text-embedding-ada-002	1536	API	60.9	OpenAI ToS
all-MiniLM-L6-v2	384	91 MB	56.3	Apache 2.0

nomic-embed-text scores on par with OpenAI's best embedding models, is fully open-source, and fits under 300 MB — making it practical to run on existing server infrastructure without a GPU.

How it works under the hood

MCP Tool Call: smart_recall("fix deploy")
       ↓
cachly MCP Server (npm)
       ↓ HTTP
cachly API (Go) — POST /api/v1/semantic/search
       ↓
EmbedHandler.Embed("fix deploy")
       ↓ HTTP (internal Docker network)
Ollama: POST http://ollama:11434/api/embeddings
       ↓
nomic-embed-text → 768-dim float32 vector
       ↓
pgvector: SELECT ... ORDER BY embedding <=> $1 LIMIT 10
       ↓
Top-k lessons returned to your AI assistant

Everything runs on a single Hetzner CPX32 node in Germany. The Ollama container uses max 700 MB RAM and stays idle at ~62 MB between requests.

Bring your own model (optional)

If you'd rather use your own embedding provider, set these in your MCP config:

{
  "env": {
    "CACHLY_JWT": "your-jwt",
    "CACHLY_BRAIN_INSTANCE_ID": "your-instance-id",
    "CACHLY_EMBED_PROVIDER": "openai",
    "OPENAI_API_KEY": "sk-..."
  }
}

The Brain falls back automatically to your provider when CACHLY_EMBED_PROVIDER is set. Otherwise it uses our hosted nomic-embed-text instance.

Get started

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

No OPENAI_API_KEY needed. Just your CACHLY_JWT.