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

> Discover over 20 Rust MCP servers in the awesome-mcp-servers repository. Find browser automation tools, code intelligence platforms, database connectors, and more.

- Repository: [Frank Fiegel/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)
- Tags: getting-started
- Published: 2026-09-06

---

**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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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:

```bash

# 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:

```bash
rag-rat serve --mode stdio

```

### Client Integration Example

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

```python
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:

```bash
toolport --listen 0.0.0.0:8080

```

Query via HTTP POST:

```bash
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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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.