Built for Continue · MCP-native

Ask Continue anything about your repo. Get exact files and lines back.

Local semantic search, editor state, and git history — piped into Continue over MCP. Nothing leaves your machine.

Get Brogrammer See how it works

7-day free trial · No credit card · JetBrains & VS Code

brogrammer · Continue · my-app/indexed · 12,481 symbols

You

Where do we validate coupon codes on checkout, and what tests cover it?

codebase-retrievalquery: "validate coupon checkout"124ms · 3 files

Continue

Coupon validation lives in src/billing/coupons.ts:84 — validateCoupon()checks expiry, usage cap, and user eligibility. It's called from src/api/checkout.ts:142 before the Stripe charge, and from src/admin/preview-order.ts:38 in the admin preview flow. Covered by 6 tests in tests/billing/coupons.spec.ts.

src/billing/coupons.ts· line 84

validateCoupon()

src/api/checkout.ts· line 142

calls validator pre-charge

src/admin/preview-order.ts· line 38

admin preview flow

tests/billing/coupons.spec.ts· 6 passing

expiry · cap · eligibility

Works with the agents and IDEs your team already uses

The problem

AI agents are powerful. On real codebases, they're blind.

Your IDE already knows everything — symbols, references, errors, git history. Without that context, even the best model answers like a stranger reading your code for the first time.

Greps blindly through every file
No index, no semantics. The agent burns the whole context window scanning files it doesn’t need to.
Imports functions that don’t exist
It invents symbol names, fabricates call signatures, and confidently suggests code that won’t compile.
Starts from zero every session
Nothing persists between chats. The architecture has to be re-explained every time you open a new conversation.
Burns tokens on files it didn’t need
Every dead-end grep, every re-read, every hallucinated path costs tokens. On Claude Opus, that bill adds up fast.

ai-agent · no context

You

Where do we validate the checkout coupon?

Agent

Typically, coupon validation lives in a checkout/ or billing/module…

grep "coupon"grep "validate"…no matches

function applyCoupon(code) {

// ???

return undefined;

}

Hallucinated

No repo context

How it works

A local MCP server that actually knows your code.

Brogrammer runs inside your IDE, indexes your repo with local embeddings, and exposes tools your AI agent can call. No cloud, no uploads, no latency.

Your IDE

JetBrains / VS Code

Active file & cursor
Project tree & open tabs
Terminal & run output

Brogrammer

Local MCP server

Semantic index (local embeddings)
12 tools over stdio
Runs on your machine only

Your AI agent

Claude Code, Cursor, Continue…

Calls MCP tools via stdio
No cloud indexing required
Works with any MCP client

Your agent

Where do we validate coupon codes on checkout?

Semantic index

500K chunks · hybrid

Symbol graph

cross-file refs

Editor state

cursor · open tabs

Git history

blame · diffs

Cited answer

src/billing/coupons.ts:84

src/api/checkout.ts:142

57,200 tokens streamed · cache hit on retry

One agent query · four local sources · one context packet · zero cloud calls

Step 1

Index

On first run the plugin walks your repo and builds local embeddings. Nothing is uploaded — the index lives on disk next to your project.

Step 2

Expose

Brogrammer launches a local MCP server that advertises 12 tools over stdio. One line of JSON in your agent’s config and you’re connected.

Step 3

Call

When you ask a question, the agent picks the right tools. Instead of hallucinating, it searches, reads, and runs — all locally.

Step 4

Cite

Answers come back grounded in real code, with exact file paths and line numbers. Every claim is verifiable in one click.

The tools your agent gets

12 tools, all local

codebase-retrievalSemantic search across the repo

viewRead any file with line ranges & regex

editor-stateActive file, selection, cursor, errors

git-contextBlame, diffs, branch, recent commits

run-testsExecute tests & surface failures

edit-fileStructured edits with review

Features

Everything your agent needs to think like a teammate.

Twelve MCP tools, one install. Semantic search, editor state, git history, memories, rules, code review — all running locally inside your IDE.

