Other agents

V3Code’s Context Bridge isn’t locked inside its own chat. You can expose the same structural tools — symbol context, call graphs, dependencies, notes, semantic search — to any agent that speaks MCP, over a single endpoint.

Why do this

It turns V3Code into an intelligence layer for whatever agent you already use. Point Claude Code or Cursor at the endpoint and they get the same LSP-backed view of your codebase that V3Code’s own agent has — structure and relationships, not just text. Their answers get sharper because their inputs get sharper.

Connect from Settings

Open Settings → Expose V3Code. The status at the top tells you whether the local server is running and which workspace it serves.

V3Code offers three guided connection paths:

• Codex + ChatGPT desktop — choose Connect. If V3Code finds an older fixed-port entry, the button becomes Repair and replaces it with the stable definition.
• Claude Desktop — choose Create extension, then double-click the generated V3Code.mcpb file to install the local connector.
• Claude Code + other local agents — choose Copy config and paste the stable stdio definition into that client’s MCP configuration.

The stable definition follows the correct running editor even if its loopback port changes after an update or more than one build is open. It stays on the current computer and does not require a V3Code account.

The page also shows a Current direct endpoint (advanced) for clients that specifically need streamable HTTP. Treat the shown URL as runtime state, not a permanent port to copy into long-lived configuration. V3Code writes the live endpoint and open workspaces to ~/.v3code/endpoint.json for local discovery.

Tip

Tell your agent to call orient first — it returns a project briefing and index health in one call, so the agent starts every session already knowing the codebase.

What’s exposed

V3Code serves a curated set of tools over the endpoint. Any MCP client you configure can call them in-process against your local project:

• Structural reads — get_symbol_context, get_call_graph, get_file_context, get_file_dependencies, pack_context, get_project_briefing, semantic_search, find_text, get_build_errors (live language-server errors, no recompile).
• Memory & recall — list_notes, search_notes, deep_recall, workspace_delta, recent_edits, session_diff, index_health, plus write-side remember / forget.
• Precision search (when the native symbol sidecar is running) — symbol_lookup (definitions/references) and impact_trace (change blast-radius).
• Handy composites — orient (briefing + index health in one call), run_subagent (a read-only investigation subagent on your own key), and send_chat / get_chat to drive and read your live V3Code chat.
• Review and navigation — bounded read_file, ls_dir, git_log, and git_diff calls for clients that need review context without shell access.
• Durable local coordination — private notebooks and collaboration records tied to the serving editor and workspace. Long research jobs return a job ID that can be checked, retrieved, or cancelled instead of holding one request open indefinitely.

Editing, terminal, and git-write tools are deliberately not exposed over the endpoint — external agents get V3Code’s intelligence, not the keys to your filesystem.

Make your agent actually use it

Here’s the honest part most integration docs skip: connecting the endpoint isn’t enough. Agents default to their built-in habits — grep, read, guess — and won’t spontaneously reach for tools they don’t know they should prefer. The fix is a small standing instruction (a “skill”) that tells your agent when these tools beat its defaults.

The Teach Claude when to use V3Code control can copy an instruction file for that client. For any other model, adapt the same behavior to its project-instruction format:

---
name: v3code
description: Use the v3code MCP tools for code intelligence and memory whenever
  working in this repo — the running V3Code editor indexes it live, so results are
  current and authoritative. Trigger on any "where/how/what implements X", symbol
  lookup, impact analysis, build-error check, or memory recall.
---

# Using V3Code's live code intelligence

This workspace is indexed live by the V3Code editor's MCP server (`v3code`).
Prefer its tools over grep/read for exploration.

- Call **`orient`** first on every non-trivial task — project briefing + index
  health in one call.
- **`semantic_search`** for "where/how is X done" (meaning); **`find_text`** for
  exact strings only.
- **`pack_context`** instead of opening five files; **`get_symbol_context`** /
  **`get_call_graph`** for callers, callees, and blast radius.
- **`get_build_errors`** before claiming a change compiles — live language-server
  errors, no build needed.
- **`remember` / `forget`** for durable notes; **`deep_recall`** when you need
  history the context dropped.

That instruction changes the default behavior: the agent starts sessions with orient, searches by meaning instead of guessing filenames, and checks real compiler state before declaring victory.

Note

Exposing V3Code is the opposite direction from installing an MCP server in V3Code. MCP Servers gives V3Code new tools; Expose V3Code gives another local agent V3Code’s tools.