Connect your coding agent

Run the command from inside a Git repository. fuse mcp install writes configuration for Claude Code, Cursor, GitHub Copilot, OpenCode, Kilo Code, Codex, and Grok Build. Other MCP clients use the same stdio server with manual registration. No environment block is required: the shared daemon and syntax-first indexing default on inside fuse mcp serve. Compiler analysis starts only for an explicit semantic index or compiler-backed request.

fuse mcp install

Model Context Protocol (MCP) is the connection format that lets a coding agent launch Fuse and call its local tools. You do not keep fuse mcp serve running in a terminal. The agent starts it when needed.

What Install Means

fuse mcp install means MCP client registration. It does not install the fuse .NET tool, start a permanent process, create .fuse/fuse.db, or install an agent skill or plugin. Install the executable first from the Install page.

The command's options control separate artifacts:

Command	Writes	Does not write
`fuse mcp install`	MCP registration, the v4.4 managed instruction block, and `.fuse/` in project `.gitignore` when needed	A skill, hook, or index
`fuse mcp install --no-rules`	MCP registration only	Managed instructions, a skill, hook, or index
`fuse mcp install --with-hooks`	Default installation plus project-scoped Claude Code hooks in `.claude/settings.json`	A skill or an index

The MCP server always advertises its built-in server instructions during connection. The installer writes the same short, versioned task-routing block by default and replaces only the text between  and . It leaves all user content outside those markers unchanged. For Codex, OpenCode, and Kilo Code this is an AGENTS.md file. For Claude Code it is CLAUDE.md. These are instruction files, not skills.

Reload the agent, then ask it to check the connection:

Call fuse_workspace with action=status for this repository. Return the workspace path,
analysis mode, and freshness exactly as Fuse reports them.

A response containing the current repository path confirms activation. A list of available tools does not.

Registration Scope and Workspace Scope

The opening command registers all seven supported clients for the current project when you use the default --client all. To register Fuse for every project on this machine:

fuse mcp install --scope user

Registration scope controls where the MCP client entry and optional rules are written. It does not control what Fuse indexes:

Scope	Registration behavior	Runtime behavior
`project`	Writes at the nearest enclosing Git repository root. Running from `repo/src/Feature` still writes at `repo`. Refuses a folder with no Git identity.	The client exposes Fuse for that repository. Calls from any nested folder use the repository identity and its root index.
`user`	Writes the client's user configuration, so the client can expose Fuse in every project. This command can run outside Git.	Every operation except `fuse_reduce` still needs a Git repository identity. A non-Git folder returns `workspace_identity_unresolved:` and no daemon or index starts.

Workspace identity is the nearest enclosing directory containing either a .git directory or a .git file. The file form covers Git worktrees. The normalized repository root keys the daemon endpoint, writer lock, and .fuse/fuse.db; a nested output folder cannot create a second index over the repository database. fuse_reduce is the exception: it accepts known files or raw content without a workspace index.

To register one client:

fuse mcp install --client cursor
fuse mcp install --client claude
fuse mcp install --client copilot
fuse mcp install --client opencode
fuse mcp install --client kilo
fuse mcp install --client codex
fuse mcp install --client grok

The available flags are:

--client claude|cursor|copilot|opencode|kilo|codex|grok|all, default all
--scope project|user, default project
--no-rules, which writes MCP registration without managed agent instructions or the project .gitignore entry
--with-hooks, which writes project-scoped Claude Code verification hooks in addition to the default managed instructions
--command, which changes the executable the client launches
fuse mcp doctor [path] --client <name> --scope project|user --json, which checks registration, executable paths, managed instructions, daemon protocol, repository identity, and active index jobs

What Project Setup Writes

Claude Code: .mcp.json, plus a Fuse-managed block in CLAUDE.md.
Cursor: .cursor/mcp.json, plus .cursor/rules/fuse.mdc.
GitHub Copilot: .vscode/mcp.json, plus a Fuse-managed block in .github/copilot-instructions.md.
OpenCode: opencode.json, plus a Fuse-managed block in AGENTS.md.
Kilo Code: .kilo/kilo.jsonc, plus a Fuse-managed block in AGENTS.md.
Codex: .codex/config.toml, plus a Fuse-managed block in AGENTS.md.
Grok Build: .grok/config.toml, plus a Fuse-managed block in AGENTS.md.
.gitignore: appends .fuse/ at project scope (skipped when an equivalent entry already exists).

Pass --no-rules to omit every managed instruction file and the .gitignore update.

Existing config keys and instruction text are retained. Re-running the command updates the Fuse server entry and marker-delimited rule in place. Project files can be committed so the team receives the same setup.

At user scope, Claude registration uses claude mcp add and writes its rule to ~/.claude/CLAUDE.md. Cursor writes ~/.cursor/mcp.json. Copilot writes the VS Code user mcp.json under:

Windows: %APPDATA%\Code\User
macOS: ~/Library/Application Support/Code/User
Linux: ~/.config/Code/User

OpenCode writes ~/.config/opencode/opencode.json and ~/.config/opencode/AGENTS.md. Kilo Code writes ~/.config/kilo/kilo.jsonc and ~/.config/kilo/AGENTS.md. Codex writes ~/.codex/config.toml and ~/.codex/AGENTS.md, or the equivalent files under CODEX_HOME. Grok Build writes ~/.grok/config.toml, or $GROK_HOME/config.toml when that variable is set.

Cursor and Copilot do not have a user-global rule file. Grok Build documents repository AGENTS.md discovery but no user-global AGENTS.md. User-scope installation skips those three rules with a note.

