Massive Context MCP

Massive Context MCP

Handle massive contexts (10M+ tokens) with chunking, sub-queries, and free local inference via Ollama.

flowchart TD

A[Claude Code] --> B[RLM MCP Server] B --> C{rlm_ollama_status} C -->|cached 60s| D{provider = auto}

D -->|Ollama running| E[🦙 Ollama gemma3:12b] D -->|Ollama unavailable| F[☁️ Claude SDK claude-haiku-4-5]

E --> G[["💰 $0 Free local inference"]] F --> H[["💰 ~$0.80/1M Cloud inference"]]

style A fill:#ff922b,color:#fff style B fill:#339af0,color:#fff style E fill:#51cf66,color:#fff style F fill:#748ffc,color:#fff style G fill:#51cf66,color:#fff style H fill:#748ffc,color:#fff

Based on the Recursive Language Model pattern. Inspired by richardwhiteii/rlm.

📸 Screenshots

Core Idea

Instead of feeding massive contexts directly into the LLM:

1. Load context as external variable (stays out of prompt)
2. Inspect structure programmatically
3. Chunk strategically (lines, chars, or paragraphs)
4. Sub-query recursively on chunks
5. Aggregate results for final synthesis

Quick Start

Installation

Option 1: PyPI (Recommended)

uvx massive-context-mcp

or

pip install massive-context-mcp

With Optional Extras:

# With Code Firewall integration (security filter for rlm_exec)

pip install massive-context-mcp[firewall]

With Claude Agent SDK (for programmatic Claude API access)

pip install massive-context-mcp[claude]

With all extras

pip install massive-context-mcp[firewall,claude]

Option 2: Claude Desktop One-Click

Download the .mcpb from Releases and double-click to install.

Option 3: From Source

git clone https://github.com/egoughnour/massive-context-mcp.git

cd massive-context-mcp uv sync

Wire to Claude Code / Claude Desktop

Add to ~/.claude/.mcp.json (Claude Code) or claude_desktop_config.json (Claude Desktop):

{

"mcpServers": { "massive-context": { "command": "uvx", "args": ["massive-context-mcp"], "env": { "RLM_DATA_DIR": "~/.rlm-data", "OLLAMA_URL": "http://localhost:11434" } } } }

Tools

Setup & Status Tools

Analysis Tools

Quick Analysis with rlm_auto_analyze

For most use cases, just use rlm_auto_analyze — it handles everything automatically:

rlm_auto_analyze(

name="my_file", content=file_content, goal="find_bugs" # or: summarize, extract_structure, security_audit, answer: )

What it does automatically:

1. Detects content type (Python, JSON, Markdown, logs, prose, code)
2. Selects optimal chunking strategy
3. Adapts the query for the content type
4. Runs parallel sub-queries
5. Returns aggregated results

Supported goals:

Programmatic Analysis with rlm_exec

For deterministic pattern matching and data extraction, use rlm_exec to run Python code directly against a loaded context. This is closer to the paper's REPL approach and provides full control over analysis logic.

Tool: rlm_exec

Purpose: Execute arbitrary Python code against a loaded context in a sandboxed subprocess.

Parameters:

• code (required): Python code to execute. Set the result variable to capture output.
• context_name (required): Name of a previously loaded context.
• timeout (optional, default 30): Maximum execution time in seconds.

Features:

• Context available as read-only context variable
• Pre-imported modules: re, json, collections
• Subprocess isolation (won't crash the server)
• Timeout enforcement
• Works on any system with Python (no Docker needed)

Example — Finding patterns in a loaded context:

# After loading a context

rlm_exec( code=""" import re amounts = re.findall(r'\$[\d,]+', context) result = {'count': len(amounts), 'sample': amounts[:5]} """, context_name="bill" )

Example Response:

{

"result": { "count": 1247, "sample": ["$500", "$1,000", "$250,000", "$100,000", "$50"] }, "stdout": "", "stderr": "", "return_code": 0, "timed_out": false }

Example — Extracting structured data:

rlm_exec(

code=""" import re import json

Find all email addresses

emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', context)

Count by domain

from collections import Counter domains = [e.split('@')[1] for e in emails] domain_counts = Counter(domains)

result = { 'total_emails': len(emails), 'unique_domains': len(domain_counts), 'top_domains': domain_counts.most_common(5) } """, context_name="dataset", timeout=60 )

When to use `rlm_exec` vs `rlm_sub_query`:

Tip: For large contexts, combine both — use rlm_exec to filter/extract, then rlm_sub_query for semantic analysis of filtered results.

Code Firewall Integration (Optional)

For enhanced security, integrate code-firewall-mcp to filter dangerous code patterns before execution:

pip install massive-context-mcp[firewall]

When installed, rlm_exec can automatically check code against a blacklist of known dangerous patterns (e.g., os.system(), eval(), subprocess with shell=True). The firewall uses structural similarity matching — normalizing code to its skeleton and comparing against blacklisted patterns via embeddings.

How it works:

1. Code is parsed to a syntax tree and normalized (identifiers → _, strings → "S")
2. Normalized structure is embedded via Ollama
3. Similarity is checked against blacklisted patterns in ChromaDB
4. Code is blocked if similarity exceeds threshold (default: 0.85)

Configuration (environment variables):

• RLM_FIREWALL_ENABLED=true — Enable firewall checks (auto-enabled when package installed)
• RLM_FIREWALL_MODE=warn|block — Warn or block on matches (default: warn)

Example blocked patterns:

• os.system(user_input) — Command injection
• eval(untrusted_data) — Code injection
• subprocess.Popen(..., shell=True) — Shell injection

Use rlm_firewall_status to check firewall availability and configuration.

Providers & Auto-Detection

RLM automatically detects and uses the best available provider:

How Auto-Detection Works

When you use provider="auto" (the default), RLM:

1. Checks if Ollama is running at OLLAMA_URL (default: http://localhost:11434)
2. Checks if gemma3:12b is available (or any gemma3 variant)
3. Uses Ollama if available, otherwise falls back to Claude SDK

The status is cached for 60 seconds to avoid repeated network checks.

Check Ollama Status

Use rlm_ollama_status to see what's available:

rlm_ollama_status()

Response when Ollama is ready:

{

"running": true, "models": ["gemma3:12b", "llama3:8b"], "default_model_available": true, "best_provider": "ollama", "recommendation": "Ollama is ready! Sub-queries will use free local inference by default." }

Response when Ollama is not available:

{

"running": false, "error": "connection_refused", "best_provider": "claude-sdk", "recommendation": "Ollama not available. Sub-queries will use Claude API. To enable free local inference, install Ollama and run: ollama serve"