A Memory System for AI assistants that goes beyond traditional RAG. Store conversations, build knowledge graphs, extract facts, and maintain user profiles—all searchable with semantic understanding.Use across your apps and LLMs.

• Infinite Context - Automatically compress long conversations while preserving important information
• Vector Search - Semantic search across all saved conversations using Pinecone
• Full Content Storage - Store up to ~5,000 words per chunk with formatting preserved
• Smart Compression - LLM-powered intelligent summarization

• User Profiles - Automatically learns your interests, projects, and preferences
• Entity Graphs - Build knowledge graphs connecting people, projects, concepts
• Fact Extraction - Extract and chain atomic facts from conversations
• Temporal Awareness - Understand recency and relevance over time
• Hybrid Scoring - Combine semantic similarity with temporal and entity signals

• Query Classification - Understand intent (search, save, question, etc.)
• Query Rewrites - Generate synonyms, broader terms, and expansions
• Enhanced Search - Guardrails, auto-refinement, and follow-up recommendations

• GitHub Repositories - Index entire repos for code search
• Documentation Sites - Crawl and index docs
• Websites - Full website crawling
• Local Filesystems - Index local directories
• Single URLs - Index individual pages (blogs, ChatGPT conversations, tweets)

git clone https://github.com/yourusername/infinite-context-mcp.git
cd infinite-context-mcp

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

pip install -r requirements.txt

cp env_example.txt .env

Edit .env with your API keys:

ANTHROPIC_API_KEY=your_anthropic_api_key_here
OPENAI_API_KEY=your_openai_api_key_here
PINECONE_API_KEY=your_pinecone_api_key_here
PINECONE_INDEX_NAME=infinite-context-index  # Optional, this is the default

Get your API keys:

• Anthropic Console - For Claude (AI responses)
• OpenAI Platform - For embeddings
• Pinecone Console - For vector storage (free tier available)

Edit run_mcp.sh to point to your installation:

#!/bin/bash
cd /path/to/your/infinite-context-mcp
source venv/bin/activate
exec python main.py

Make it executable:

chmod +x run_mcp.sh

Add to your Cursor MCP settings (~/.cursor/mcp.json or via Settings > MCP):

{
  "mcpServers": {
    "infinite-context": {
      "command": "/path/to/your/infinite-context-mcp/run_mcp.sh",
      "args": [],
      "env": {
        "PYTHONPATH": "/path/to/your/infinite-context-mcp"
      }
    }
  }
}

Add the same configuration to Claude Desktop's MCP settings.

claude mcp add --transport stdio infinite-context -- /path/to/your/infinite-context-mcp/run_mcp.sh

Fully quit and restart Cursor/Claude Desktop to load the MCP server.

The easiest way to use the MCP—just describe what you want:

"Save this conversation about setting up the MCP server"
"Find past discussions about API integration"
"What have I been working on lately?"
"Show me my user profile"

When you save context, the system stores:

• Summary - Brief overview (up to 2,000 chars)
• Full Content - Raw content preserving formatting (up to 25,000 chars)
• Topics - Tags for categorization
• Key Findings - Important points extracted
• Entities - People, projects, concepts mentioned
• Facts - Atomic facts for precise retrieval

The system automatically learns:

• Interests - Topics you frequently discuss
• Current Focus - What you're actively working on
• Entity Connections - How concepts in your work relate

As you save contexts, entities are extracted and connected:

• Find relationships between projects, people, and concepts
• Discover paths between entities
• Get summaries of your knowledge domain

Atomic facts are extracted with:

• Type - Statement, decision, preference, problem, solution, etc.
• Confidence - How certain the extraction is
• Temporal Ordering - Newer facts can supersede older ones

Search combines multiple signals:

• Semantic Similarity - Meaning-based matching
• Temporal Relevance - Recent content weighted higher
• Entity Matching - Boost results with matching entities
• Profile Context - Personalized based on your interests

infinite-context-mcp/
├── main.py                 # MCP server with all tools
├── run_mcp.sh              # Startup script
├── requirements.txt        # Python dependencies
├── env_example.txt         # Environment variable template
├── query_understanding.py  # Query classification & rewriting
├── user_profile.py         # User profile management
├── entity_graph.py         # Knowledge graph implementation
├── fact_chain.py           # Fact extraction & chaining
├── memory_scorer.py        # Hybrid scoring system
├── lib/
│   └── indexing_service.py # External indexing service
└── api/
    └── api_server.py       # Optional REST API

1. Check the script path - Verify run_mcp.sh path in your MCP config
2. Test the script - Run ./run_mcp.sh directly to see errors
3. Check Python environment - Ensure venv has all dependencies
4. Restart completely - Fully quit and restart your AI tool

1. Verify API keys - Check all keys in .env are valid
2. Pinecone index - Will be auto-created on first run
3. OpenAI access - Ensure your key has embedding API access

chmod +x run_mcp.sh

1. Check MCP connection status in your AI tool's settings
2. Look for error messages in the terminal running the MCP
3. Verify the Pinecone index exists and is accessible

• Never commit .env - It's in .gitignore by default
• API keys in environment - All secrets loaded from env vars
• Unique index names - Use different PINECONE_INDEX_NAME for different projects
• Local storage - User profiles stored locally in ~/.infinite-context/

• QUICKSTART.md - Quick setup guide
• SMART_ACTION.md - Smart action orchestration details
• QUERY_UNDERSTANDING.md - Query understanding features
• USAGE.md - Detailed usage guide

Contributions welcome!

MIT License

Reach out to me on x!