Context Sync

🧠 The Memory Layer for AI Development

Finally, AI that remembers.

Context Sync is the open-source infrastructure that gives AI systems persistent memory across all your development tools, sessions, and projects.

# The future of AI-assisted development
npm install -g @context-sync/server

Local-first • Open source • Platform agnostic • Built by developers, for developers

---

The Problem Every Developer Faces

AI systems lose context between conversations. You spend hours explaining your codebase, architecture decisions, and project context... then close the chat and start over tomorrow.

The memory loss problem affects everyone:

Freelancers juggling multiple client projects
Teams building complex applications
Open source maintainers across different tools
Anyone using AI for serious development work

This isn't just inconvenient - it's fundamentally broken.

Context Sync: GitHub for AI Memory

Context Sync creates persistent, queryable memory for AI systems across all development environments.

Think of it as distributed version control for AI context:

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Claude.ai     │    │   Cursor IDE    │    │   VS Code       │
│   (Web & App)   │    │                 │    │   + Copilot     │
└─────────┬───────┘    └─────────┬───────┘    └─────────┬───────┘
          │                      │                      │
          │           MCP Protocol (standardized)       │
          │                      │                      │
          └──────────────────────┼──────────────────────┘
                                 │
                     ┌───────────▼────────────┐
                     │    Context Sync        │
                     │   Memory Layer         │
                     │                        │
                     │  • Project Context     │
                     │  • Code Understanding  │
                     │  • Decision History    │
                     │  • Architecture Maps   │
                     │  • File Operations     │
                     │  • Git Integration     │
                     └────────────────────────┘

Every AI tool gets the same shared memory.

Why Open Source?

AI memory shouldn't be controlled by corporations.

Context Sync is built by developers who were tired of:

Losing context between AI conversations
Being locked into single AI platforms
Having no control over their development data
Paying subscription fees for basic memory functionality

Our philosophy:

Local-first: Your data stays on your machine
Platform agnostic: Works with any AI that supports MCP
Community-driven: Built for developers, by developers
Extensible: Open architecture for unlimited customization

Quick Start

# Install globally
npm install -g @context-sync/server

# Restart your AI tool (Claude Desktop, Cursor, VS Code)
# Then ask: "help me get started with context-sync"

That's it. Context Sync auto-configures and guides you through first-time setup with natural language instructions.

Supports:

Claude Desktop (Mac/Windows/Linux)
Cursor IDE
VS Code + GitHub Copilot
Any MCP-compatible AI tool

🎯 See the Problem in Action

Before Context Sync:

Monday - Claude Desktop:
You: "I'm building a React app with TypeScript, using Supabase for auth..."
Claude: *helps for 2 hours*

Tuesday - New chat:
You: "Continue working on my React app"
Claude: "What React app? Can you describe your project?"
You: *spends 20 minutes re-explaining everything*

After Context Sync:

Monday - Claude Desktop:
You: "I'm building a React app with TypeScript, using Supabase for auth..."
Claude: *helps for 2 hours*

Tuesday - New chat (or different AI tool):
You: "Continue working on my React app"  
Claude: "Continuing your TypeScript React app with Supabase auth. What should we work on next?"

That's the power of persistent AI memory.

🚀 Get Started in 2 Minutes

# 1. Install Context Sync
npm install -g @context-sync/server

# 2. Restart your AI tool (Claude Desktop, Cursor, VS Code)

# 3. Ask for help setting up
"help me get started with context-sync"

Context Sync automatically detects your platform and guides you through setup with personalized instructions.

🔧 Platform-Specific Setup

VS Code + GitHub Copilot

Quick Setup for VS Code (30 seconds)

After installing Context Sync globally:

Restart VS Code completely
Open Copilot Chat (Ctrl+Shift+I / Cmd+Shift+I)
Switch to Agent mode (if available)
Look for context-sync in the Tools list
Test: Ask Copilot "help me get started with context-sync"

Context Sync should appear in available tools! ✨

🔧 Setup for Cursor

Quick Setup for Cursor (30 seconds)

After installing Context Sync, in Claude Desktop type:

setup cursor

Claude will give you OS-specific instructions! ✨

Manual Cursor Setup

Open Cursor: Settings → MCP
Add this configuration:

{
  "mcpServers": {
    "context-sync": {
      "command": "npx",
      "args": ["-y", "@context-sync/server"]
    }
  }
}

Refresh MCP servers
Test: "Help me get started with context-sync"

Done! ✅

How It Works: Distributed AI Memory

Context Sync creates a persistent knowledge layer between you and AI systems using the Model Context Protocol (MCP).

Architecture:

