RS UTCP
Official Rust implementation of the UTCP
What is RS UTCP?
RS UTCP is a Model Context Protocol (MCP) server that allows AI assistants like Claude, Cursor, and VS Code to official rust implementation of the utcp
Official Rust implementation of the UTCP
This server falls under the Developer Tools category on MCPgee, the world's largest MCP server directory with 33,000+ servers.
Features
- Official Rust implementation of the UTCP
Use Cases
Maintainer
Works with
Installation
Manual Installation
npx rs-utcpConfiguration
Configuration Details
claude_desktop_config.json
Performance
Response Metrics
Resource Usage
How to Set Up and Use RS UTCP
rs-utcp is the official Rust client library for the Universal Tool Calling Protocol (UTCP), an open standard that allows AI agents to discover and invoke tools hosted over 12 different communication protocols including HTTP, MCP, WebSocket, gRPC, CLI, GraphQL, TCP, SSE, and more. Built with async/await via Tokio, it provides config-driven tool provider registration from JSON manifests, tag-based semantic tool search, OpenAPI spec import, and multi-authentication support. Rust developers building AI agent frameworks or multi-protocol tool orchestration layers use it as the foundation for uniform tool calling across heterogeneous backends.
Prerequisites
- Rust toolchain (stable, 2021 edition or later) with Cargo
- Tokio async runtime (added as a dependency)
- A providers.json manifest describing the tool providers your agent needs
- Network access to the tool endpoints listed in the manifest
- API keys or auth credentials for any secured tool providers
Add rs-utcp to your Cargo.toml
Add the rs-utcp crate and Tokio runtime to your project's dependencies. Tokio with the 'full' feature set is required for the async client.
cargo add rs-utcp
cargo add tokio --features fullCreate a providers.json manifest
Define your tool providers in a JSON file. Each entry in 'tools' specifies the tool name, description, input/output schemas, and a call template that references the communication protocol and endpoint.
{
"manual_version": "1.0.0",
"utcp_version": "0.3.0",
"allowed_communication_protocols": ["http", "mcp"],
"info": {
"title": "My Agent Tools",
"version": "1.0.0",
"description": "Tool providers for my AI agent"
},
"tools": []
}Initialise the UTCP client in Rust
Create a UtcpClientConfig pointing to your providers.json, wire up an InMemoryToolRepository and TagSearchStrategy, then instantiate UtcpClient. The client discovers and registers all tools on startup.
use rs_utcp::{
config::UtcpClientConfig,
repository::in_memory::InMemoryToolRepository,
tag::tag_search::TagSearchStrategy,
UtcpClient, UtcpClientInterface,
};
use std::sync::Arc;
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let config = UtcpClientConfig::new()
.with_manual_path("providers.json".into());
let repo = Arc::new(InMemoryToolRepository::new());
let search = Arc::new(TagSearchStrategy::new(repo.clone(), 1.0));
let client = UtcpClient::create(config, repo, search).await?;
Ok(())
}Search for and call tools
Use search_tools to find tools by tag and call_tool to invoke them. Results are returned as serde_json::Value.
let tools = client.search_tools("weather", 10).await?;
let mut args = std::collections::HashMap::new();
args.insert("city".to_string(), serde_json::json!("London"));
let result = client.call_tool("get_forecast", args).await?;
println!("{}", serde_json::to_string_pretty(&result)?);Build and run your agent
Compile with 'cargo build --release' and run your binary. The UTCP client will load providers.json and be ready to route tool calls at runtime.
cargo build --release
./target/release/my_agentRS UTCP Examples
Client configuration
Example providers.json manifest registering one HTTP tool and one MCP stdio tool for a UTCP client.
{
"manual_version": "1.0.0",
"utcp_version": "0.3.0",
"allowed_communication_protocols": ["http", "mcp"],
"info": {
"title": "Example Tools",
"version": "1.0.0",
"description": "Sample providers manifest"
},
"tools": [
{
"name": "get_forecast",
"description": "Get weather for a city",
"inputs": {
"type": "object",
"properties": {
"city": { "type": "string" }
},
"required": ["city"]
},
"outputs": { "type": "object" },
"tool_call_template": {
"call_template_type": "http",
"name": "weather_api",
"url": "https://api.weather.example.com/tools",
"http_method": "GET",
"headers": { "Accept": "application/json" }
},
"tags": ["weather"]
}
]
}Prompts to try
Conceptual interactions showing how an AI agent using rs-utcp would orchestrate tool calls.
- "Search for all tools tagged 'filesystem' and list their names and descriptions."
- "Call the get_forecast tool for city=Tokyo and return the result."
- "Import the Petstore OpenAPI spec and generate tools from all GET endpoints."
- "List all registered tool providers and their communication protocols."
- "Call the read_file tool with path=/etc/hosts using the MCP stdio provider."Troubleshooting RS UTCP
cargo add rs-utcp fails with 'no matching package'
Ensure your Rust toolchain is up to date (rustup update stable) and that crates.io is reachable. Check the current version at crates.io/crates/rs-utcp and pin it explicitly if needed.
Client panics at startup with 'providers.json not found'
The path passed to with_manual_path is resolved relative to the working directory of the binary at runtime, not the project root. Use an absolute path or ensure you run the binary from the correct directory.
Tool call returns an auth error from the remote provider
UTCP supports API keys, Basic Auth, and OAuth2 in the call_template. Add an 'auth' block to the tool's call_template in providers.json with the appropriate credential type and values.
Frequently Asked Questions about RS UTCP
What is RS UTCP?
RS UTCP is a Model Context Protocol (MCP) server that official rust implementation of the utcp It connects AI assistants to external tools and data sources through a standardized interface.
How do I install RS UTCP?
Follow the installation instructions on the RS UTCP GitHub repository. Clone the repo, install dependencies, and add the server config to your AI client.
Which AI clients work with RS UTCP?
RS UTCP works with all major MCP-compatible AI clients including Claude Desktop, Claude Code, Cursor, VS Code (GitHub Copilot), Windsurf, and Cline.
Is RS UTCP free to use?
Yes, RS UTCP is open source and available under the MPL-2.0 license. You can use it freely in both personal and commercial projects.
RS UTCP Alternatives — Similar Developer Tools Servers
Looking for alternatives to RS UTCP? Here are other popular developer tools servers you can use with Claude, Cursor, and VS Code.
Ecc
★ 188.2kThe agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Javaguide
★ 155.8kJava 面试 & 后端通用面试指南，覆盖计算机基础、数据库、分布式、高并发、系统设计与 AI 应用开发
Gemini CLI
★ 104.5kA secure MCP server that wraps the Google Gemini CLI, allowing clients to query Gemini models using local OAuth sessions without requiring an API key. It provides tools for model interaction and diagnostics with built-in protection against command in
Awesome MCP Servers
★ 87.3k⭐ Curated list of Model Context Protocol (MCP) servers - tools that extend Claude Desktop, Cursor, Windsurf, and other MCP clients with custom capabilities.
MCP Servers
★ 86.0kModel Context Protocol Servers
CC Switch
★ 77.5kA cross-platform desktop All-in-One assistant for Claude Code, Codex, OpenCode, OpenClaw, Gemini CLI & Hermes Agent. Only official website: ccswitch.io
Browse More Developer Tools MCP Servers
Explore all developer tools servers available in the MCPgee directory. Each server includes setup guides for Claude, Cursor, and VS Code.
Set Up RS UTCP in Your Editor
Choose your AI client for step-by-step setup instructions.
Quick Config Preview
Add this to your claude_desktop_config.json or .cursor/mcp.json
Ready to use RS UTCP?
Browse our complete directory of 33,000+ MCP servers, read setup guides for your editor, and start building with the Model Context Protocol.