Local-first context engine for AI coding agents

74% fewer tokens.
100% on your machine.

vexp gives your AI agent only the code that matters — via a local dependency graph with session memory. No cloud. No account. No data leaves your laptop.

›
On mobile? Get the install links by email.

One-time email with install links. No spam.

Works with
Claude Code
Cursor
Windsurf
Copilot
Continue.dev
Zed
Augment
Codex
Opencode
Kilo Code
Kiro
Antigravity
“I spend $400-600 a month on tokens. Any savings I can get is always sought after.”
Power user
1,000+ downloads12 AI agents supported
The problem

AI agents read everything. They understand nothing.

Every coding session starts the same: the agent scans files, guesses dependencies, and fills your context window with code it will never use. Cloud-based context engines solve this — but send your code to their servers.

Without vexp
8,247tokens
import { authenticate } from "./auth"
import { RateLimiter } from "./limiter"
import { db } from "./database"
import { logger } from "./logger"
import { config } from "./config"
import { User } from "./types/user"
import { Session } from "./types/session"
import { CacheService } from "./cache"
export async function middleware(req, res, next) {
const token = req.headers.authorization
if (!token) return res.status(401).json({ error: "Unauthorized" })
try {
const user = await authenticate(token)
req.user = user
logger.info(`Request from ${user.id}`)
next()
} catch (err) {
logger.error("Auth failed:", err)
res.status(401).json({ error: "Invalid token" })
}
}
 
export class RateLimiter {
private redis: Redis
private limits: Map<string, number>
 
constructor(config: RateLimitConfig) {
this.redis = new Redis(config.redisUrl)
this.limits = new Map(Object.entries(config.limits))
}
 
async check(key: string): Promise<boolean> {
const count = await this.redis.incr(key)
const limit = this.limits.get(key) ?? 100
return count <= limit
}
}
import { authenticate } from "./auth"
import { RateLimiter } from "./limiter"
import { db } from "./database"
import { logger } from "./logger"
import { config } from "./config"
import { User } from "./types/user"
import { Session } from "./types/session"
import { CacheService } from "./cache"
export async function middleware(req, res, next) {
const token = req.headers.authorization
if (!token) return res.status(401).json({ error: "Unauthorized" })
try {
const user = await authenticate(token)
req.user = user
logger.info(`Request from ${user.id}`)
next()
} catch (err) {
logger.error("Auth failed:", err)
res.status(401).json({ error: "Invalid token" })
}
}
 
export class RateLimiter {
private redis: Redis
private limits: Map<string, number>
 
constructor(config: RateLimitConfig) {
this.redis = new Redis(config.redisUrl)
this.limits = new Map(Object.entries(config.limits))
}
 
async check(key: string): Promise<boolean> {
const count = await this.redis.incr(key)
const limit = this.limits.get(key) ?? 100
return count <= limit
}
}
context budget81% used
With vexp
2,140tokens
● pivotmiddleware/auth.ts
export async function authenticate(token: string): Promise<User>
export async function middleware(req, res, next): Promise<void>
○ skeletonservices/cache.ts
class RateLimiter
check(key: string): Promise<boolean>
reset(key: string): Promise<void>
○ skeletonconfig/limits.ts
export const rateLimits: Record<string, number>
● pivotmiddleware/auth.ts
export async function authenticate(token: string): Promise<User>
export async function middleware(req, res, next): Promise<void>
○ skeletonservices/cache.ts
class RateLimiter
check(key: string): Promise<boolean>
○ skeletonconfig/limits.ts
export const rateLimits: Record<string, number>
context budget21% used
74%
fewer tokens per query

Not an optimization. A structural repair — entirely on your machine.

On mobile? Get the install links by email.

One-time email with install links. No spam.

Interactive demo

See it work.

Three scenarios. Real MCP tool calls. Token savings calculated.