Find code by meaning

Semantic search across the whole repo. Find the code that handles "retry logic" or "session restore" even if those words never appear.

Understand the whole system

Cross-file references, call chains, and related code surface automatically. No more grep loops or hallucinated file names.

Knows what you’re looking at

The agent sees your current file, cursor position, selection, and open tabs — so "fix this" and "refactor this" actually work.

Real IDE errors as context

JetBrains inspections and VS Code problems pipe straight into the agent. Catch real issues, not guesses.

Git-aware by default

Recent commits, blame, diffs, and branch context — so the agent knows what changed and why.

Agent-agnostic

Claude Code, Cursor, Continue, or any MCP-compatible client. No lock-in. Swap agents without losing context.

Token efficiency

Claude Opus charges by the token. Brogrammer tells it exactly where to look.

We can't promise you a specific percentage yet — the measured numbers land in the benchmark section below. But here are the three mechanisms that make it work, all verifiable in the plugin source.

One call, not ten.

codebase-retrieval returns up to 80 ranked symbols in a single round-trip. Your agent stops looping grep → read → grep.

Measurable in MCP call count

Budgeted context.

Hard caps at ~57K tokens per query and 15 full bodies — no whole-file dumps, no context-window blowouts.

Enforced in toolDefs.ts

Cache-friendly by design.

Stable prompt layout hits Anthropic's prompt cache. Expect cache_read_input_tokens > 0 from the 2nd tool call — up to ~90% off on repeated reads.

Per Anthropic docs

Zero extra LLM spend from Brogrammer itself — the plugin injects context, it doesn't generate text.

Built for Continue users

Continue is open. Give it production-grade context.

Continue is the flexible open-source agent that already speaks MCP — but its out-of-the-box context is scoped to a handful of files. Brogrammer plugs in as a local MCP server so Continue sees the whole repo, your editor state, and your git history, all without leaving the machine.

Continue without Brogrammer

Generic answers. Dead ends. Constant copy-paste.

Continue only

You

Where do we handle Stripe webhook retries?

Continue

I don’t have visibility into your codebase from here. Typically, Stripe webhooks are handled in a route like /api/webhooks/stripe. You’d want to check the webhook signature and implement idempotency using the event ID…

You

Can you just find it for me?

Continue

I can’t search your repo directly. Try grep’ing for "stripe" or "webhook" and paste the relevant file in.

Continue with Brogrammer

Deep repo awareness. Cites files, lines & tests.

With Brogrammer

You

Where do we handle Stripe webhook retries?

Continueused codebase-retrieval

Retries are handled in site/backend/src/billing/webhooks.ts:42 — handleStripeEvent() checks processedEvents by event.id (Postgres unique index) and returns 200 early on duplicates. Failed events are pushed to the stripe_retry_queue job and retried with exponential backoff up to 6 times.

You

Show me the idempotency check.

Continueused view

Here it is — lines 58–72 of webhooks.ts. Want me to walk through the retry queue too, or check for related tests in webhooks.test.ts?

Semantic search across your repo

Live editor + cursor context

Git history & diff awareness

Install in 2 minutes.

Connect Brogrammer to Claude Code, Cursor, or any MCP agent — and watch it cite actual files from your repo. 7-day free trial. No credit card.

Get Brogrammer Read the docs

Developer feedback

“I stopped copy-pasting stack traces into Claude. It just knowsthe repo now — cites the exact function, the test that covers it, and the commit that last touched it. It's the first MCP tool I've kept installed past the weekend.”

Early beta tester

Staff engineer · 2M-LOC Go monorepo

Placeholder quote. Replace with a real named testimonial post-launch.

Compared

Built for real codebases, not toy demos.

Copilot and Cursor bring their own cloud retrieval. Claude Code and Continue speak MCP but ship without repo-deep context. Brogrammer is the missing local context engine either camp can plug into.

