ContextStream MCP Server

🧠 Your AI's Permanent Brain — Across Every Tool, Every Conversation

Tired of re-explaining your codebase to AI every single time?

ContextStream gives your AI persistent memory that follows you everywhere. Decisions remembered. Context preserved. No more repeating yourself.

Website: contextstream.io | Docs: contextstream.io/docs/mcp

✨ Why ContextStream?

The Problem

Close a chat with Cursor → Open a new one → AI forgot everything
Switch from Claude to Windsurf → Start explaining from scratch
New team member joins → Days of onboarding conversations
"Why did we build it this way?" → No one remembers

The Solution

ContextStream is a universal memory layer for AI coding tools. It works with Cursor, Claude Code, Windsurf, VS Code, and any MCP-compatible client.

You: "Initialize session and remember we use PostgreSQL with TypeScript strict mode"
...later, in a NEW conversation...
You: "What are my preferences for this project?"
AI: "You prefer TypeScript with strict mode, and you're using PostgreSQL."

It remembers. Across sessions. Across tools. Forever.

🚀 2-Minute Setup

1. Get your API key (30 seconds)

2. Add to your MCP config (60 seconds)

Cursor / Claude Code / Windsurf / VS Code:

{
  "mcpServers": {
    "contextstream": {
      "command": "npx",
      "args": ["-y", "@contextstream/mcp-server"],
      "env": {
        "CONTEXTSTREAM_API_URL": "https://api.contextstream.io",
        "CONTEXTSTREAM_API_KEY": "your_api_key"
      }
    }
  }
}

Codex CLI: Add to ~/.codex/config.toml:

[mcpServers.contextstream]
command = "npx"
args = ["-y", "@contextstream/mcp-server"]

[mcpServers.contextstream.env]
CONTEXTSTREAM_API_URL = "https://api.contextstream.io"
CONTEXTSTREAM_API_KEY = "your_api_key"

3. Try it out (30 seconds)

Start a chat and say:

"Initialize session and remember that I prefer TypeScript with strict mode"

Then start a brand new conversation and ask:

"What are my preferences?"

✨ It remembers.

🔥 Beyond Memory — That's Just the Beginning

ContextStream isn't just memory storage. It understands your code.

Impact Analysis

"What breaks if I change the UserService class?"

See all dependencies and side effects before refactoring.

Decision History

"Why did we choose PostgreSQL over MongoDB?"

Recall past decisions with full context and reasoning.

Semantic Code Search

"Find where we handle rate limiting"

Search by meaning, not just keywords. Find code by intent.

Knowledge Graph

"Show dependencies for the auth module"

Visualize connections between code, decisions, and docs.

📊 60+ MCP Tools at Your Fingertips

🔍 Code Search & Context

Tool	Description
`search_semantic`	Find code by meaning, not just keywords
`search_hybrid`	Combines semantic + keyword for best results
`search_pattern`	Regex-based code search
`ai_context`	Automatically gather relevant code, docs, and memory

🧠 Memory & Knowledge

Tool	Description
`session_remember`	Quick natural language memory ("Remember I prefer TypeScript")
`session_recall`	Quick recall ("What were the auth decisions?")
`memory_create_event`	Store decisions, insights, and context
`memory_search`	Find relevant past context
`memory_decisions`	Get decision summaries

📊 Code Intelligence

Tool	Description
`graph_dependencies`	Understand what depends on what
`graph_call_path`	Trace execution flows
`graph_impact`	Understand change impact
`graph_circular_dependencies`	Find problematic cycles
`graph_unused_code`	Identify dead code

🤖 AI Integration

Tool	Description
`ai_context`	Build LLM-ready context from your codebase
`ai_enhanced_context`	Deep analysis with memory integration
`ai_plan`	AI-powered development planning
`ai_tasks`	Break down work into actionable tasks

🚀 Session Management

Tool	Description
`session_init`	Initialize conversation with auto-context
`context_smart`	Get relevant context for any message
`session_capture`	Store context to memory
`session_compress`	Compress chat history to memory

See all 60+ tools →

✨ Auto-Context (v0.3.0+)

Context loads automatically on the first tool call. No manual setup required.

═══════════════════════════════════════════
🧠 AUTO-CONTEXT LOADED (ContextStream)
═══════════════════════════════════════════
📁 Workspace: my-project
📂 Project: backend-api

📋 Recent Decisions:
   • Use PostgreSQL for persistence
   • JWT for authentication

🧠 Recent Context:
   • [decision] API design patterns
   • [preference] TypeScript strict mode
═══════════════════════════════════════════

Works with all MCP clients — no client-side changes required.

🛡️ Privacy & Security

Encrypted at rest — All data encrypted with AES-256
No training on your data — We never use your code to train AI
You control access — Workspace permissions & API keys
Self-host option — Enterprise can self-host for full control