MCP Tool Call
// Claude Code \u2192 vexp
tool: "run_pipeline"
task: "fix JWT validation bug"
preset: "auto"
vexp Output
● pivotauth/jwt.ts
280 lines
export function validateToken(token: string): JWTPayload
→ impactmiddleware/auth.ts
12 lines
3 callers · 2 cross-file dependents
◎ memorysession #4 · 2h ago
1 lines
"JWT chosen over sessions — see decision #12"
tokens used
1,640
tokens saved
7,360
latency
56ms
82% saving
How it works

Graph-native context. Deterministic. Local. Zero network calls.

01

Index

Parse. Graph. Persist.

vexp uses tree-sitter to parse your codebase into an AST, then builds a dependency graph: nodes for functions, classes, and types; edges for calls, imports, and implementations. Stored in local SQLite — never uploaded, never shared. 5,000 files indexed in under 15 seconds.

.vexp/index.db (local) + manifest.json (git) — 34.8k nodes | 89.2k edges
< 15sfull index
02

Traverse

Hybrid search + graph centrality.

When an agent queries a task, vexp runs hybrid search — FTS5 full-text matching combined with TF-IDF semantic similarity — to find candidate pivot nodes, then ranks them using graph centrality. Intent detection auto-selects the search strategy: 'fix bug' triggers debug mode, 'refactor' triggers blast-radius mode. No embeddings. No external API. No hallucination.

FTS5 + TF-IDF → 423 candidates → intent: debug → centrality rank → top 12 pivots
< 500msP95 query
03

Capsule

Pivots in full. Scaffolding skeletonized.

Pivot nodes are returned with full source. Adjacent nodes are reduced to signatures, docstrings, and return types — no implementation bodies. The capsule is bounded to your token budget. Exact context, nothing more.

pivot: 350 lines → skeleton: 8 lines (97.7% reduction)
70-90%skeleton reduction
Architecture
AI Agents
Claude Code
Cursor
Windsurf
Copilot
Continue.dev
+ 7 more
MCP Protocolstdio / HTTP
vexp-mcp
TypeScript · Node.js
11 MCP tools
Session memory dispatch
Tool schema validation
Bundled in VSIX
Unix socket/ Named pipe
vexp-core
Rust daemon
Indexer (tree-sitter)
Graph engine (petgraph)
Skeletonizer (AST)
SQLite persistence
File watcher (.gitignore-aware)
.vexp/index.db (gitignored)
.vexp/manifest.json (git)
Smart Features
v1.2
Intent Detection

run_pipeline auto-detects intent from your task description. "fix bug" activates debug mode (follows error paths), "refactor" triggers blast-radius mode, "add feature" uses modify mode.

Hybrid Search

Combines FTS5 keyword matching with TF-IDF semantic similarity and graph centrality. Finds validateCredentials when you search for "authentication" — no embeddings required.

LSP Bridge

VS Code captures type-resolved call edges from the language server for high-confidence call graphs. Supplements tree-sitter static analysis with runtime type information.

Feedback Loop

Repeated queries with similar terms automatically expand the result budget. The engine learns your session focus and returns progressively broader context.

Session Memory

Auto-captures every tool call (< 1ms overhead). Memories surface automatically in context capsules. When linked code changes, memories are marked stale. Consolidates similar observations automatically. Detects anti-patterns like dead-end exploration and file thrashing.

Passive Observation

Watches every file change via blake3 hashing, computes AST-level structural diffs (added, removed, renamed, signature/body/visibility changed), and auto-correlates changes with tool calls. Recurring patterns are auto-promoted into project rules — all without agent cooperation.

Install Free for VS Code

or npm install -g vexp-cli

MCP Tools

One primary call. Ten specialized tools.

Specialized tools
Multi-repo & Git

Cross-repo context. Git-native manifest.

Most AI agents are repo-blind. Cloud context engines can link repos — but require uploading your code. vexp builds cross-repo dependency graphs entirely on your machine, spanning frontend, backend, and infra in a single local query.