The optional project-scoped --with-hooks flag also merges two Claude Code hooks into .claude/settings.json: a post-edit fuse check --delta --fast hook and a stop-time fuse gate hook. User scope with --with-hooks is refused because the hook commands are bound to one repository and its daemon identity.

Inspect an Installation

fuse mcp doctor reads the selected registration without modifying it. It reports the running Fuse version, the fuse executable found on PATH, the selected client configuration and command, managed-block version, optional hooks, daemon protocol, repository identity, and active index job. Use JSON when another tool must consume the result.

fuse mcp doctor --client codex --scope project --json
fuse mcp doctor --client claude --with-hooks

After fuse mcp install, the command runs this check and tells you when the selected client must restart before it reads the new registration.

Get the First Compiler-Backed Result

After the status call succeeds, ask the agent:

Before editing OrderService.cs, call fuse_check with the proposed file content. Show the
compiler result before writing the change.

Fuse labels the compiler path used for each check. This label is the verification grade: oracle grade uses a build-captured compilation, while build grade runs a scoped real dotnet build. If neither path can answer, Fuse abstains and states what is missing.

After a client launches the server from a Git repository, the shared daemon starts warming .fuse/fuse.db. Every indexed read first requires a valid warm-index manifest containing the normalized repository root and the complete file-inventory count and hash. A database with rows but no manifest, an interrupted build marker, a wrong root, or an inconsistent inventory rebuilds automatically. Added files are discovered during read-time reconcile, and removed files are deleted from the files table and its derived rows.

Run fuse index (or ask the agent to call fuse_workspace with action=index) only when you want to wait for the syntax index before the first task. Add --semantic when a complete workspace compiler pass is required. Otherwise a cold read uses a bounded syntax-first pass and reports the active job. Fuse then re-indexes changed files through the live watcher and read-time backstop. It reports partial or syntax analysis when compiler analysis cannot load every selected project.

Local Process and Network Behavior

The client launches fuse mcp serve as a child process and communicates over standard input and output. Fuse does not listen on a TCP port. Source files and the derived index remain on your machine. Indexing, retrieval, reduction, and captured-compiler checks can work offline.

Your coding agent still applies its own data policy to prompts and tool results. Fuse can contact NuGet for a daily update check; set FUSE_UPDATE_CHECK=0 in the server environment to disable it. A compiler fallback can run the repository's normal dotnet build, including any package-feed access required by that build.

Advanced opt-outs

The defaults above suit most agent sessions. Set these only when you need to override them in the client env block or your shell:

Variable	Opt-out value	Effect
`FUSE_DAEMON`	`0`	Serve in-process instead of delegating to a shared `fuse host` per repository
`FUSE_AUTO_UPDATE`	`0`	Do not launch a background updater between MCP sessions
`FUSE_EAGER_INDEX`	`0`	Do not start warming the repository when the daemon or MCP server starts
`FUSE_UPDATE_CHECK`	`0`	Disable the NuGet update notice on stderr

See Configuration keys for the full list.

Other MCP clients

Any client that supports MCP over stdio can launch Fuse. Add a server entry that runs fuse mcp serve. The JSON shape varies by client; some use mcpServers, others servers, and some require type: stdio.

{
  "mcpServers": {
    "fuse": {
      "command": "fuse",
      "args": ["mcp", "serve"]
    }
  }
}

Windsurf, Cline, Zed, and custom agents follow this pattern once you locate the client's MCP configuration file. Reload the client after editing.

Manual registration

Use these files if you prefer to edit the client configuration yourself instead of running fuse mcp install.

Claude Code, .mcp.json:

{
  "mcpServers": {
    "fuse": {
      "type": "stdio",
      "command": "fuse",
      "args": ["mcp", "serve"]
    }
  }
}

You can also use the Claude CLI:

claude mcp add fuse --scope project -- fuse mcp serve

Use --scope user to make it available in every project.

Cursor, .cursor/mcp.json:

{
  "mcpServers": {
    "fuse": {
      "command": "fuse",
      "args": ["mcp", "serve"]
    }
  }
}

GitHub Copilot in VS Code, .vscode/mcp.json:

{
  "servers": {
    "fuse": {
      "type": "stdio",
      "command": "fuse",
      "args": ["mcp", "serve"]
    }
  }
}

OpenCode in opencode.json, or Kilo Code in .kilo/kilo.jsonc:

{
  "mcp": {
    "fuse": {
      "type": "local",
      "command": ["fuse", "mcp", "serve"],
      "enabled": true
    }
  }
}

Codex in .codex/config.toml, or Grok Build in .grok/config.toml:

[mcp_servers.fuse]
command = "fuse"
args = ["mcp", "serve"]

Roll Back the Setup

There is no fuse mcp uninstall command. Remove only the fuse entry from each client configuration file listed above, preserving other entries. For Claude user scope, run:

claude mcp remove fuse --scope user

Delete .cursor/rules/fuse.mdc. In any managed CLAUDE.md, AGENTS.md, or copilot-instructions.md, delete the block from  through . In Codex or Grok Build TOML, delete the block from # fuse:begin ... through # fuse:end. If you installed hooks, delete the two Fuse entries from .claude/settings.json under hooks.

Stop or reload the coding agent, then delete .fuse/ at the repository root to remove the derived index. Deleting .fuse/ does not change source files. A later Fuse read rebuilds it after the repository identity resolves.

Continue with the Quickstart. Use the tool reference for every operation and parameter, or the API surfaces map when you need the CLI or host RPC equivalent of an MCP tool.