claude-context-server

An MCP server that reads all your Claude Code project memory files and exposes them as tools. Lets any Claude instance — in any project, or via Claude.ai — query your full project history and preferences.

The problem it solves

Claude Code stores per-project memory at ~/.claude/projects/[project]/memory/. Each project is siloed — Claude in one project can't see what it learned in another. Claude.ai (web/phone) can't see any of it.

This server bridges that gap.

Related MCP server: memcp

Installation

Claude Code (CLI / VS Code)

claude mcp add --scope user claude-context-server -- npx -y claude-context-server

That's it. The server is now available in every project automatically. Verify with:

claude mcp list

Claude Desktop app (Mac/Windows)

Add to your Claude Desktop config file:

• Mac: ~/Library/Application Support/Claude/claude_desktop_config.json

• Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "claude-context-server": {
      "command": "npx",
      "args": ["-y", "claude-context-server"]
    }
  }
}

Restart the Claude Desktop app.

Tools

Export for Claude.ai

Claude.ai can't run local MCP servers, but you can give it a snapshot:

npx claude-context-server export

This writes ~/claude-context-export.md. Upload it to a Claude.ai Project as a knowledge file — every chat in that project will have your full context.

Re-run the export whenever your memories have grown and you want to refresh Claude.ai's snapshot.

Use cases

Picking up where you left off

You worked on a Laravel app three months ago and need to add a feature. Instead of re-reading the whole codebase, Claude can query its memory:

"What do you know about the Secure File Transfer project?"

It gets back the full architecture — encryption scheme, deployment checklist, database driver choices, environment variables — and can immediately write informed code without you explaining the context again.

Applying rules from one project to another

You've taught Claude several rules on your marketing website: no em dashes in copy, blog images must be landscape at 1200px, blog posts finish with a CTA linking to the contact form. Those lessons live in that project's memory.

When you start building a related project — say, a CRM for the same agency — Claude in that new project has no idea those rules exist. With this server, it can query:

"What feedback and preferences do you have for my blog post structure?"

And apply every hard-won rule from day one, without you having to re-teach them.

Context on your phone

You're away from your desk and want to think through an architecture decision for your CRM. You open Claude on your phone — which has no access to your local files. But you ran npx claude-context-server export this morning and uploaded the result to a Claude.ai Project.

Claude on your phone already knows the CRM's tech stack (Laravel 11, Blade + Tailwind + Alpine, cPanel deployment), the lead capture SDK architecture, the deployment cron setup, and every other decision made in previous sessions. You can have a real, grounded architecture conversation without being at your computer.

Shared conventions across a client's projects

You build multiple things for the same client — a website, a CRM, a PDF report tool. Each lives in its own project folder. You've saved the client's brand colours, typography choices, and copy style rules in the website project's memory.

When you start a new project for that client, ask Claude:

"Search my memories for anything related to Big Boss Gyms branding."

It finds the brand red #D32027, the Outfit/Manrope font stack, the no-em-dash copy rule, and the contact form CTA structure — all from the website project — and applies them to the new one.

Teaching Claude reusable patterns

Memory isn't just for feedback — you can deliberately save patterns and conventions so they're available everywhere. Tell Claude Code to remember a structural rule:

"Remember: for all my Laravel APIs, every endpoint returns the same response envelope — { data: ..., meta: { success: bool, message: string } }. Controllers extend BaseApiController which has successResponse() and errorResponse() helpers. Never return raw model data directly."

Claude writes this as a reference memory entry. Every new Laravel project you start, this server surfaces that convention automatically. Claude structures every controller the same way without you specifying it — and when it sees code that breaks the pattern, it flags it.

What works well in memory: architectural conventions, response formats, naming rules, copy style guides, small representative snippets, deployment checklists, client preferences.

What doesn't belong in memory: full component implementations (keep those as actual shared files), things that change with every release, anything you'd want version-controlled.

How it works

Claude Code auto-saves memory files to ~/.claude/projects/*/memory/ as you work. Each file has frontmatter with a type (user, feedback, project, reference) and a markdown body. This server reads them fresh on every tool call — no database, no sync, always up to date.

Memory file format

---
name: short-slug
description: one-line summary
metadata:
  type: user | feedback | project | reference
---
Body content here.

Contributing / building from source

git clone https://github.com/carlformigoni/claude-context-server.git
cd claude-context-server
npm install
npm run build

Run locally instead of via npx:

claude mcp add --scope user claude-context-server -- node /path/to/claude-context-server/dist/index.js