Which integrations are available for this server?

Resolves exact-version Rust crate documentation from docs.rs (along with cache and local sources), enabling agents to look up dependency APIs and documentation.

How do I use agz-rust-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@agz-rust-mcp inspect this Cargo workspace and list its packages and targets" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

agz-rust-mcp

by agzyazilim

Overview Schema Source Related Servers Discussions Admin

Rust

Local

AGZ Rust MCP

crates.io License: MIT

English | Türkçe

An AGZ Yazılım product. agz-rust-mcp is a standalone stdio MCP server for general-purpose Rust development grounded in Cargo and rustc. Discover a project offline, collect focused source context and compiler diagnostics, select individual tests, and run binaries/examples. Exact-version dependency docs, Rust Analyzer navigation and write-free change/refactor packages support deeper work.

Everyday workflow

The same workflow works with a library, CLI, service or multi-package Cargo workspace. No framework-specific project structure or particular MCP client is required.

Need	Tool call
Map packages, declared targets, features and dependencies without compiling	`workspace(action="inspect")`
Locate code and read bounded, numbered source	`workspace(action="search", query="parse_record")`, then `workspace(action="read", path="src/lib.rs", line=1, lineCount=80)`
Get fresh compiler diagnostics	`check(target="check", options={"packages":["my_crate"]})`
Discover actual test names	`test(action="list", packages=["my_crate"])`
Run one library test by its full name	`test(action="run", packages=["my_crate"], cargoTarget={"kind":"lib"}, filter="tests::parses_record", exact=true)`
Compile tests without executing them	`test(action="compile", packages=["my_crate"])`
Execute a binary or example	`run(package="my_crate", target={"kind":"example","name":"demo"}, args=["input.json"], timeoutMs=30000)`
Resolve an unfamiliar dependency API	`docs` with its exact version; `api` for deeper resolution/probing

Pass an absolute dir for the active project when the client starts elsewhere. A function is exercised through a test or executable example. run is a typed Cargo runner; program arguments remain literal, including spaces and shell metacharacters. Tests and applications execute project code with its ordinary side effects. Empty selections return NO_TESTS, not a passing test verdict.

Use agz-rust-mcp --toolset core for a compact catalog of six everyday tools: workspace, check, test, run, docs, and crate_lookup. The default --toolset full preserves every existing tool plus the new additions. Individual --tools-<name> false switches can disable tools further. See the full reference for limits and result states.

Related MCP server: ROS 2 Workspace Inspector MCP

Install

# installer script (Linux x86_64): download install.sh and SHA256SUMS from the
# latest release, verify the script, then run it
bash install.sh

# crates.io (requires Rust 1.88.0 or newer)
cargo install agz-rust-mcp --locked
agz-rust-mcp --version

Prebuilt .tar.gz archives with .sha256 files are available for Linux x86_64, macOS arm64, and Windows x86_64. Releases up to 0.2.0 use the legacy agz-rust-coder-* asset names; from 0.3.0 onward the names are agz-rust-mcp-*.

Step-by-step instructions, per-OS notes, checksum verification, and troubleshooting: docs/install.md · Türkçe.

MCP Client Setup

The current source also bundles four offline skills: agz-rust-workflow, agz-rust-repair, agz-rust-refactor, and agz-rust-performance. One executable serves the tools and their workflows through MCP prompts/resources; a second MCP is unnecessary. Filesystem-based clients can use agz-rust-mcp skills export. See bundled skills. Bundled skills are available from 0.4.0; 0.3.0 binaries do not include them.

Client	Configuration	Guide
ZCode	`~/.zcode/cli/config.json` → `mcp.servers.rust`	ZCode
OpenCode	`opencode.jsonc` → `mcp.rust`	OpenCode
OpenCode2	`opencode.jsonc` → `mcp.servers.rust`	OpenCode2
Codex	`~/.codex/config.toml` → `mcp_servers.rust`	Codex

Use the example for your client; OpenCode and OpenCode2 have different layouts. All launch the installed agz-rust-mcp binary. Run agz-rust-mcp --version once before connecting, and use an absolute path if the client's PATH differs.

The canonical current directory is the default authorized root. Add explicit roots with repeated --allow-root arguments when the client starts elsewhere; client-provided MCP roots may narrow configured access but never widen it. See docs/install.md for per-client setup.

Documentation

Read the documentation in this order:

Install and client setup - every install method and client configuration.
Tool and configuration reference - tools, actions, result semantics, and all configuration keys.
Architecture - process model, protocol lifecycle, and authority boundaries.
Validation and benchmark protocol - smokes, gates, and evidence.
Security policy and Contributing.

