Skip to main content
Glama

Cortex-MCP (cortex-mcp)

CI Release v1.1.0 Python 3.10+ MCP Spec Vercel Deployment Claude Code Glama Score Smithery Ready Tests Passed Zero Cloud Dependencies License: MIT

Local-First Bi-Temporal Knowledge Graph, Cross-Agent Persistent Memory, Contradiction Auditor, TruthGate Citation Bundle Exporter & Token-Budgeted Context Compiler MCP Server for AI Coding Agents.

🚀 Live Interactive Developer Portal & Playground: Visit https://cortex-mcp-steel.vercel.app in your web browser to test tools live, inspect schemas, and copy 1-click configurations for Claude Code, Cursor, Windsurf, and Claude Desktop.


Why cortex-mcp Exists

Modern AI coding agents (Claude Code, Cursor, Windsurf, Antigravity, LangGraph) suffer from two compounding failure modes across multi-session engineering workflows:

  1. Cross-Session & Cross-Agent Context Amnesia: Architectural decisions (ADRs), subtle bug root causes, and module invariants discovered in one session vanish when a developer switches sessions or tools.

  2. Stale Context Bloat: Static .cursorrules, CLAUDE.md, or append-only vector stores accumulate contradictory facts as systems evolve (e.g., an old note saying auth_service uses JWT_HS256 alongside a newer note saying it migrated to PASETO_v4). Stuffing both into the prompt wastes tokens and causes hallucinated regressions.

cortex-mcp solves both problems deterministically with zero external API keys and zero cloud dependencies:

  • Bi-Temporal Knowledge Graph (BiTemporalMemoryGraph): Tracks Entities, TemporalFacts, and Episodes with automatic conflict detection and temporal supersession (valid_from, valid_until, superseded_by). When an architectural fact changes, the old fact is retired into historical lineage rather than polluting active context.

  • Hybrid BM25 + 2-Hop Graph Spreading Activation (ContextCompiler): Ranks active facts, ADRs, bug root causes, and file invariants using Okapi BM25 lexical scoring, exact code-identifier boosting, and K-hop graph activation, then packs the highest-utility items into a strict max_tokens budget with 100% stale-fact suppression.

  • Standards-Compliant JSON-RPC 2.0 MCP Server (CortexMCPServer): Exposes tools, resources, and prompts over stdio or in-memory transport for immediate integration with any MCP client.


Related MCP server: memory_graph_mcp

System Architecture

+-----------------------------------------------------------------------------------+
|                AI Coding Agents (Claude Code / Cursor / Windsurf / AGY)           |
+-----------------------------------------+-----------------------------------------+
                                          |
                        JSON-RPC 2.0 over stdio / in-memory
                    (initialize, tools/call, resources/read, prompts/get)
                                          |
                                          v
+-----------------------------------------------------------------------------------+
|                           CortexMCPServer (server.py)                             |
|  Tools:                                                                           |
|   - memory_record_episode     - memory_query_entity                               |
|   - memory_upsert_fact        - memory_time_travel                                |
|   - memory_compile_context    - memory_verify_integrity                           |
+-------------------+-------------------------------------------+-------------------+
                    |                                           |
                    v                                           v
+---------------------------------------+   +---------------------------------------+
|   BiTemporalMemoryGraph (graph.py)    |   |      ContextCompiler (compiler.py)    |
|                                       |   |                                       |
| * Entities (service, module, ...)     |   | * Code-Aware Tokenizer (snake/Camel)  |
| * TemporalFacts (valid_from/until,    |   | * Okapi BM25 Lexical Scoring          |
|   singular conflict supersession)     |   | * 2-Hop Graph Spreading Activation    |
| * Episodes (ADR, bug_root_cause,      |   | * Stale-Fact Filter (valid_until=None)|
|   invariant, migration, incident)     |   | * Greedy Utility-Density Knapsack     |
| * Point-in-Time Snapshot & K-Hop BFS  |   |   Packing under strict `max_tokens`   |
| * SHA-256 Hashes + Graph Merkle Root  |   | * Provenance Citations (@sha256:...)  |
+-------------------+-------------------+   +---------------------------------------+
                    |
                    v
