ctxgraph

Privacy-first knowledge graph engine for AI agents.

Extracts entities and relations from any text. Builds a temporal knowledge graph. Works locally with zero API keys — and when it does call an LLM, it makes one call per episode instead of Graphiti's six.

brew install rohansx/tap/ctxgraph
ctxgraph init && ctxgraph models download
ctxgraph log "Migrated auth from Redis sessions to JWT. Chose JWT for stateless scaling."
ctxgraph query "Why did we move away from Redis?"

Why ctxgraph?

Every knowledge graph engine requires an LLM for every operation. Graphiti makes 6 API calls per episode. Mem0 calls GPT-4 on every add/search. Microsoft GraphRAG is so expensive they put a cost warning in their README.

ctxgraph runs a tiered extraction pipeline: local ONNX models handle most episodes at zero cost, and only escalates to an LLM when local confidence is low. One call, not six. PII stripped before it leaves your machine.

Benchmarked on 20 random real-world texts (GPT-4o judge, 10-point scale):

ctxgraph's local ONNX tier handles tech-domain text at 0.800 F1. For cross-domain, the Ollama tier (auto-detected) uses Gemma 3n E4B at zero cost. Cloud escalation to Gemma 4 26B MoE hits 8.4/10 quality at $0.13/1M tokens.

How It Works

Text comes in
    │
    ▼
[Tier 1] GLiNER + GLiREL (local ONNX, FREE, ~30ms)
    │
    ▼ confidence < threshold?
    │
[Tier 2] Ollama auto-detected (Gemma 3n E4B, FREE, ~18s, 3.8GB VRAM)
    │
    ▼ Ollama not available?
    │
[Tier 3] Cloud API + CloakPipe PII stripping ($0.13/1M tokens)

Auto-schema inference: Log 3 episodes → ctxgraph infers domain-specific entity/relation types automatically. No manual schema definition needed.

Graphiti does ALL of these via LLM: entity extraction, deduplication, relation extraction, contradiction detection, summarization, community detection. Five calls. Every episode.

Competitive Landscape

Knowledge Graph Engines

Agent Memory Systems

Graph-Enhanced RAG

What Makes ctxgraph Unique

No other tool has all of these:

1. Zero-config schema inference — Log 3 episodes, ctxgraph auto-infers domain-specific entity/relation types. No manual schema definition.
2. Tiered local-first pipeline — ONNX handles ~70% of extractions at $0. Ollama auto-detection adds cross-domain quality at $0. Cloud LLM only when needed.
3. 5x fewer LLM calls — 0-1 calls per episode vs Graphiti's 5. Same quality, fraction of the cost.
4. Runs on a laptop GPU — Gemma 3n E4B fits in 3.8GB VRAM (RTX 4050), scores 7.6/10 on cross-domain extraction.
5. Bi-temporal history — Only ctxgraph and Graphiti have this. Every other tool is current-state only.
6. PII protection — CloakPipe strips PII before cloud LLM calls (--features cloakpipe). No competitor offers this.
7. Single Rust binary — Every competitor is Python with pip/Docker/Neo4j. ctxgraph is cargo install.

Benchmarks

Real-World Extraction (GPT-4o judge, 20 random texts, 10-point scale)

LLM Model Comparison (10 random texts, GPT-4o judge)

Schema-Typed Extraction (50 tech-domain episodes, F1 scores)

Query Performance

Key Features

• Tiered extraction — Local ONNX first → Ollama auto-detected → Cloud LLM fallback
• Auto-schema inference — Domain-specific entity/relation types inferred from first 3 episodes
• Privacy — CloakPipe strips PII before cloud LLM calls (enable with --features cloakpipe)
• Zero infrastructure — One binary, one SQLite file. No Docker, no Neo4j
• Ollama auto-detection — Finds local Ollama and picks the best model automatically
• Any LLM — Ollama (Gemma 3n/4), OpenRouter, OpenAI, Anthropic
• Bi-temporal — Time-travel queries, fact invalidation
• Schema-driven — Auto-inferred or manual via ctxgraph.toml
• MCP server — Claude Code, Cursor, Cline, any MCP client
• Embeddable — Rust library, CLI, or MCP server
• Entity dedup — Jaro-Winkler + alias table across episodes

Installation

# Homebrew
brew install rohansx/tap/ctxgraph

# Or build from source (Rust 1.85+)
cargo install ctxgraph-cli

Quick Start

ctxgraph models download              # one-time ONNX model download
ctxgraph init                         # initialize graph in current dir
ctxgraph log "Alice chose PostgreSQL"  # extract + store
ctxgraph query "why PostgreSQL?"       # search the graph

Optional: Local LLM for cross-domain quality

# Install Ollama + Gemma 3n E4B (one-time, 7.5GB download)
ollama pull gemma3n:e4b

# ctxgraph auto-detects Ollama — no config needed!
# You'll see: [ctxgraph] Ollama detected with model 'gemma3n:e4b' (local, free)

Optional: Cloud LLM for maximum quality

# ctxgraph.toml
[llm]
provider = "openrouter"
model = "google/gemma-4-26b-a4b-it"   # 8.4/10 quality, $0.13/1M tokens
api_key_env = "OPENROUTER_API_KEY"

Auto-schema inference

No need to define entity types manually. After 3 episodes, ctxgraph automatically infers domain-specific types:

ctxgraph log "Pfizer's Ozempic generated $28B revenue..."
ctxgraph log "FDA approved Casgevy gene therapy..."
ctxgraph log "NHS launched Federated Data Platform by Palantir..."
# [ctxgraph] Schema inferred: domain='Healthcare', 9 entity types, 10 relation types
# Saved to .ctxgraph/schema.toml — all future extractions use this schema

MCP Server

{
  "mcpServers": {
    "ctxgraph": { "command": "ctxgraph-mcp" }
  }
}

Rust SDK

let graph = ctxgraph::Graph::init(".ctxgraph")?;
graph.add_episode(Episode::builder("Chose Postgres for billing").build())?;
let results = graph.search("why Postgres?", 10)?;

Project Structure

crates/
+-- ctxgraph-core/       Types, storage, query, temporal
+-- ctxgraph-extract/    Tiered extraction (ONNX + LLM)
+-- ctxgraph-embed/      Local embeddings
+-- ctxgraph-cli/        CLI binary
+-- ctxgraph-mcp/        MCP server
+-- ctxgraph-sdk/        Rust SDK

Contributing

See CONTRIBUTING.md.

License

MIT