The bilingual index with the full reading path is docs/README.md / docs/README.tr.md.

Identity

Contract	Value
Crate, binary, server	`agz-rust-mcp`
MCP Registry	`io.github.agzyazilim/rust-mcp`
Source version	`0.5.0`
First release	`0.1.0`
Release tag	`agz-rust-mcp-v<version>`
Rust edition / MSRV	`2024` / `1.88.0`
Rust MCP SDK	`rmcp` `3.1.4`
Default / discovered protocol	`2025-11-25` / `2026-07-28`

MCP package ownership marker: mcp-name: io.github.agzyazilim/rust-mcp.

Tools

MCP clients may prefix tool names (for example rust_*); use the names from the connected server's tool catalog.

MCP tool	Example prefixed name	Default	Purpose
`workspace`	`rust_workspace`	`enabled`	Inspect manifests/lockfiles, search source and read excerpts offline without Cargo or Rust Analyzer.
`test`	`rust_test`	`enabled`	Discover, compile or run selected tests with exact names, ignored-test controls and bounded execution.
`run`	`rust_run`	`enabled`	Run an exact Cargo binary/example with literal arguments, a deadline and bounded output.
`check`	`rust_check`	`enabled`	Run bounded Cargo check, Clippy, tests, docs, or the full gate.
`profile`	`rust_profile`	`enabled`	Analyze observed Cargo rebuild behavior and compare bounded build evidence without claiming unmeasured speedups.
`audit`	`rust_audit`	`enabled`	Scan Rust source for bounded static findings.
`crate_lookup`	`rust_crate_lookup`	`enabled`	Verify a crate and optional exact version on crates.io.
`docs`	`rust_docs`	`enabled`	Resolve exact-version docs from cache, local sources, or docs.rs.
`context`	`rust_context`	`enabled`	Prepare, expand, or delta a revision-bound semantic context capsule with per-item reasons.
`api`	`rust_api`	`enabled`	Resolve an API signature from bounded analyzer evidence or type-check a candidate snippet in an isolated copy of the workspace configuration.
`explain`	`rust_explain`	`enabled`	Explain macro expansion provenance, trait obligations, or cfg enablement.
`verify`	`rust_verify`	`enabled`	Plan or run a bounded feature, target, toolchain, and stage matrix.
`symbol`	`rust_symbol`	`enabled`	Read Rust Analyzer hover data for one symbol.
`references`	`rust_references`	`enabled`	Find bounded references.
`definition`	`rust_definition`	`enabled`	Find the selected definition.
`symbols`	`rust_symbols`	`enabled`	List symbols in one Rust file.
`implementations`	`rust_implementations`	`enabled`	Find implementations.
`hierarchy`	`rust_hierarchy`	`enabled`	Trace a bounded call hierarchy.
`rename`	`rust_rename`	`enabled`	Produce a verified rename edit package without applying it.
`refactor`	`rust_refactor`	`enabled`	Produce a verified refactor edit package without applying it.
`change`	`rust_change`	`enabled`	Create, stage, migrate, and validate a revision-bound changeset in server-owned scratch without writing the workspace.
`repair`	`rust_repair`	`enabled`	Analyze, try, compare, and minimize compiler-driven repair candidates for a failing change revision without writing the workspace.
`work`	`rust_work`	`enabled`	Drive a typed intent through change/validate with explicit gates and budgets, returning honest gate evidence or a bounded single-use handoff.

Every tool returns deterministic structured data plus an equivalent bounded text fallback. External data stays under untrustedData. Expected domain outcomes such as compiler failure, missing crates, or unavailable docs are typed results; invalid input, authorization failure, resource exhaustion, and unavailable semantic infrastructure are protocol errors.

Configuration

Precedence is CLI, then AGZ_RUST_MCP_* environment variables, then the explicit --config TOML file, then defaults. Environment keys use __ between sections, for example AGZ_RUST_MCP_GATE__HARD_TIMEOUT_MS=600000.