+---------------------------------------+
| Atomic JSON Snapshot Persistence      |
| (~/.cortex-mcp/memory.json)           |
+---------------------------------------+

Install

pip install "git+https://github.com/codesphere-u/cortex-mcp.git@v1.1.0"
# After the first PyPI release: pip install cortex-bitemporal-mcp  (installs the `cortex-mcp` CLI; import name: cortex_mcp)
cortex-mcp --help

The PyPI name cortex-mcp belongs to an unrelated project, so this package is published as cortex-bitemporal-mcp. The GitHub repository and CLI keep the cortex-mcp name.

Quickstart

1. Installation

git clone https://github.com/codesphere-u/cortex-mcp.git
cd cortex-mcp
pip install -e ".[dev]"

2. Run the Multi-Session Engineering Demo

python -m cortex_mcp.cli demo

Sample output demonstrating automatic supersession of JWT_HS256 by PASETO_v4_public, point-in-time historical inspection, and token-budgeted context compilation:

==============================================================================
 CORTEX-MCP: BI-TEMPORAL KNOWLEDGE GRAPH & CONTEXT COMPILER DEMO
==============================================================================
Entities tracked      : 3
Active temporal facts : 6
Superseded stale facts: 2 (automatically retired)
Engineering episodes  : 4
SHA-256 Merkle Digest : e893bf67424f995283813e265a227224...
------------------------------------------------------------------------------
[Time-Travel Inspection @ 2026-02-01T00:00:00Z (Pre-PASETO Migration)]
  * auth_service --(uses_token_format)--> JWT_HS256
  * auth_service --(signing_primitive)--> HMAC_SHA256_SHARED_SECRET
------------------------------------------------------------------------------
[Compiled Active Context | Budget: 307/320 tokens (95.9%) | Suppressed Stale Facts: 2]
## Cortex-MCP Compiled Context (query: `auth_service token format signing_primitive and payment_ledger idempotency invariant`)
- [FACT:fact_auth_key_v2] `auth_service` --(signing_primitive)--> `Ed25519_Asymmetric_Keypair` (valid_from=2026-04-20T16:45:00+00:00, src=ep_adr_019)
- [FACT:fact_ledger_auth_dep] `payment_ledger` --(verifies_caller_via)--> `auth_service` (valid_from=2026-03-01T11:15:00+00:00, src=ep_inv_007)
- [INVARIANT:ep_inv_007] **INV-007: Payment Ledger Idempotency & Zero-Sum Double Entry** | files: src/payments/ledger.py
  Every mutation in payment_ledger MUST supply a deterministic idempotency_key and balance debit/credit postings to zero in a single SERIALIZABLE transaction.
- [FACT:fact_auth_token_v2] `auth_service` --(uses_token_format)--> `PASETO_v4_public` (valid_from=2026-04-20T16:45:00+00:00, src=ep_adr_019)
- [FACT:fact_ledger_isolation] `payment_ledger` --(requires_isolation_level)--> `SERIALIZABLE_WITH_IDEMPOTENCY_KEY` (valid_from=2026-03-01T11:15:00+00:00, src=ep_inv_007)
- [FACT:fact_order_depends_ledger] `order_repository` --(depends_on)--> `payment_ledger` (valid_from=2026-02-14T14:30:00+00:00, src=ep_bug_042)
==============================================================================

Connect to Claude Code / Cursor / Windsurf / Antigravity

Add Cortex-MCP directly to Claude Code with one command:

# Project-scoped:
claude mcp add --transport http cortex-mcp https://cortex-mcp-steel.vercel.app/mcp

# Global user-scoped (available across all projects):
claude mcp add --scope user --transport http cortex-mcp https://cortex-mcp-steel.vercel.app/mcp

2. Cursor / Windsurf / Claude Desktop (mcp.json)

Add the hosted HTTP server to .cursor/mcp.json or claude_desktop_config.json:

{
  "mcpServers": {
    "cortex-mcp": {
      "type": "http",
      "url": "https://cortex-mcp-steel.vercel.app/mcp"
    }
  }
}

3. Smithery Registry (1-Click Install)

npx -y @smithery/cli install @codesphere-u/cortex-mcp --client claude

4. Local Stdio via uvx (Zero Install)

