What Rust MCP Servers Are Available in the Awesome-MCP-Servers Repository

The awesome-mcp-servers repository curates over 20 Rust MCP servers marked with the 🦀 emoji, ranging from browser automation tools and code intelligence platforms to hardened database connectors and embedded hardware debuggers.

The awesome-mcp-servers list is the definitive community directory for Model Context Protocol (MCP) implementations. Entries tagged with 🦀 indicate Rust-based binaries that leverage the language's memory safety and async concurrency. This guide catalogs all available Rust MCP servers organized by functional domain, with architecture details and specific line references from README.md.

Infrastructure and Server Management

These servers provide gateway aggregation, security proxying, and system administration capabilities.

toolport – Local Gateway and Manager

toolport operates as a local gateway and credential manager for MCP server fleets. According to line 243 of README.md, it provides a single binary that stores credentials in the OS keychain and lazily discovers servers to keep LLM contexts small. The architecture uses a lightweight Rust daemon that spawns child processes for each registered MCP server and forwards JSON-RPC calls between the client and target servers.

shield – Guardrail Proxy for AI Agents

shield implements a security-focused middleware that wraps any MCP server to intercept and filter requests. As documented at line 3211, this Rust binary blocks destructive JSON-RPC calls by matching them against configurable rule sets, providing audit logs for all intercepted traffic before forwarding or rejecting commands.

sysknife – Hardened System Administration

sysknife exposes 189 typed Linux administration actions with cryptographic audit trails. Located at line 727 of the source catalog, it uses nix syscalls wrapped in Rust structs, with each system action exposed as a distinct MCP method. The server implements Ed25519-signed audit logs and TTL-based approvals for production environments.

Development and Code Intelligence

Rust MCP servers excel at static analysis, documentation extraction, and build tool integration.

crimson-crab-mcp-template – Rust Server Template

crimson-crab-mcp-template provides a minimal, ready-to-clone foundation for building new Rust MCP servers. The implementation at line 245 exposes the MCP interface over stdio (JSON-RPC) with a single main.rs that forwards requests to Anthropic's Claude via the crimson-crab SDK, demonstrating the ask_claude tool pattern.

rag-rat – Repository Intelligence Index

rag-rat compiles a hybrid BM25 and vector search index with tree-sitter code graph analysis. As described at line 1132, the Rust binary builds a sled and tantivy index supporting Rust, TypeScript, Kotlin, C/C++, and Python, exposing search and graph-traversal tools for repository-wide intelligence queries.

idencify-mcp – Hosted Code Intelligence Platform

idencify-mcp delivers 14 code intelligence tools including impact analysis and dead code detection for any GitHub repository. The entry at line 1133 notes a Rust service layer exposing a GraphQL-like MCP schema with optional OAuth 2.1 authentication for secure repository analysis.

cratedocs-mcp – Rust Documentation Extraction

cratedocs-mcp leverages the rust-analyzer API to extract traits and interfaces from Rust crates. Documented at line 1399, this single-binary tool parses crate ASTs, filters documentation with regex patterns, and returns token-estimated JSON optimized for LLM consumption.

just-mcp – Justfile Integration

just-mcp enables LLMs to safely execute Justfile recipes with parameter validation. Found at line 1400, the Rust binary wraps the just parser, validates command arguments against recipe schemas, and returns structured execution results while maintaining environment isolation.

Browser Automation

These servers provide headless and visible browser control via WebDriver, CDP, and WebAssembly sandboxing.

browser-use-rs – Lightweight Browser Automation

browser-use-rs drives headless browsers via WebDriver to return structured DOM information. The architecture at line 422 uses headless-chrome and serde for JSON payloads, communicating over stdio as a zero-dependency binary suitable for containerized environments.

AgenticCrawler – Autonomous Web Crawler

AgenticCrawler provides autonomous crawling with 17 browser tools and support for 25 LLM providers. As listed at line 466, it combines reqwest and headless-chrome, with each browser action implemented as a distinct JSON-RPC method such as click and fill_form.

unbrowser – Minimal JavaScript Sandbox

unbrowser executes JavaScript and manages cookies without external browser binaries. The implementation at line 478 uses wasmtime to sandbox JavaScript execution entirely within the Rust process, returning token-efficient BlockMaps for DOM representation.

ghostlight – Local Profile Automation

ghostlight automates the user's visible Chrome profile via the Chrome DevTools Protocol. Documented at line 492, it connects over a local socket to a signed-in Chromium instance, providing recovery mechanisms and optional policy enforcement for local automation workflows.

Data Processing and Storage

Rust MCP servers handle structured data, databases, and knowledge graphs with strict type safety.

spreadsheet-mcp – Token-Efficient Spreadsheet Analysis

spreadsheet-mcp reads and writes XLSX/XLSM files with formula inspection capabilities. The server at line 1402 uses calamine for file I/O and polars for DataFrame operations, providing typed MCP tools that detect regions and inspect formulas while maintaining token efficiency.

postgres-mcp-hardened – Hardened PostgreSQL Server

postgres-mcp-hardened provides a read-only-by-default PostgreSQL interface with AST validation. Built on tokio-postgres as noted at line 955, it enforces transaction-read-only fallback for destructive queries, maintains a hash-chain audit log, and supports optional OAuth 2.1 authentication.

memkeeper – Local-First Memory Store

memkeeper implements hybrid BM25 and vector search for AI agent memory with confidence-based abstention. The binary at line 1540 embeds sqlite and tantivy, with optional ONNX embeddings for reranking, operating as a zero-cost local server that abstains on low-confidence queries.

tribal – Team Knowledge Server