🏆 Why Not Built-in Memory?

Built-in memory	ContextStream
✗ Vendor lock-in — switch tools, lose everything	✓ Universal — Cursor, Claude, Windsurf, any MCP tool
✗ Expires or resets over time	✓ Persistent forever — never lose context (paid plans)
✗ No semantic search	✓ Semantic search — find anything across all history
✗ Personal only — teammates start from zero	✓ Team memory — shared context, instant onboarding
✗ No API access	✓ 60+ MCP tools — full API and automation
✗ Memory isolated from code	✓ Knowledge graph — decisions linked to code
✗ Clunky to use	✓ Natural language — "remember X", "what did we decide about Y?"

📖 Full Tool Reference

Authentication

Tool	Description
`auth_me`	Get current user profile

Workspaces

Tool	Description
`workspaces_list`	List accessible workspaces
`workspaces_get`	Get workspace details
`workspaces_create`	Create a new workspace
`workspaces_overview`	Get workspace summary
`workspaces_analytics`	Get usage analytics
`workspaces_content`	List workspace content

Projects

Tool	Description
`projects_list`	List projects (by workspace)
`projects_get`	Get project details
`projects_create`	Create a new project
`projects_overview`	Get project summary
`projects_statistics`	Get code statistics
`projects_files`	List indexed files
`projects_index`	Trigger re-indexing
`projects_index_status`	Check indexing status

Search

Tool	Description
`search_semantic`	Semantic vector search
`search_hybrid`	Combined semantic + keyword
`search_keyword`	Traditional keyword search
`search_pattern`	Regex pattern search
`search_suggestions`	Get search suggestions

Memory

Tool	Description
`memory_create_event`	Store a memory event
`memory_get_event`	Retrieve an event
`memory_update_event`	Update an event
`memory_delete_event`	Remove an event
`memory_list_events`	List events in workspace
`memory_bulk_ingest`	Bulk import events
`memory_distill_event`	Extract key insights
`memory_create_node`	Create knowledge node
`memory_get_node`	Get knowledge node
`memory_update_node`	Update knowledge node
`memory_delete_node`	Remove knowledge node
`memory_supersede_node`	Replace with new version
`memory_list_nodes`	List knowledge nodes
`memory_search`	Search memory
`memory_decisions`	Get decision summaries
`memory_timeline`	Get chronological timeline
`memory_summary`	Get condensed summary

Graph Analysis

Tool	Description
`graph_related`	Find related knowledge nodes
`graph_path`	Find path between nodes
`graph_decisions`	Decision history in graph
`graph_dependencies`	Query code dependencies
`graph_call_path`	Trace call paths
`graph_impact`	Analyze change impact
`graph_circular_dependencies`	Find circular deps
`graph_unused_code`	Find dead code
`graph_contradictions`	Find conflicting info

Tool	Description
`ai_context`	Build LLM context
`ai_enhanced_context`	Deep context with memory
`ai_embeddings`	Generate embeddings
`ai_plan`	Generate dev plan
`ai_tasks`	Generate tasks

Session & Auto-Context

Tool	Description
`session_init`	Initialize conversation
`session_get_user_context`	Get user preferences
`session_capture`	Store context to memory
`session_smart_search`	Search with context enrichment
`session_remember`	Quick natural language memory
`session_recall`	Quick natural language recall
`context_smart`	Get relevant context for message
`session_compress`	Compress chat history to memory
`session_summary`	Get compact workspace summary
`session_delta`	Get changes since timestamp

🔌 Pre-built Prompts

Prompt	Description
`explore-codebase`	Get a codebase overview
`capture-decision`	Document an ADR
`review-context`	Build code review context
`investigate-bug`	Debug investigation helper
`explore-knowledge`	Navigate knowledge graph
`onboard-to-project`	Generate onboarding guide
`analyze-refactoring`	Find refactoring opportunities
`build-context`	Build comprehensive LLM context

⚙️ Environment Variables

Variable	Required	Description
`CONTEXTSTREAM_API_URL`	Yes	API base URL (`https://api.contextstream.io`)
`CONTEXTSTREAM_API_KEY`	Yes	Your API key from contextstream.io

🔗 Links

Website: contextstream.io
Documentation: contextstream.io/docs
MCP Setup Guide: contextstream.io/docs/mcp
npm: @contextstream/mcp-server
GitHub: contextstream/mcp-server

🤝 Contributing

We welcome contributions! Here's how you can help:

Report bugs — Open an issue at GitHub Issues
Request features — Share your ideas in the issues
Submit PRs — Fork the repo and submit pull requests

Development

# Clone the repo
git clone https://github.com/contextstream/mcp-server.git
cd mcp-server

# Install dependencies
npm install

# Run in development mode
npm run dev

# Build for production
npm run build

# Type check
npm run typecheck

📄 License

MIT