{
  "mcpServers": {
    "cortex-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/codesphere-u/cortex-mcp.git",
        "cortex-mcp",
        "serve-stdio"
      ]
    }
  }
}

Exposed MCP Tools (tools/list) & Detailed Usage Guide

Tool Name

What is its use? (Purpose)

Key Arguments

Typical Output

memory_record_episode

Record an immutable engineering episode (adr, bug_root_cause, invariant, session_note, migration, incident) with touched files and mentioned entities.

title (str), category (enum), content (str), files_touched (list), entities_mentioned (list)

{"episode": {"id": "ep_...", "sha256": "..."}}

memory_upsert_fact

Record a directed (subject_id, predicate, object) fact with automatic bi-temporal conflict detection and supersession when singular=True.

subject_id (str), predicate (str), object_value (str), singular (bool, default True)

{"fact": {"id": "fact_...", "superseded": [...]}}

memory_compile_context

Compile a provenance-cited, token-budgeted context bundle (max_tokens) using hybrid BM25 + 2-hop graph spreading activation.

query (str), max_tokens (int, default 1200), as_of (iso8601), include_superseded (bool)

{"markdown": "...", "token_count": 842, "citations": [...]}

memory_query_entity

Inspect an entity's active facts, superseded historical facts, related episodes, and K-hop ego-graph neighborhood.

entity_id (str), max_hops (int, default 2), include_superseded (bool)

{"entity": "...", "active_facts": [...], "history": [...]}

memory_time_travel

Query the entire knowledge graph as of any historical ISO-8601 UTC timestamp (as_of).

as_of (iso8601 UTC timestamp str)

{"as_of": "...", "active_facts": [...], "snapshot_hash": "..."}

memory_verify_integrity

Verify canonical SHA-256 hashes across all facts and episodes and compute the graph Merkle root digest.

None

{"verified": true, "fact_count": 12, "merkle_root": "..."}

cortex_audit_contradictions

Scan active facts for unresolved logical contradictions (negation polarity inversions, antonym objects, predicate alias collisions, or unsuperseded multi-value drift) with optional auto_resolve=True.

as_of (optional str), auto_resolve (bool, default False)

{"contradiction_count": 0, "findings": [], "auto_resolved": []}

Tool Usage Examples

1. memory_upsert_fact — Recording Architectural Facts with Automatic Supersession

When an AI agent modifies architecture (e.g. changing token signing algorithm from RS256 to Ed25519), calling memory_upsert_fact updates the active decision while preserving historical auditability:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "memory_upsert_fact",
    "arguments": {
      "subject_id": "auth_service",
      "predicate": "signing_algorithm",
      "object_value": "Ed25519",
      "singular": true
    }
  }
}
2. memory_compile_context — Compiling Token-Budgeted Context for Coding Prompts

Before an agent begins a task, compile relevant historical decisions within a strict token budget:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "memory_compile_context",
    "arguments": {
      "query": "authentication token signing and database transaction isolation",
      "max_tokens": 800
    }
  }
}
3. cortex_audit_contradictions — Auditing Multi-Agent Fact Drift

Detect if two autonomous agents made conflicting decisions in the same codebase:

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "cortex_audit_contradictions",
    "arguments": {
      "auto_resolve": true
    }
  }
}

v1.1.0 Features: Contradiction Auditor & TruthGate Citation Exporter

# 1. Audit active facts in the bi-temporal graph for logical/polarity contradictions
cortex-mcp audit-contradictions --json

# 2. Export compiled context packets as a TruthGate-compatible SourceDocument JSON bundle
cortex-mcp export-sources --query "auth_service uses_token_format" --output sources.json
from cortex_mcp import audit_contradictions, export_truthgate_sources

# Detect and auto-resolve cross-agent predicate alias or polarity conflicts
report = audit_contradictions(graph, auto_resolve=True)
print(report.summary_markdown)

# Export active facts with temporal provenance & SHA-256 Merkle root for codesphere-u/truthgate
sources = export_truthgate_sources(graph, query="payment_ledger isolation_level")

Exposed MCP Resources (resources/list, resources/read)

Resource URI

MIME Type

Purpose / Content Description

cortex://graph/summary

application/json

Real-time counts of tracked entities, active temporal facts, superseded historical facts, recorded episodes, and the graph SHA-256 Merkle root.

