Remote MCP · Codebase context without burning tokens

Give your agentthe code that matters, nothing more

Q: How do I get the free quota?

Sign in with GitHub and the free plan activates automatically. Quota resets every cycle. No credit card required.

Agents can't read your whole repo, and they shouldn't gamble on grep — or burn tokens re-reading files they've already seen. Context Engine builds a hybrid index of your codebase in the cloud; every question runs three retrieval paths in parallel, reranks and dedupes, then returns a file-level context pack within the token budget you set. Your agent sees a single MCP tool — setup is one config block.

See how it works

Claude Code · Cursor · any MCP client / free quota on signup

▊ codebase_context — livelistening

❯

src/session.ts0.94
src/auth/jwt.ts0.87
src/db/user.ts0.00
src/api/login.ts0.81
src/middleware/rate.ts0.00
src/utils/hash.ts0.00
src/config.ts0.00

→ context pack0 / 8,000 tokens

$ stats --live

0tool

One MCP tool wraps indexing and retrieval

0paths

Semantic + keyword + symbol graph, in parallel

0+ languages

tree-sitter AST parsing and chunking

spanlevel

Trimmed precisely to your token budget

> cat ./setup.json # Setup

One config block, and your agent can see

Drop this JSON into your MCP client config. codebase_context handles the rest.

{
  "mcpServers": {
    "context-engine": {
      "command": "npx",
      "args": ["-y", "@code-context-engine/mcp@latest"],
      "env": {
        "CONTEXT_ENGINE_REMOTE_API_KEY": "<cek_ key>"
      }
    }
  }
}

> ls ./why-context-engine/ # Why Context Engine

Retrieval quality is the ceiling on agent quality

What lands in the context window decides whether your agent edits the right place. We treat retrieval as a core engineering problem — not a single embedding lookup.

--access

One tool, ready on connect

Your agent sees exactly one MCP tool: codebase_context. Incremental file sync, remote indexing, retrieval, and the feedback loop are all wrapped inside — one JSON block and you're in.

--recall

Hybrid retrieval + symbol graph

Semantic vectors and keyword search recall in parallel, while a cross-language symbol graph expands along call relationships. Reranked and grouped by file — closer to "the code that matters" than embeddings or grep alone.

--budget

Trimmed to your token budget

Every response stays within the token budget you set, trimmed at span level with scores and hit sources attached. No more blowing up your agent's context window.

--sync

Incremental sync in seconds

The client diffs a content-hash manifest and uploads only changed files; the server rebuilds the index incrementally. Editing one file never means reindexing the repo.

--parse

AST-level code understanding

tree-sitter parses 12+ languages — TypeScript, Python, Go, Rust, Java and more — chunking along function and symbol boundaries instead of blind line splits.

--feedback

A feedback-driven quality loop

Agents can rate every result. Feedback accumulates into eval sets and training data, so retrieval quality keeps improving with use.

> sh ./pipeline.sh # How it works

Three steps from local repo to precise context

01 · Sync [OK]

Incremental local upload

The MCP client scans your repo, computes a manifest, and uploads only new or changed files. After the first sync, daily edits land in seconds.

02 · Index [OK]

Hybrid index in the cloud

The server does AST chunking, vectorization, keyword indexing, and symbol graph construction. The index lives remotely — shared by your team and every agent.

03 · Retrieve [OK]

Your agent just asks

The agent calls codebase_context with a natural-language question and gets back a context pack grouped by file, with scores and hit spans.

> cat ./security-boundary.md # Data boundaries

Your code, clearly fenced

Tenant-isolated workspaces

Each API key maps to its own workspace. Repos, indexes, and usage are invisible across tenants.

Rotate keys anytime

Generate a new key in one click; the old one dies instantly. Keys are shown exactly once, at creation.

Delete means gone

Deleting a project stops service immediately and voids remaining quota. Data is cleaned up per retention policy.

Path and size double-checked

Uploads are verified by content hash and path boundary checks. The server rejects anything that steps outside.

> ./billing --plans # Pricing

Subscriptions, metered by retrieval calls

30-day cycles, quota resets automatically. Only the call that hands your agent a context pack counts — file sync, indexing, and feedback are free.

--plan=Free

Auto-enabled on sign-in. Kick the tires first.

$0per month, on signup

50 retrieval calls per month
Unlimited repos, free incremental sync
Hybrid retrieval + symbol graph expansion
Dedicated workspace, tenant isolation

--plan=Pro

The daily driver for individual developers

$5/ month, cancel anytime

500 retrieval calls per month
Unlimited repos, free incremental sync
Hybrid retrieval + symbol graph expansion
Dedicated workspace, tenant isolation

Billing and data, answered

What counts as a billable call?

Only the codebase_context call that actually delivers a context pack to your agent. File sync, index builds, and quality feedback are all free and never touch your quota.

How do I get the free quota?

Which coding agents are supported?

Any MCP-capable client: Claude Code, Cursor, Windsurf, and more. The setup is one standard MCP JSON block.

Where does my code live? Is it safe?

Your index lives in a dedicated workspace, fully isolated from other tenants. Rotate API keys anytime; deleting a project stops service immediately and data is cleaned up per retention policy.

What happens when I run out of quota?

Retrieval calls return an explicit out-of-quota error (HTTP 402) — your agent never silently gets empty results. Upgrade your plan or wait for the next cycle's reset.

Does it handle large repos and monorepos?

Yes. After the first sync everything is incremental: the client uploads only changed files by content hash, and the server rebuilds the index incrementally. One edited file never triggers a full reindex.

How is this better than grep or plain embeddings?

Three retrieval paths — semantic vectors, keywords, symbol graph — cover each other's blind spots, then results are reranked, deduped, grouped by file, and trimmed at span level. Every result carries a score and hit source: explainable, and improvable through feedback.

$ Get started

Five minutes to give your agent new eyes

Free quota with GitHub sign-in. Setup is one MCP config block.