Context-first
The Context-First MCP server maintains AI conversation integrity through 37 tools across 7 layers, preventing context drift, contradictions, ambiguity, and hallucinations. It requires zero API keys and deploys via npx, Claude Desktop, Cursor/VS Code, or a remote Vercel instance.
Core Orchestration
context_loop— Single-call orchestrator running 8 stages (ingest → recap → conflict → ambiguity → entropy → abstention → discovery → synthesis), returning a unified directive (proceed,clarify,reset,abstain) and a context health score (0–1).
Context Health (9 tools)
Recap conversations, detect silent contradictions, check ambiguity, verify tool execution, monitor output entropy, check abstention confidence across 5 dimensions, detect intent drift, check response depth, and verify grounding.
State Management (4 tools)
Lock in confirmed facts and decisions as ground truth (
set_state,get_state,clear_state) and retrieve compressed history summaries.
Sandbox & Discovery (3 tools)
Discover relevant tools via TF-IDF semantic search (reducing context bloat by up to 98%), quarantine isolated memory silos for sub-tasks, and merge results back with noise filtering.
Persistent Memory (6 tools)
Store, recall, compact, graph, inspect, and curate findings across a hierarchical memory system (scratchpad → working → episodic → semantic → graph → curation).
Advanced Reasoning (5 tools)
InftyThink (iterative bounded-segment reasoning), Coconut (continuous latent-space reasoning), ExtraCoT (reasoning chain compression), MindEvolution (evolutionary solution search), and KAG-Thinker (knowledge-augmented structured decomposition).
Truthfulness & Verification (7 tools)
Probe internal state, detect truth direction deviants, run neighborhood consistency checks (NCB), verify logical consistency, pre-verify candidate answers (
verify_first), apply confidence-based self-correction (ioe_self_correct, corrects only when confidence < 0.4), and run iterative self-critique cycles.
Research Pipeline & Export (2 tools)
research_pipeline— Multi-phase orchestration (init → gather → review → analyze → verify → finalize) with autonomous file writing, quality gates, and coverage tracking.export_research_files— Writes verified reports and raw evidence batches directly to disk without requiring manual LLM intervention.
Integrates with arXiv research papers as foundational algorithms for core tools, implementing peer-reviewed methods like ERGO for entropy monitoring, RLAAR for calibrated abstention, and MCP-Zero for semantic tool discovery.
Supports deployment of a remote MCP server instance on Vercel, enabling streamable HTTP access to all context management tools without local installation.
Context-First MCP
The MCP server that keeps your AI grounded, coherent, and honest — across every turn.
npx context-first-mcpWorks instantly with Claude Desktop · Cursor · VS Code · any MCP client · Vercel remote — zero API keys needed.
37 research-backed tools across 7 layers — context health, state, sandboxing, persistent memory, advanced reasoning, truthfulness verification, orchestration, structured research, and autonomous file export. One
context_loopcall replaces 6–7 individual tools and returns a unified action directive.
Why Your AI Conversations Break Down
Long AI conversations fail in predictable ways. Context-First fixes all four:
Failure Mode | What Goes Wrong | Context-First Solution |
Context Drift | AI forgets earlier decisions and intent as the conversation grows |
|
Silent Contradiction | New inputs silently overrule established facts — the AI doesn't notice |
|
Vague Execution | AI proceeds on underspecified requirements, producing misaligned output |
|
Hallucinated Success | Tool outputs look successful but didn't actually achieve the goal |
|
What You Get
37 production-ready tools grouped into 7 layers — plus 1 orchestrator that runs them all:
context_loop ─────────────────────────────────────────────────────────────────
├─ Layer 1 · Context Health (9 tools) recap, conflict, ambiguity, depth …
├─ Layer 2 · Sandbox (3 tools) discover_tools, quarantine, merge
├─ Layer 3 · Persistent Memory(6 tools) store, recall, compact, graph …
├─ Layer 4 · Advanced Reasoning(5 tools) InftyThink, Coconut, KAG, MindEvo …
├─ Layer 5 · Truthfulness (7 tools) NCB, IOE, verify_first, self_critique…
└─ State + Research Pipeline + Export (7 tools)One call. One directive. One score.
{
"directive": {
"action": "clarify",
"contextHealth": 0.62,
"instruction": "Resolve with the user: (1) Is this a firm requirement? (2) Which framework?",
"autoExtractedFacts": { "deploy_to": "Vercel" },
"suggestedNextTools": ["verify_execution", "quarantine_context"]
}
}Quick Start
npx — zero install
npx context-first-mcpClaude Desktop
{
"mcpServers": {
"context-first": {
"command": "npx",
"args": ["-y", "context-first-mcp"]
}
}
}Cursor / VS Code
{
"mcp": {
"servers": {
"context-first": {
"command": "npx",
"args": ["-y", "context-first-mcp"]
}
}
}
}Remote (Streamable HTTP)
{
"mcpServers": {
"context-first": {
"url": "https://context-first-mcp.vercel.app/api/mcp"
}
}
}Deploy your own Vercel instance
Tool Reference
Layer 1: Core Context Health (9 tools)
Tool | Purpose |
| One-call orchestrator. Runs 8 stages (ingest→recap→conflict→ambiguity→entropy→abstention→discovery→synthesis) and returns a single |
| Extracts hidden intent, key decisions, and produces consolidated state summaries |
| Compares new input against ground truth; surfaces contradictions |
| Identifies underspecified requirements and generates clarifying questions |
| Validates whether tool outputs actually achieved the stated goal |
| Proxy-entropy scoring via lexical diversity, contradiction density, hedge frequency, and n-gram repetition (ERGO) |
| 5-dimension confidence scoring — abstains with questions rather than hallucinating (RLAAR) |
| Detects conversation drift from the original intent |
| Evaluates response depth against question complexity |
Layer 1b: State Management (4 tools)
Tool | Purpose |
| Retrieve confirmed facts and task status |
| Lock in ground truth — subsequent conflict checks run against these values |
| Reset specific keys or all state |
| Compressed conversation history with intent annotations |
Layer 2: Sandbox & Discovery (3 tools)
Tool | Method | Purpose |
| MCP-Zero + ScaleMCP | Natural-language tool routing — returns only semantically relevant tools, reducing context bloat by up to 98% |
| Multi-Agent Quarantine | Create isolated memory silos for sub-tasks, preventing intent dilution |
| Multi-Agent Quarantine | Merge silo results with noise filtering — only promoted keys return to main context |
Layer 3: Persistent Memory (6 tools)
Tool | Purpose |
| Store findings, decisions, and intermediate results with metadata |
| Retrieve relevant memories by semantic query |
| Compress and consolidate memory entries |
| Build and query a knowledge graph from stored memories |
| Inspect memory store contents and statistics |
| Deduplicate and organize memory entries |
Layer 4: Advanced Reasoning (5 tools)
Tool | Method | Purpose |
| InftyThink | Infinite-depth reasoning with adaptive stopping |
| Coconut | Chain-of-Continuous-Thought in latent space |
| ExtraCoT | Compress chain-of-thought while preserving reasoning fidelity |
| MindEvolution | Evolutionary search over the solution space |
| KAG-Thinker | Knowledge-augmented generation with structured thinking |
Layer 5: Truthfulness & Verification (7 tools)
Tool | Purpose |
| Probe model consistency across paraphrased prompts |
| Detect whether model reasoning is trending toward or away from truth |
| Neighborhood consistency check across semantically equivalent inputs |
| Verify logical coherence of reasoning chains |
| Pre-verification before committing to claims |
| Intrinsic-extrinsic self-correction |
| Structured self-critique with improvement suggestions |
Research Pipeline & Export (2 tools)
Tool | Purpose |
| Structured research orchestration across |
| Writes every verified report chunk and/or every raw evidence batch to disk in a single call. |
Built on Peer-Reviewed Research
Every core algorithm traces back to a published paper:
Algorithm | Paper | arXiv | Tool |
MCP-Zero | Active Tool Request |
| |
ScaleMCP | Semantic Tool Grouping |
| |
ERGO | Entropy-based Quality |
| |
RLAAR | Calibrated Abstention |
|
Implementation highlights:
Proxy Entropy (ERGO): 4 response-level proxy signals (lexical diversity, contradiction density, hedge-word frequency, n-gram repetition) replace inaccessible token-level logprobs. Composite score above threshold triggers adaptive context reset.
TF-IDF Discovery (MCP-Zero): Pure TypeScript, zero external dependencies. Indexes all tool descriptions at startup; cosine similarity routes queries to the top-k relevant tools only.
Inference-Time Abstention (RLAAR): 5-dimension confidence scoring replaces the RL training loop. Abstains with targeted questions when confidence < threshold — no hallucination fallback.
Export Helper (1 tool)
Tool | Description |
| Writes research artifacts directly to disk. It can automatically expand and write every verified report chunk without asking the LLM to loop |
context_loop Pipeline
context_loop (single MCP tool call)
├── Stage 1: INGEST — Store messages to session history
├── Stage 2: RECAP — Extract intents, decisions, summaries
├── Stage 3: CONFLICT — Detect contradictions against ground truth
├── Stage 4: AMBIGUITY — Check for underspecified requirements
├── Stage 5: ENTROPY — Monitor output quality degradation (ERGO)
├── Stage 6: ABSTENTION — Multi-dimensional confidence check (RLAAR)
├── Stage 7: DISCOVERY — Suggest relevant next tools (MCP-Zero)
└── Stage 8: SYNTHESIS — Combine signals → action recommendation + LLM directiveSynthesis Priority: abstain > reset > clarify > proceed
Each stage runs with independent error isolation — a failure in one stage doesn't block the others. The result includes per-stage timing, status, and detailed results for observability.
LLM Directive (NEW)
The context_loop response includes a top-level directive object designed for LLM consumption — a compact, actionable instruction that replaces the need to parse nested stage results:
{
"directive": {
"action": "clarify",
"instruction": "Before proceeding, resolve these issues with the user:\n1. Could you specify exactly what you mean?\n2. Is this a firm requirement or still open for discussion?",
"questions": ["Could you specify exactly what you mean?", "Is this a firm requirement?"],
"contextHealth": 0.62,
"autoExtractedFacts": { "framework": "React", "deploy_to": "Vercel" },
"suggestedNextTools": ["verify_execution", "quarantine_context"]
}
}How context_loop Works
context_loop (single MCP tool call)
├── Stage 1: INGEST — Store messages to session history
├── Stage 2: RECAP — Extract intents, decisions, summaries
├── Stage 3: CONFLICT — Detect contradictions against ground truth
├── Stage 4: AMBIGUITY — Check for underspecified requirements
├── Stage 5: ENTROPY — Monitor output quality degradation (ERGO)
├── Stage 6: ABSTENTION — Multi-dimensional confidence check (RLAAR)
├── Stage 7: DISCOVERY — Suggest relevant next tools (MCP-Zero)
└── Stage 8: SYNTHESIS — Combine signals → action + directiveSynthesis priority: abstain > reset > clarify > proceed
Each stage runs with independent error isolation. The directive response field carries everything an LLM needs:
Field | Description |
|
|
| Plain-language guidance for the LLM's next step |
| Aggregated clarifying questions (ambiguity + abstention + conflicts) |
| 0–1 composite score. 1 = healthy, 0 = degraded |
| Key-value facts auto-extracted from user messages and stored as ground truth |
| Relevant tools the LLM should consider next |
Smart defaults: currentInput is auto-inferred from the last user message. Facts like "use React" are extracted and stored automatically.
Usage Protocol: Getting the Most from Context-First
The #1 mistake: LLMs treat
context_loopas optional. It's not — it's the backbone.
Built-in Enforcement (v1.2.1+)
The server ships with four compliance mechanisms that require zero configuration:
Server Instructions — Full usage protocol injected at MCP handshake via
ServerOptions.instructionsBootstrap Gate — First non-
context_loopcall appends a strong redirect reminderCross-Tool Reminders — After 3 consecutive calls without
context_loop, reminders appear in tool responsesMCP Prompts —
context-first-protocolandresearch-protocolprompt templates available on demand
Reinforce in Your System Prompt (Optional)
When using Context-First MCP:
1. Call context_loop BEFORE any complex task
2. Call context_loop every 2–3 tool calls
3. Call context_loop AFTER generating long-form output
4. ALWAYS follow directive.action (proceed/clarify/reset/abstain/deepen/verify)
5. Use memory_store to save findings; memory_recall to retrieve themResearch Task Workflow
research_pipeline orchestrates memory, phase control, reasoning, and autonomous file writing. It is not a web crawler — bring your own sources from web search, GitHub, fetch tools, PDFs, or any other MCP.
Phase 1 · Init research_pipeline(init) → sets up state, enables autonomous file writing
Phase 2 · Gather ONE web search → research_pipeline(gather) → file written to disk → repeat
Phase 3 · Analyze research_pipeline(analyze) → reasoning engines produce clean analysis file
Phase 4 · Verify research_pipeline(verify) → context health gate (non-blocking)
Phase 5 · Finalize research_pipeline(finalize) → synthesis.md + all batch files on disk
Automation shortcut:
export_research_files(outputDir, exportVerifiedReport=true) → write all report chunks
export_research_files(outputDir, exportRawEvidence=true) → write all evidence batchesAutonomous file writing is always on. Files are written to ./context-first-research-output/ by default — no LLM cooperation required. Pass outputDir to override.
Architecture
┌──────────────────────────────────────────────────────────────┐
│ @xjtlumedia/context-first-mcp-server │
│ (Core — shared logic) │
│ │
│ Layer 1: Context Health (9 tools) │
│ Layer 2: Sandbox (3 tools) │
│ Layer 3: Persistent Memory (6 tools) │
│ Layer 4: Advanced Reasoning(5 tools) │
│ Layer 5: Truthfulness (7 tools) │
│ State (4) · Orchestrator · Pipeline · Export │
└──────────────┬───────────────────────┬──────────────────────┘
│ │
┌──────▼──────┐ ┌──────▼────────┐
│ stdio-server │ │ remote-server │
│ (npx local) │ │ (Vercel) │
│ stdio │ │ Streamable │
│ 37 tools │ │ HTTP │
└──────────────┘ │ 37 tools │
└───────────────┘Core library (
@xjtlumedia/context-first-mcp-server): All tool implementations. Zero external API keys — heuristic-based by default.stdio-server (
context-first-mcp):npxentry point, stdio transport, 37 tools.remote-server: Vercel serverless, Streamable HTTP transport, 37 tools.
Frontend Demo
Try all 37 tools live in your browser at context-first-mcp.vercel.app.
Development
git clone https://github.com/XJTLUmedia/Context-First-MCP.git
cd Context-First-MCP
pnpm install
# Build everything
pnpm build
# Run stdio server
cd packages/stdio-server && pnpm start
# Run frontend
cd packages/frontend && pnpm dev
# Tests
pnpm testContributing
See CONTRIBUTING.md.
License
Context-First MCP · @xjtlumedia/context-first-mcp-server · context-first-mcp
Built for every developer tired of watching their AI lose the plot.
Latest Blog Posts
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/XJTLUmedia/Context-First-MCP'
If you have feedback or need assistance with the MCP directory API, please join our Discord server