cortex://graph/integrity

application/json

Full cryptographic integrity report verifying canonical SHA-256 digests across all temporal facts and engineering episodes.

cortex://episodes/recent

application/json

Array of the 20 most recent engineering episodes (ADRs, invariants, bug root causes, migrations) with touched files and entity links.

Exposed MCP Prompts (prompts/list, prompts/get)

Prompt Name

Purpose / Use Case

Required Arguments

Workflow Output

architecture-briefing

Guides an LLM agent to assemble a verified architectural briefing for a component.

component (string)

Pre-formatted system/user prompts instructing the model to review active facts and ADRs before modifying the component.

bug-investigation-context

Guides an LLM agent through a structured root-cause investigation for a bug symptom.

symptom (string)

Pre-formatted prompt querying active invariants, historical regressions, and touched files to isolate root causes without hallucinating.


Reproducible Benchmarks

Run the built-in benchmark suite (500 temporal facts, 150 bi-temporal supersessions, 100 episodes, 60 entities):

python -m cortex_mcp.cli benchmark

Operation

Samples

P50 Latency (ms)

P95 Latency (ms)

record_episode (SHA-256 + entity indexing)

100

0.003

0.005

upsert_fact (bi-temporal conflict & supersession)

500

0.003

0.004

traverse_subgraph (2-hop active ego-graph)

60

0.123

0.185

compile_context (BM25 + 2-hop activation, 800 tok)

50

4.879

5.229

verify_integrity (600 SHA-256 hashes + Merkle root)

1

1.412

1.412

  • Active Facts: 350 | Superseded Facts: 150

  • Stale-Fact Suppression Rate: 100.0% (0 leaked stale facts across 50 compilation queries)

  • Token-Budget Compliance Rate: 100.0% (0 budget overruns)

  • Cryptographic Integrity Verified: True


Architectural Decision Records (ADRs)

ADR-01: Bi-Temporal Supersession over Destructive Overwrite or Append-Only RAG

  • Context: Append-only vector stores return both old and new architectural facts when queried, confusing LLM agents. Destructive overwrites destroy auditability ("why did we stop using JWT_HS256?").

  • Decision: Every TemporalFact carries valid_from, valid_until, and superseded_by. Inserting a new singular=True fact for (subject_id, predicate) atomically closes the prior active fact's validity window (valid_until = new_fact.valid_from) and links superseded_by = new_fact.id.

  • Consequence: Active context compilation achieves 100% stale-fact suppression while memory_time_travel and memory_query_entity retain complete historical lineage.

ADR-02: Hybrid BM25 + 2-Hop Spreading Activation over Embedding-Only Retrieval

  • Context: Dense embeddings frequently miss exact code identifiers (OrderRepository, SERIALIZABLE_WITH_IDEMPOTENCY_KEY) and fail to retrieve 2-hop architectural dependencies not lexically mentioned in the prompt.

  • Decision: Combine a code-aware tokenizer (snake_case, CamelCase, file paths) with Okapi BM25 lexical scoring, exact identifier boosting, and 2-hop graph spreading activation over active edges, followed by greedy utility-density packing under max_tokens.

  • Consequence: Deterministic, sub-5ms context compilation with zero external embedding API latency or cost.


Running the Test Suite

pytest -v

All 100 tests validate bi-temporal supersession chains, semantic & polarity contradiction auditing, TruthGate SourceDocument citation bundle export, point-in-time queries, K-hop graph traversal, token-budget compliance, cryptographic tamper detection, JSON-RPC 2.0 MCP protocol compliance, and CLI subcommands.


Hosted endpoint (Vercel)

A free, public, stateless deployment of Cortex MCP runs over MCP Streamable HTTP:

MCP endpoint

https://cortex-mcp-steel.vercel.app/mcp (JSON-RPC 2.0 over POST)

Health probe

https://cortex-mcp-steel.vercel.app/health

curl -s -X POST https://cortex-mcp-steel.vercel.app/mcp -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Client Configuration

1. Claude Code CLI

Add instantly to your Claude Code workspace or global user profile:

# Add to current project:
claude mcp add --transport http cortex-mcp https://cortex-mcp-steel.vercel.app/mcp