1 query
spans all repos
auto-detected
API contracts & shared types
zero config
cross-repo linking
Cross-repo graph
frontendTypeScript
consumer
backendGo
provider
infraTerraform
infrastructure
openapi contract
shared types
env vars
Single query across all repos:
get_context_capsule("Add JWT refresh to auth")
→ 3 repos · 8 pivots · 2,840 tokens
Cross-repo advantage
You ask: "Add JWT refresh to the auth endpoint"
✓vexp returns: auth handler (backend) + token type (shared) + refresh logic stub (frontend) — one query, three repos
3 repos · 1 query
Agent reads backend auth.go blindly, misses shared Token type
✓vexp detects the OpenAPI contract edge, includes the TypeScript Token type skeleton automatically
Zero missed dependencies
"What environment variables does the frontend expect from infra?"
✓vexp traces ENV_CONTRACT edges: infra .env.example → backend config → frontend process.env refs
Full env lineage
Git-native manifest
$ git clone git@github.com/org/repo.git
Receiving objects: 100% (12,847 objects)
vexp: manifest found → rebuilding from hashes...
vexp: 34,821 nodes ready (4.8s from manifest)
Compatibility

Already in your workflow.

Install the VS Code extension or the standalone CLI. vexp auto-detects your agents, writes their config files, and starts working. No login. No API key.

Claude Code
Cursor
Windsurf
GitHub Copilot
Continue.dev
Augment
Zed
Codex
Opencode
Kilo Code
Kiro
Antigravity

Distributed as a VS Code extension and standalone CLI (14 commands) · works with any MCP agent · generates configs for 12 agents automatically

Performance

The numbers.

65-70%
Average token reduction
Measured across 5 real codebases
< 15s
Index 5,000 files from scratch
Parallel tree-sitter parsing with rayon
< 500ms
P95 context capsule query
Hybrid search: FTS + TF-IDF + graph centrality
0
Network calls to external servers
Native Rust binary. Local SQLite. Your code never leaves your machine.

Benchmarked against Next.js, FastAPI, Gin, and vexp itself

Pricing

Flat pricing. No credits. No surprises.

Starter lets you try vexp with session memory on any project — no account, no API key. Pro unlocks all 11 tools including the full pipeline, multi-repo workspaces, and 50,000 nodes for $19/mo.

If you spend $20–200/mo on AI coding, vexp pays for itself in the first week. 65–70% fewer tokens = 2–3x more work before hitting limits.

Starter
$0forever

Try vexp on a personal project. No account required.

  • ✓≤ 2,000 nodes
  • ✓Single-repo workspace
  • ✓7 MCP tools (4 core + 3 memory)
  • ✓VS Code extension or standalone CLI
  • ✓Git manifest sync
  • ✓Community support
Most popular
Pro
$19/month

Full context engine for professional developers. Under $20 — expense without approval.

  • ✓50,000 nodes
  • ✓Up to 3 repos per workspace
  • ✓All 11 MCP tools
  • ✓Intent detection & CodeLens
  • ✓Email support

All plans work on unlimited individual repositories. The workspace limit defines how many repos can be linked together for cross-repo queries.

Get started

Install. Open. Done.

01

Install the extension or CLI

VS Code / Cursor / Windsurf
# Search in the Extensions panel
Extensions → Search "vexp" → Install
✓ Auto-detects your AI agent and configures MCP
Standalone CLI
# Install globally via npm
npm install -g vexp-cli
# Or run the daemon directly
vexp-core mcp --workspace .
✓ Works with Claude Code, Codex, Opencode & more
02

Open your workspace — vexp indexes automatically

Status Bar
◈ vexp: indexing... 2,341/5,000 files
◈ vexp: 34.8k nodes | 89.2k edges | ready
03

Your agent has context — no account needed

Claude Code
# Auto-called before every code edit
tool_call: get_context_capsule
query: "{task}"
✓ 12 pivots · 8 skeletons · 2,140 tokens
On mobile? Get the install links by email.

One-time email with install links. No spam.

74% fewer tokens.
Zero cloud dependency.

One call: context + impact + memory. Native Rust binary. Local SQLite. Works with 12 agents.

On mobile? Get the install links by email.

One-time email with install links. No spam.

No account · No credit card · Zero network calls