Your Development Environment
┌─────────────────────────────────────────────────────────┐
│  IDE/Editor        AI Tool           Browser/Web        │
│  ┌───────────┐    ┌───────────┐     ┌─────────────┐    │
│  │  Cursor   │    │  Claude   │     │ Claude.ai   │    │
│  │  VS Code  │    │  Desktop  │     │  Web app    │    │
│  │  Vim/etc  │    │  Copilot  │     │  Other AIs  │    │
│  └─────┬─────┘    └─────┬─────┘     └──────┬──────┘    │
└────────┼──────────────────┼─────────────────┼───────────┘
         │                  │                 │
         └──────────────────┼─────────────────┘
                            │ MCP Protocol
                            │
┌───────────────────────────▼─────────────────────────────┐
│              Context Sync (Open Source)                 │
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐ │
│  │   Memory    │  │   Files     │  │    Git & Code   │ │
│  │  • Projects │  │  • Read     │  │  • Status       │ │
│  │  • Context  │  │  • Write    │  │  • Diffs        │ │
│  │  • History  │  │  • Search   │  │  • Analysis     │ │
│  └─────────────┘  └─────────────┘  └─────────────────┘ │
│                                                         │
│            Local SQLite Database (~/.context-sync/)    │
└─────────────────────────────────────────────────────────┘

Key advantages:

Universal compatibility: Works with any MCP-enabled AI
Local ownership: All data stays on your machine
Zero vendor lock-in: Open source and extensible
Intelligent caching: Only loads what AI needs when it needs it

What Makes Context Sync Different

🌍 Universal AI Memory Layer

Context Sync isn't just another tool - it's infrastructure.

Like Git for code, Context Sync is version control for AI knowledge:

Distributed: Every AI tool gets the same shared memory
Local-first: Your data, your control, your privacy
Platform agnostic: Works with any MCP-compatible AI
Extensible: Open source architecture for unlimited customization

Current ecosystem support:

✅ Claude Desktop (Mac/Windows/Linux)
✅ Cursor IDE
✅ VS Code + GitHub Copilot
✅ Any MCP-compatible AI tool
🔄 More platforms added regularly via community contributions

🧠 Intelligent Context Management

Smart memory that scales with your projects:

Project-Aware Context:

Automatic project detection and initialization
Tech stack recognition (TypeScript, React, Python, etc.)
Architecture decision tracking with reasoning
Code structure understanding and analysis

Efficient Memory Usage:

1-3K tokens per project (not full conversation dumps)
On-demand querying (AI requests details as needed)
Structured summaries instead of raw chat logs
Never saturates context windows

Developer-Focused Features:

File operations (read, write, search) with approval workflows
Git integration (status, diffs, branches)
Dependency analysis and call graph tracing
TODO management with cross-project tracking
Code symbol search and type analysis

🔒 Privacy-First Architecture

Your code stays yours:

100% local storage (SQLite database on your machine)
No cloud dependencies (optional git-based sync available)
No tracking or analytics (we don't even have servers!)
Open source transparency (audit every line of code)
Zero vendor lock-in (export your data anytime)

Context Sync vs. Existing Solutions

The fundamental difference: Context Sync is infrastructure, not a product.

Other approaches:

Chat-based solutions: Store conversations → become bloated and slow
Platform-specific tools: Lock you into one AI tool
Cloud-based services: Your data on someone else's servers
Proprietary solutions: No customization, no transparency

Context Sync approach:

Memory infrastructure: Structured, queryable knowledge base
Universal compatibility: Works with any MCP-enabled AI
Local-first: Your data stays on your machine
Open source: Community-driven development and customization

Complementary, not competitive:

Use with Claude Pro for more daily messages
Works alongside /compact for conversation compression
Enhances existing AI tools rather than replacing them

💬 Common Questions

Why isn't this built into Claude already?

Honest answer: Business incentives.

If Claude remembered everything perfectly:

You'd have shorter conversations
Use fewer messages
Hit rate limits slower

Persistent memory makes AI more useful but potentially less profitable for AI companies.

That's why Context Sync is:

Open source (no profit motive)
Local-first (you own your data)
Community-driven (built by developers, for developers)

Won't this fill up my context window?

No! Context Sync uses only 1-3K tokens per project.

How it works:

Stores structured summaries (not full conversations)
AI queries for details on-demand via MCP
Never dumps everything into a new chat

Analogy:

❌ Bad: Loading 10GB codebase into RAM
✅ Good: IDE that loads files as needed

Example:

Your 10K line project with 50 decisions
Context Sync summary: ~1.5K tokens
AI queries for specific details when needed

You never saturate because you're not copying conversations - you're giving AI access to a queryable database.

Is my data safe and private?

100% local. 100% yours.

✅ SQLite database on YOUR machine
✅ No cloud sync (unless you configure it)
✅ No data sent to our servers (we don't have servers!)
✅ Open source - audit the code yourself
✅ Delete anytime - just remove ~/.context-sync/

Database location:

Mac/Linux: ~/.context-sync/data.db
Windows: %USERPROFILE%\.context-sync\data.db

You control everything.

Does this work with VS Code?

Yes! Available since v0.6.0! 🎉

VS Code with GitHub Copilot is now fully supported through MCP integration.

Setup instructions:

Install Context Sync: npm install -g @context-sync/server
Restart VS Code
Open Copilot Chat
Switch to Agent mode
Look for context-sync in Tools list

Currently works with:

✅ VS Code + GitHub Copilot (new!)
✅ Cursor IDE (full support)
✅ Claude Desktop (full support)

Does this work with Claude Code CLI?

Also supported since v0.6.0!

Claude Code just launched and supports MCP, so integration should be straightforward.

We're prioritizing:

VS Code extension
Claude Code CLI
Better onboarding

Want it sooner? Let us know in GitHub Discussions!

Can I use this on mobile?

Not yet. Mobile requires:

Claude mobile app to support MCP (not available yet)
OR a custom mobile app (planned for future)

Current workaround:

Use Claude.ai web on mobile (read-only)
Full features on desktop only

Mobile support depends on Anthropic adding MCP to their mobile app.

How much does this cost?

Context Sync is 100% free and open source (MIT License).

Why free?

Built by developers, for developers
Solves a problem we personally had
Community-driven development
No profit motive = no business incentives to limit features

You might pay for:

Claude Pro subscription (recommended but not required)
Your time (2 minutes to set up)

That's it!

What if I have multiple projects?

Context Sync handles multiple projects beautifully!

You: "Switch to my blog project"
AI: [loads blog context instantly]

You: "List my projects"
AI: 
  1. TaskFlow (Next.js + Supabase)
  2. Personal Blog (Astro)
  3. Client Website (WordPress)

You: "Switch to TaskFlow"
AI: [back to TaskFlow context]

Each project maintains its own:

Architecture decisions
Tech stack
TODOs
Code context
Conversation history

🎬 Real-World Example

Freelance Developer Workflow

Monday Morning (Cursor):

You: "Initialize project 'EcommerceClient' - Next.js 14, Stripe, PostgreSQL"
AI: "Project created! ✓"
*Build product catalog for 3 hours*

Tuesday Afternoon (Claude Desktop):

You: "Continue EcommerceClient - add shopping cart"
AI: "Adding cart to your Next.js app with Stripe integration.
     Using the product schema we defined yesterday..."

Wednesday (Cursor):

You: "Switch back to Cursor. Review cart implementation"
AI: "Analyzing cart code... found 2 potential improvements..."

No re-explaining. No context loss. Just continuous progress across tools.

🗺️ Roadmap

✅ v0.6.1 - Current

_{Released October 2025}

✓ VS Code & GitHub Copilot support
✓ Performance optimizations
✓ Async file operations
✓ File size limits & safety
✓ Real-time cache invalidation

🔄 v0.7.0 - Next

_{6-8 weeks}

• Claude Code CLI support
• Enhanced VS Code integration
• Better onboarding flow
• Improved documentation
• Additional performance optimizations

🔮 Future

_{Coming later}

• Mobile support
• Team collaboration
• Analytics dashboard
• More AI platforms
• Advanced features

See detailed roadmap: ROADMAP.md

📊 Stats

Recent milestones:

🎉 26 stars in first 24 hours
📦 400+ npm downloads in launch week
🚀 #17 on Product Hunt
💬 20K+ Reddit impressions

🛠️ Advanced Features

Full Feature List

Project Management

Initialize and switch between projects
Track architecture and tech stack
Store design decisions with reasoning
Manage TODOs and priorities

Code Analysis

Dependency graph analysis
Function call traces
Type definition lookup
Find all references
Impact analysis

File Operations

Read project structure
Search files and content
Modify files (with approval)
Preview changes before applying

Git Integration

Status and diff viewing
Branch information
Commit message suggestions
Change tracking

Cross-Platform

Seamless Cursor ↔ Claude sync
Platform-specific optimizations
Context handoff automation

Developer Tools

50+ MCP tools
Extensible architecture
TypeScript + SQLite
Open source

Join the AI Infrastructure Revolution

Context Sync is built by the developer community, for the developer community.

🚀 Why Contribute?

You're not just contributing to a tool - you're building the future of AI-assisted development.

Shape AI tooling standards: Help define how AI systems should handle persistent memory
Solve your own problems: Build features you need for your workflow
Learn cutting-edge tech: Work with MCP, TypeScript, SQLite, and AI integrations
Join a movement: Be part of making AI development tools truly open and extensible

🛠️ Ways to Contribute

Code Contributions:

Add support for new AI platforms (Gemini, Ollama, etc.)
Implement new analysis tools (Python dependency tracking, etc.)
Build integrations for more editors (Vim, Emacs, etc.)
Optimize performance and memory usage

Non-Code Contributions:

Write documentation and tutorials
Test beta features and report bugs
Share use cases and workflows
Help other developers in discussions
Create example projects and templates

Community Building:

Share Context Sync with fellow developers
Write blog posts about your experience
Speak at conferences or meetups
Contribute to roadmap planning

📋 Current Priorities

Help wanted on:

Python ecosystem support - pip, poetry, requirements analysis
Mobile/web integration - React Native, Expo, web development workflows
Docker/containerization - workspace detection for containerized apps
More Git integrations - PR analysis, commit message generation
Performance optimizations - faster workspace scanning, better caching
UI/dashboard development - web interface for memory management

🎯 Get Started Contributing

Star the repo to show support
Join discussions to share ideas and get help
Read CONTRIBUTING.md for technical guidelines
Pick an issue labeled good-first-issue or help-wanted
Submit a PR - we review quickly and provide feedback

New to open source? We're beginner-friendly! Many contributors started here.

💬 Community Links

GitHub Discussions: Feature requests, questions, showcase
Issues: Bug reports and feature planning
Pull Requests: Code contributions welcome
Roadmap: ROADMAP.md - see what's coming next

🔧 Troubleshooting

Claude Desktop doesn't see Context Sync

Verify installation:

context-sync --version

Check config file:

# Mac/Linux
cat ~/.config/Claude/claude_desktop_config.json

# Windows
type %APPDATA%\Claude\claude_desktop_config.json

Restart Claude completely:

Mac: ⌘ + Q (force quit)
Windows: Right-click tray icon → Exit

Check MCP servers in Claude: Look for Context Sync in settings

Still stuck? Create an issue

Cursor doesn't see Context Sync

Open Cursor settings: Settings → MCP
Verify configuration exists:

{
  "mcpServers": {
    "context-sync": {
      "command": "npx",
      "args": ["-y", "@context-sync/server"]
    }
  }
}

Refresh MCP servers in Cursor
Test: Ask AI "What's my current project?"

"No active project" error

Set up a workspace first:

You: "Set workspace to /path/to/your/project"

Or check existing projects:

You: "What projects do I have?"
You: "Switch to [project-name]"

Context not syncing between platforms

Check platform status:

You: "Check platform status"

Verify both platforms are configured
Try manual sync:

You: "Sync context to Cursor"

More help: TROUBLESHOOTING.md

License & Philosophy

MIT License - Use commercially, modify freely, redistribute openly.

Context Sync is truly open source:

No dual licensing schemes
No "enterprise" vs "community" versions
No feature paywalls or subscription tiers
No proprietary extensions or locked ecosystem

Why MIT? Because AI tooling infrastructure should belong to the developer community, not corporations.

The Vision

We're building the git of AI development.

Just as git transformed how developers collaborate on code, Context Sync is transforming how developers collaborate with AI systems.

Current state: AI tools are isolated, forgetful, and platform-locked Our vision: Universal, persistent, extensible AI memory layer End goal: AI that truly understands and remembers your development context across all tools and platforms

This is bigger than Context Sync - we're establishing standards and protocols that any tool can implement. Think of us as the Apache Foundation for AI development infrastructure.

Star History & Community

Growing fast thanks to developers like you:

Recent milestones:

🎉 26 stars in first 24 hours
📦 400+ npm downloads in launch week
💬 Active community in GitHub Discussions
🚀 Growing contributor base from 6 countries

Spread the Word

Help other developers discover Context Sync:

⭐ Star the repository (most important!)
🐦 Share on social media with your experience
� Write about it in blogs, newsletters, forums
💬 Tell colleagues about the productivity gains
🎤 Present at meetups or conferences
🤝 Contribute code or documentation

Every developer who discovers Context Sync makes the AI development ecosystem a little more open and powerful.

Built by developers, for developers. Join the movement.

⭐ Star on GitHub • 📖 Documentation • 💬 Discussions • 🐛 Issues

Name		Name	Last commit message	Last commit date
Latest commit History 27 Commits
.github		.github
bin		bin
documentation		documentation
src		src
.gitignore		.gitignore
.npmignore		.npmignore
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
ROADMAP.md		ROADMAP.md
TROUBLESHOOTING.md		TROUBLESHOOTING.md
package.json		package.json
setup.js		setup.js
tsconfig.json		tsconfig.json
yarn.lock		yarn.lock

License

Intina47/context-sync

Folders and files

Latest commit

History

Repository files navigation