# Other agents

V3Code's [Context Bridge](/editor/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:

```markdown
---
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.