tribal stores organizational tacit knowledge in a PostgreSQL-backed graph. Located at line 2548, the Rust layer acts as an MCP façade using sqlx for type-safe queries against pgvector embeddings, enabling semantic search over team decisions and documentation.

emem – Geospatial Memory

emem provides an Earth memory server delivering elevation, land-cover, and vegetation data. The Rust binary at line 2604 includes built-in vector tiles and geospatial calculation engines, exposing MCP tools for location-based queries with cryptographically signed receipts.

Hardware and Embedded Systems

These servers interface with physical hardware, debugging probes, and serial devices.

embedded-debugger-mcp – Probe-based Debugging

embedded-debugger-mcp supports ARM Cortex-M and RISC-V targets via J-Link and ST-Link probes. As documented at line 1644, the Rust binary interfaces with probe-rs to translate GDB-style commands into MCP calls for embedded firmware debugging.

serial-mcp-server – Serial Port Communication

serial-mcp-server provides tools for reading and writing serial streams with configurable baud rates. Found at line 1645, it uses tokio-serial for async I/O, mapping each serial operation to a distinct JSON-RPC method for hardware communication.

Specialized Utilities

Niche servers for performance tracing, networking, and media processing.

perfetto-mcp-rs – Performance Trace Analysis

perfetto-mcp-rs wraps the Perfetto trace_processor_shell for browser and system trace analysis. The entry at line 1524 describes a Rust wrapper exposing MCP methods for SQL-style queries against page-load metrics, jank detection, and hotspot analysis.

rustunnel – Public Tunneling Service

rustunnel creates HTTP, TCP, and UDP tunnels with custom subdomains and load-balanced pools. The binary at line 1532 combines tokio, hyper, and rust-tls to function simultaneously as the tunnel service and MCP server, exposing tunnel management via JSON-RPC.

cochlea – Audio Processing

cochlea performs offline audio analysis including loudness, pitch, and tempo extraction without ffmpeg dependencies. Documented at line 2831, it implements a pure-Rust DSP pipeline where each analysis step (PCM generation, structure extraction) is exposed as a distinct MCP tool.

max-ramas/rms-memory-mcp – Hybrid Search Memory

rms-memory-mcp provides persistent memory vaults using SQLite, LanceDB, and Tantivy. The server at line 2432 stores vectors in lancedb and full-text indices in tantivy, offering CRUD tools for per-project memory with token-bounded recall mechanisms.

Installing and Running Rust MCP Servers

Most Rust MCP servers distribute via Cargo and support either stdio or HTTP transport modes.

Installation via Cargo

Install any Rust MCP server using its published crate name:

# Example: installing rag-rat

cargo install rag-rat

Running in Stdio Mode

The majority of Rust servers expose JSON-RPC over standard input/output. Start a server in stdio mode:

rag-rat serve --mode stdio

Client Integration Example

Connect to a stdio-based server using Python's subprocess module:

import subprocess, json

proc = subprocess.Popen(
    ["rag-rat", "serve", "--mode", "stdio"],
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
    text=True,
)

request = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "search",
    "params": {"query": "tokenizer"}
}
proc.stdin.write(json.dumps(request) + "\n")
proc.stdin.flush()

response = json.loads(proc.stdout.readline())
print(response["result"])

Running HTTP Servers

Some infrastructure servers like toolport expose HTTP endpoints:

toolport --listen 0.0.0.0:8080

Query via HTTP POST:

curl -X POST http://localhost:8080 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"list","params":{}}'

Summary

• The awesome-mcp-servers repository catalogs over 20 Rust MCP servers marked with the 🦀 emoji in README.md, spanning infrastructure, development, and hardware domains.
• Infrastructure tools like toolport and shield leverage tokio and Rust's async runtime to provide gateway and security proxy capabilities.
• Browser automation servers utilize headless-chrome, CDP, and wasmtime for sandboxed JavaScript execution and DOM manipulation.
• Code intelligence platforms such as rag-rat and cratedocs-mcp integrate tantivy, sled, and rust-analyzer for high-performance indexing and documentation extraction.
• Database connectors including postgres-mcp-hardened and memkeeper use tokio-postgres and sqlite with embedded search engines for type-safe data operations.
• Hardware interfaces like embedded-debugger-mcp and serial-mcp-server wrap probe-rs and tokio-serial to expose physical device control via JSON-RPC.

Frequently Asked Questions

How do I identify Rust MCP servers in the awesome-mcp-servers repository?

Rust MCP servers are marked with the 🦀 emoji in the repository's README.md. You can locate specific implementations by searching for this emoji character within the markdown table, which identifies servers ranging from browser-use-rs to postgres-mcp-hardened.

What transport protocols do Rust MCP servers typically use?

Most Rust MCP servers communicate via stdio (standard input/output) using JSON-RPC 2.0, as implemented in crimson-crab-mcp-template and browser-use-rs. Infrastructure servers like toolport and rustunnel additionally expose HTTP endpoints for remote network access, while hardware servers use stdio to wrap low-level device commands.

Are these Rust MCP servers suitable for production use?

Several entries are explicitly designed for production deployment, including postgres-mcp-hardened with read-only defaults and hash-chain audit logs, shield with guardrail proxy capabilities, and sysknife with Ed25519-signed audit trails. Each project's individual maintenance status and security policies should be verified before sensitive production use.

How do Rust MCP servers handle authentication?

Authentication implementations vary by server purpose. toolport stores credentials in the OS keychain, while idencify-mcp and postgres-mcp-hardened support optional OAuth 2.1 flows. shield provides middleware-level request interception without requiring backend modifications, and sysknife implements TTL-based approval workflows for privileged system commands.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}