Capability	Copilot	Cursor	Claude Code	Continue
Local-only code analysis	—	—	—	Partial
Semantic search across repo	—	Partial	—	Partial
Editor state + cursor context	Partial		—
Git history as context	—	—	—	—
IDE inspections as context	—	—	—	—
Agent-agnostic (any MCP client)	—	—	—	—
Source never leaves your machine	—	—	—	Partial

Claude Code & Continue columns reflect out-of-the-box behaviour without an MCP context server attached. Brogrammer extends both.

Privacy by design

Your code never leaves your machine.

Unlike Cursor, Copilot, or Augment, Brogrammer does not upload your source code — not for indexing, not for search, not for anything. Semantic embeddings run locally via Ollama. The only data we see is your email and subscription status.

No cloud indexing — ever
Local embeddings via Ollama (or your GPU)
Open protocol (MCP) — inspect every call
Self-hosted by design — your security review is the IDE itself

Read the privacy guarantee

Data leaving your machine

Source codeNever
File pathsNever
EmbeddingsNever
Prompts / queriesNever
Git historyNever
Email (auth only)Yes, encrypted
Subscription statusYes, encrypted

Is it for you?

Built for real codebases. Honest about the edges.

Brogrammer shines when your repo is too big to paste into a chat. If yours isn't there yet, that's fine — here's a straight answer either way.

You’ll get value if

Engineers shipping on large, long-lived codebases

Teams already using Claude Code, Cursor, or Continue seriously

Anyone tired of copy-pasting files into a chat window

Privacy-constrained orgs where source code can’t leave the laptop

Probably skip it if

You’re on a greenfield project that fits in one prompt

You live in autocomplete and don’t use an agent loop

You want a cloud-indexed assistant with a hosted chat UI

You’re shopping for a model — Brogrammer adds context, not a brain

Quick start

Three minutes from install to useful.

1. Install the plugin

One-click install from the JetBrains Marketplace or VS Code Marketplace. Sign in with a magic link — no passwords.

2. Point your agent at it

Brogrammer exposes a local MCP server. Claude Code, Cursor, or any MCP client connects in one line of config.

3. Ship with real context

Ask questions, refactor, debug. The agent sees your repo the way you do — instantly, locally, and privately.

# ~/.continue/config.yaml

mcpServers:
  - name: brogrammer
    command: brogrammer
    args:
      - --stdio

FAQ

Questions, answered up front.

Short versions below. The docs go deeper on every one.

Does my code leave my machine?

No. Indexing, retrieval, and git history reads all run locally on your machine. Only the final prompt your agent sends (which you control) goes to the LLM provider you already use.

Which agents / IDEs are supported?

Any MCP-compatible agent — Claude Code, Cursor, Continue, Windsurf, and others. IDE plugins ship for JetBrains (IntelliJ / PyCharm / WebStorm / GoLand / Rider) and VS Code.

How is this different from grep or the built-in IDE search?

Brogrammer returns ranked symbols(functions, classes, tests) with their bodies and call sites — not raw line matches. It's built on a local tree-sitter index + embeddings, so "where do we validate coupons?" finds the right function even if that word never appears in the file.

Will it slow down my IDE?

The initial index is incremental and runs in a background worker. On a 100k-line repo, first-index completes in <60s; subsequent updates are sub-second. Memory footprint is capped at ~300MB regardless of repo size.

Does it work on private / monorepo codebases?

Yes. Designed for large private monorepos first — the retrieval tool has bounded token budgets specifically so it stays useful past 1M LOC. Works offline, no SaaS account required to run the plugin.

What does it cost, and what does the free trial include?

7-day Pro trial with every feature enabled, no credit card. After that, the personal tier stays free for individual use; paid plans unlock team sharing, SSO, and audit logs. See the pricing page.

Install in 2 minutes.

Connect Brogrammer to Claude Code, Cursor, or any MCP agent — and watch it cite actual files from your repo. 7-day free trial. No credit card.

Get Brogrammer Read the docs

Starts at $12/mo · 7-day free trial · No credit card to start