Key	Default	Meaning
`server.allow_roots`	canonical CWD	Workspace read/command boundary.
`server.allow_dependency_roots`	empty	Explicit external path-dependency roots.
`gate.hard_timeout_ms`	`600000`	Cargo operation deadline.
`gate.scope`	`shadow`	Validation target: `workspace`, `shadow`, or `affected`.
`gate.cache`	`auto`	Cache policy: `auto`, `project`, or `isolated`.
`rust_analyzer.workspace_code`	`deny`	Reject RA startup unless workspace code is disabled.
`docs.fallback`	`auto`	Documentation source policy.
`profile.max_report_bytes`	`4194304`	Bounded read/store cap for one Cargo timing artifact.
`profile.max_runs`	`4`	Fresh Cargo runs available to one `profile` call.
`profile.compare_samples`	`3`	Required samples per side before any speed claim.
`limits.tool_output_bytes`	`49152`	Maximum serialized tool result size.
`change.max_bytes`	`268435456`	Maximum captured candidate bytes per changeset.
`repair.max_candidates`	`4`	Candidates one `repair` action may try.
`repair.max_compiles`	`4`	Cargo validations one `repair` action may run.
`repair.wall_time_ms`	`120000`	Wall-clock budget for one `repair` action.
`repair.minimize_max_candidates`	`32`	Compile-evaluated reduction attempts one `repair(action=minimize)` may try.
`repair.minimize_max_compiles`	`16`	Cargo runs one `repair(action=minimize)` may execute, including reproduction and export verification.
`work.max_candidates`	`4`	Host candidate revisions one work item may stage.
`work.max_compiles`	`12`	Gate validations one work item may run.
`work.wall_time_ms`	`600000`	Wall-time budget for one work item.
`telemetry.enabled`	`true`	Bounded local activity records without prompts or source.

profile evidence is bounded: the latest 64 records stay in memory, and persisted timing artifacts under the server-owned profile-evidence directory are pruned after 24 hours or beyond 64 files. The profile result reports this retention policy, so expired evidence is visible instead of silently reused.

Run agz-rust-mcp --help for every CLI field. The complete behavior and default table is in docs/tools.md.

Security

The server does not modify workspace source, but it is not an operating-system sandbox. Cargo build scripts, tests, procedural macros, local rustdoc, and opted-in Rust Analyzer workspace code execute with the server user's authority. Use a container or OS sandbox when that boundary is required. Workspace, dependency, cache, lease, journal, docs, and telemetry paths are canonicalized, bounded, and fail closed, and stdout is reserved for MCP framing. Report vulnerabilities privately as described in SECURITY.md.

License

This server cannot be deployed

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

Maintenance

ActivityMaintained

ResponsivenessResponsive

Resources

Related MCP Connectors

codeitall A
dev.codeitall
Behavioral oracle for Rust crate APIs: runtime behavior, yank/advisory, deprecation, sig search
Code Analysis Developer Tools
2
https://api.codeitall.dev/mcp
Ferritin — Rust documentation A
rs.ferritin
Search and read Rust documentation for the standard library and any crate on crates.io
Documentation Access Developer Tools
2233
https://ferritin.rs/mcp
SpiderbrainOAuth
ai.spiderbrain
Deterministic context layer for your codebase: change impact, blast radius, answers with receipts.
Code Analysis Developer Tools RAG Systems
13
https://mcp.spiderbrain.ai/mcp
gentlyOAuth
is.gently
Ask a codebase what calls what: search, blast radius, paths between symbols, and diffs.
Code Analysis Developer Tools
1
https://api.stage.gently.is/mcp

Related MCP Servers

mcp-rust-docs
Developer Tools Documentation Access
trungnguyenvn
A
license
Not graded
quality
D
maintenance
Provides access to Rust crate documentation, search, and metadata from docs.rs and crates.io.
Updated a year ago (2025-07-23 15:19 UTC)
4 npm
MIT
ROS 2 Workspace Inspector MCP
Developer Tools Code Analysis
doer0312
A
license
A
quality
D
maintenance
Provides static analysis of ROS 2 workspaces, enabling inspection of packages, dependencies, interfaces, launch files, and robot descriptions without running ROS 2.
Updated 4 months ago (2026-07-11 10:42 UTC)
7
2
Apache 2.0
firedbg-mcp
Developer Tools Code Analysis
ConVonKnorrisson
F
license
Not graded
quality
D
maintenance
Enables discovery, execution, indexing, and querying of Rust program traces using FireDBG, scoped to a single Cargo workspace.
Updated 4 months ago (2026-07-14 20:00 UTC)
-
FolderBridge MCP
File Systems Version Control
MoonTzai
A
license
A
quality
A
maintenance
Enables AI clients to inspect and carefully edit a bounded local workspace via stdio, with a read-only default, conflict-safe updates, and no network listener or telemetry.
Updated 11 days ago (2026-10-22 11:20 UTC)
10
2
Apache 2.0