# Or add globally across all projects:
claude mcp add --scope user --transport http cortex-mcp https://cortex-mcp-steel.vercel.app/mcp

2. Claude Desktop / Cursor / Windsurf (mcp.json)

{
  "mcpServers": {
    "cortex-mcp": {
      "type": "http",
      "url": "https://cortex-mcp-steel.vercel.app/mcp"
    }
  }
}

Hosted limitations: All 7 tools are available. State is in-memory and ephemeral (per serverless instance, shared by callers) — use the local stdio install for persistent, private memory.

The hosted gateway is api/index.py; it enforces a 1 MB body limit, strict JSON-RPC envelopes and the tool restrictions above. Deploy your own copy with npx vercel deploy --prod (entrypoint is configured in pyproject.toml under [tool.vercel]).

License

MIT License — Copyright (c) 2026 Akandwanaho Ivan Alvin.

Available Tools

7 tools
cortex_audit_contradictionsA

Scan active facts in the bi-temporal graph to detect unresolved logical contradictions (negation polarity inversions, antonym objects, predicate alias collisions, or unsuperseded multi-value drift) and recommend or apply supersession resolutions.

Inputs: as_of, auto_resolve.

memory_compile_contextA

Compile a token-budgeted, provenance-cited context bundle for a coding query, automatically suppressing superseded/stale facts.

Inputs: query (required), as_of, max_tokens, include_superseded.

memory_query_entityA

Inspect an entity's active facts, superseded historical facts, related episodes, and K-hop ego-graph neighborhood.

Inputs: entity_id (required), max_hops, include_superseded.

memory_record_episodeB

Record an immutable engineering episode (ADR, bug_root_cause, invariant, session_note, migration, incident) with associated files and mentioned entities.

Inputs: title (required), content (required), category (required), timestamp, +2 more.

memory_time_travelA

Query the knowledge graph as of a specific ISO-8601 timestamp to inspect historical architecture state.

Inputs: as_of (required).

memory_upsert_factB

Record a structured entity-relationship fact (subject_id, predicate, object) with automatic bi-temporal conflict detection and supersession of stale facts.

Inputs: predicate (required), subject_id (required), singular, object_id, +4 more.

memory_verify_integrityA

Verify cryptographic SHA-256 hashes of all episodes and facts and compute the graph Merkle digest.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 7 tools

    Disambiguation4/5

    The write/read/verify tools are clearly split by resource and action: episode recording, fact upsert, entity inspection, context compilation, and time travel are distinguishable. Minor overlap exists between memory_query_entity and memory_compile_context (both retrieve graph data) and between memory_verify_integrity and cortex_audit_contradictions (both are 'check' operations), though descriptions clarify hash integrity vs. logical contradiction.

    Naming Consistency4/5

    Six tools follow a clean memory_<verb>_<noun> snake_case pattern with consistent imperative verbs. The single cortex_audit_contradictions breaks both the prefix and the verb_noun ordering, but it is still readable and semantically clear.

    Tool Count5/5

    Seven tools is a well-scoped surface for a bi-temporal engineering memory graph, with each tool covering a distinct phase of the lifecycle (write, read, compile, historical query, integrity, audit). No tool appears redundant or filler.

    Completeness4/5

    The surface covers the core lifecycle: recording episodes, upserting facts with supersession, querying entities, compiling context, time travel, integrity verification, and contradiction auditing. Gaps remain around explicit retraction/deletion of facts or episodes and full-text/episode search, forcing agents to rely on the audit tool or supersession to fix bad data.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Provides long-term memory and a temporal knowledge graph for AI agents, enabling persistent memory and reasoning across sessions.
      33
      2
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables AI agents to maintain a persistent knowledge graph of a project, providing dependency context, impact analysis, side-effect discovery, and session recording for more informed coding decisions.
      5
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to store and retrieve typed facts with bi-temporal validity, supersede outdated information, and query what was true as of any past date.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI coding agents to keep sessions short by compacting early, saving a handoff and restoring it afterwards, while automatically recalling relevant project knowledge on every request. It exposes a code map ranked with PageRank and a temporal knowledge graph of decisions, bugs, gotchas and concepts, searched with hybrid BM25, Personalized PageRank and Reciprocal Rank Fusion within a token budget.
      6 npm
      13
      MIT