Code Context Engine

[Code Context Engine]

Code Context Engine

Index your codebase. AI searches instead of re-reading files.
94% token savings, reproducibly benchmarked.

Website · Docs · Why CCE? · Benchmark · GitHub

[PyPI] [Downloads] [CI] [MCP Registry] [MIT License] [Stars]

_{Python 3.11+ · macOS · Linux · Windows}

[Claude Code]  [VS Code]  [Cursor]  [Gemini CLI]  [Codex CLI]  [OpenCode]  [Tabnine]  [Pi]

_{One command. Auto-detects your editor. Zero cloud, zero config.}

[CCE Demo]

[Talk: We Cut 94% of Our AI Coding Tokens — AI Engineer World's Fair 2026]
_{Talk: We Cut 94% of Our AI Coding Tokens — AI Engineer World's Fair 2026}

Use cases

Quick start

One command. 30 seconds.

uvx --from "code-context-engine[local]" cce init    # install + index + configure, one shot

Or if you prefer a persistent install:

uv tool install "code-context-engine[local]"    # or: pipx install "code-context-engine[local]"cd /path/to/your/projectcce init

Restart your editor. Done. Every question now hits the index instead of re-reading files.

Agent Plugin support: Run cce init --plugin to generate a portable Agent Plugin directory that works with VS Code, Cursor, Copilot, Codex, ChatGPT, and Kiro. The plugin uses uvx to launch CCE on demand, so users don't need to pre-install the Python package. See Agent Plugin below.

Already have Ollama? Skip [local] and use uv tool install code-context-engine instead. CCE auto-detects Ollama at localhost:11434 and uses nomic-embed-text.

cce init auto-detects your editor and writes the right config. To target a specific agent, use --agent claude, --agent codex, --agent copilot, --agent pi, or --agent all.

Multiple editors in the same project? All get configured in one command.

Codex note: Codex CLI reads MCP servers from ~/.codex/config.toml only — it has no per-project config. cce init adds one [mcp_servers.cce-<project>-<hash>] section per project so multiple projects coexist; cce uninstall removes only the section for the current project.

Pi note: Pi does not support MCP natively. To use CCE with Pi, you need a pi MCP adapter extension (e.g. pi-mcp-adapter) that consumes the .mcp.json config and exposes CCE's tools to the Pi agent. cce init sets up both .mcp.json and AGENTS.md (Pi loads the latter automatically for startup instructions).

  my-project · 38 queries · last query 5m ago
  ⛁ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶  88% tokens saved
  Input savings   1.9M  tokens   $27.78  Output savings  4.8k  tokens   $0.36  ──────────────────────────────────────────  Total saved   1.9M  tokens   $28.15
  Breakdown:    retrieval              84%  ▰▰▰▰▰▰▰▰▰▰    1.8M   $26.76 · 12 calls    chunk compression       3%  ▰▱▱▱▱▱▱▱▱▱   68.5k    $1.03 · 12 calls    output compression*    <1%  ▰▱▱▱▱▱▱▱▱▱    4.8k    $0.36 · 12 calls
  Cost estimate based on Opus pricing (input $15.0/1M, output $75.0/1M)

Supports Anthropic, OpenAI, and Google model pricing. Configure via pricing.model in ~/.cce/config.yaml.

Why this matters

Input tokens are 85-95% of your Claude Code bill. CCE cuts them by 94% (benchmarked on FastAPI).

Without CCE:    Claude reads payments.py + shipping.py   = 45,000 tokensWith CCE:       context_search "payment flow"            =    800 tokens

Benchmark: FastAPI (reproducible)

We benchmarked CCE against FastAPI (53 source files, 180K tokens) with 20 real coding questions. No cherry-picking, no synthetic queries.

Methodology: For each query, "without CCE" means reading the full content of every file the query touches. "With CCE" means the relevant chunks after compression.

Important baseline note: The 94% number is measured against full-file reads, not against what Claude Code actually does. In practice, Claude Code already uses grep, partial file reads, and targeted tools, so the real-world savings compared to normal Claude Code behavior will be lower than 94%. We use full-file as the baseline because it's reproducible and deterministic (no agent behavior variability). The benchmark measures CCE's retrieval efficiency, not a head-to-head comparison with Claude Code's built-in exploration.

Per-Layer Savings (each measured independently)

Output compression (reducing Claude's reply length) provides additional savings (~65% estimated) but is not included in the headline number above.

Multi-language benchmarks

Django (2,347 files, 5.4M tokens) shows CCE scales to large codebases with 0.95 recall. Go's shorter files reduce the retrieval headroom (smaller baseline). Monorepos dilute recall at top-10 (fiber). Middleware queries with one-feature-per-file hit R=1.00 consistently.

Reproduce it yourself:

pip install code-context-enginepython benchmarks/run_benchmark.py --repo https://github.com/fastapi/fastapi.git --source-dir fastapipython benchmarks/run_benchmark.py --repo https://github.com/go-chi/chi.git --source-dir .

Full results in benchmarks/results/. Queries and methodology in benchmarks/.

What you get

11 MCP tools that Claude uses automatically:

Live dashboard with donut charts, file health, and session history:

cce dashboard

[CCE Dashboard]

Dollar estimates with multi-provider pricing (Anthropic, OpenAI, Google):

cce savings --all    # see savings across all projects

How it works

1. Index: Tree-sitter parses your code into semantic chunks (functions, classes, modules). Stored as vector embeddings locally.
2. Search: Claude calls context_search. Hybrid vector + BM25 retrieval finds the right chunks. Code graph adds related files automatically.
3. Compress: Chunks are truncated to signatures + docstrings (or LLM-summarized if Ollama is running).
4. Remember: Decisions and code areas persist across sessions via session_recall.
5. Track: Every query is logged. cce savings shows exactly how much you saved.

Re-indexing after edits takes under 1 second (96% embedding cache hit rate). Git hooks keep the index current automatically.

What makes CCE different

It saves where the money is

Output compression tools (like Caveman) save 20-75% on output tokens. Output is 5-15% of your bill. Net savings: ~11%.

CCE saves on input tokens (94% retrieval savings on FastAPI, reproducibly benchmarked). Input is 85-95% of your bill.

It actually understands your code

Not a text search. Tree-sitter AST parsing creates semantic chunks. Hybrid retrieval merges vector similarity with BM25 keyword matching via Reciprocal Rank Fusion. A confidence scorer blends similarity (50%), keyword match (30%), and recency (20%). Graph expansion walks CALLS/IMPORTS edges to pull in related code.

It remembers

record_decision("use JWT for auth", reason="session tokens flagged by legal") is stored in SQLite and surfaces via session_recall in the next session. No re-explaining your architecture.

It tracks real savings

Not estimates. Actual tokens served vs full-file baseline, broken down by buckets (retrieval, compression, output, memory, grammar). Dollar costs fetched from Anthropic's pricing page. Savings summary shown at every session start.

It is secure by default

Secret files (.env, *.pem, credentials.json) are never indexed. Content is scanned for AWS keys, GitHub tokens, Slack tokens, Stripe keys, JWTs, and generic credentials. PII (emails, IPs, SSNs, credit cards) is scrubbed from memory writes. All MCP file paths are validated against path traversal.

Under the hood

Agent Plugin

Agent Plugins is an open standard (v1.0.0) backed by Amazon, Cursor, Microsoft, OpenAI, and Vercel for packaging AI skills and MCP servers into portable, zero-install bundles. CCE can generate a plugin directory that compatible editors can discover and load automatically.

cce init --plugin                          # Generate at .cce/plugin/cce init --plugin --plugin-dir ~/plugins/cce  # Custom locationcce init --agent claude --plugin           # Both: agent config + plugin

What gets generated

.cce/plugin/├── plugin.json                       # Agent Plugins v1.0.0 manifest├── mcp.json                          # MCP server config (uvx + stdio)├── skills/│   └── code-context/│       ├── SKILL.md                  # Agent instructions (frontmatter + body)│       └── references/│           └── tools.md              # Per-tool parameter docs (loaded on demand)└── LICENSE

Compatible editors

VS Code, GitHub Copilot, ChatGPT, Codex, Cursor, and Kiro. The plugin uses uvx to launch CCE on demand, so users do not need to pre-install the Python package. The MCP server auto-discovers the project root by walking up from its working directory, looking for .context-engine.yaml or .git/.

When to use --plugin vs --agent

Both can be used together. --agent handles per-editor MCP config, --plugin provides a portable alternative.

CLI at a glance

cce init                    # Index + install hooks + register MCPcce init --plugin           # Generate Agent Plugin for VS Code, Cursor, etc.cce                         # Status bannercce savings                 # Token savings with dollar estimatescce savings --all           # All projectscce dashboard               # Web dashboard with live chartscce search "auth flow"      # Test a querycce status                  # Index health + configcce services                # Ollama + dashboard + MCP statuscce commands add-rule '...' # Project rules for Claudecce uninstall               # Clean removal of all CCE artifacts

Run cce list for the full command reference.

Configuration

Zero-config by default. Override what you need in ~/.cce/config.yaml or .context-engine.yaml:

compression:  level: standard          # minimal | standard | full  output: standard         # off | lite | standard | max  ollama_url: http://localhost:11434   # point at a remote Ollama if desired
retrieval:  top_k: 20  confidence_threshold: 0.5
pricing:  model: opus              # opus | sonnet | haiku | gpt-4o | gemini-2.5-pro | ...  # input: 15.0            # override $/1M input tokens  # output: 75.0           # override $/1M output tokens

Remote Ollama: If you run Ollama on another machine in your network, set compression.ollama_url (e.g. http://nas.local:11434) or export CCE_OLLAMA_URL (the env var wins). CCE probes the endpoint and falls back to truncation-only compression when it's unreachable, so a flaky link won't break indexing.

Output Compression

CCE also compresses Claude's responses (same concept as Caveman):

Tell Claude: "switch to max compression" or "turn off compression". Code blocks and commands are never compressed.

Disk Footprint

No GPU required. With Ollama, embeddings are handled by the Ollama server. With the [local] extra, the embedding model runs on CPU via ONNX Runtime.

Supported Languages

AST-aware chunking (tree-sitter parsed, 11 extensions):

Language-aware fallback chunking (40+ extensions):

All other text files are chunked by line range. Binary files are skipped.

Documentation

FAQ

Does CCE affect response quality?

No. Quality stays the same or slightly improves.

CCE replaces "dump the entire file" with "search for the relevant function." The model still gets the code it needs (0.90 Recall@10 in benchmarks). Less irrelevant context means less noise competing for attention, which can improve the model's focus on your actual question.

How does output token savings work?

CCE writes output compression rules directly into your agent's instruction files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) during cce init. These rules apply to the entire session, not just CCE tool responses, so every reply from the agent follows them.

Set the level in ~/.cce/config.yaml or .context-engine.yaml:

compression:  output: max       # off | lite | standard | max

Then re-run cce init to update instruction files. Or change at runtime:

set_output_level output_level=max

Default is standard. All levels include code output rules that tell the model to show only changed lines (not full file rewrites), which is where most output tokens go in coding sessions. The max level produces very terse prose (similar to "caveman mode"). Code blocks, paths, and commands are never compressed regardless of level.

Where do the savings come from?

Most savings are input tokens (what goes into the model):

Output tokens cost 5x more per token (e.g. Opus: $15/1M input vs $75/1M output), so even a small output reduction has outsized cost impact.

Roadmap

• Multi-repo benchmarks (FastAPI, chi, fiber)
• More benchmarks (Django, Express)
• Tree-sitter support for C, C++, Ruby, Swift, Kotlin
• Docker support for remote mode
• Port to mcp 2.x API

See CHANGELOG.md for shipped features.

Contributing

Contributions welcome. See https://github.com/elara-labs/code-context-engine/blob/main/CONTRIBUTING.md for setup.

License

MIT. See LICENSE.

Authors

• Fazle Elahee
• Raj

Acknowledgments

Claude Code · MCP · sqlite-vec · Tree-sitter · fastembed · Ollama

If CCE saves you tokens, give it a star.