# Prism MCP SDK for Rust
[](https://crates.io/crates/prism-mcp-rs)
[](https://crates.io/crates/prism-mcp-rs)
[](https://docs.rs/prism-mcp-rs)
[](https://github.com/prismworks-ai/prism-mcp-rs/actions/workflows/ci.yml)
[](https://www.rust-lang.org/)
[](https://prismworks-ai.github.io/prism-mcp-rs/benchmarks/)
[](https://github.com/prismworks-ai/prism-mcp-rs/actions/workflows/security.yml)
[](https://codecov.io/gh/prismworks-ai/prism-mcp-rs)
[](https://opensource.org/licenses/MIT)
[](https://blog.rust-lang.org/2025/01/09/Rust-1.85.0.html)
[](https://deps.rs/repo/github/prismworks-ai/prism-mcp-rs)
[](https://crates.io/crates/prism-mcp-rs)
[](https://github.com/prismworks-ai/prism-mcp-rs/blob/main/CHANGELOG.md)
[](https://github.com/prismworks-ai/prism-mcp-rs/graphs/contributors)
[](https://github.com/prismworks-ai/prism-mcp-rs/commits/main)
[](https://github.com/prismworks-ai/prism-mcp-rs/releases)
[](https://discord.gg/prismworks)
[](https://github.com/rust-secure-code/safety-dance/)
**prism-mcp-rs** is a production-grade Rust implementation of the Model Context Protocol (MCP) SDK with enterprise-class features for building secure, scalable MCP servers and clients.
## Why Prism MCP?
**The first MCP SDK designed for production AI systems.** While other implementations focus on basic protocol compliance, Prism MCP brings enterprise-grade reliability patterns, zero-downtime operations, and plugin ecosystems that scale.
**Built for the AI-first world**: Where services need to be fault-tolerant, discoverable, and composable. Where hot-swapping capabilities matters more than cold starts. Where observability isn't optional—it's survival.
**From prototype to production in minutes**: Clean APIs that hide complexity, but expose power when you need it.
## Core Differentiators
### 1. Advanced Resilience Patterns
- **Circuit Breaker Pattern**: Automatic failure isolation preventing cascading failures
- **Adaptive Retry Policies**: Smart backoff with jitter and error-based retry decisions
- **Health Check System**: Multi-level health monitoring for transport, protocol, and resources
- **Graceful Degradation**: Automatic fallback strategies when services become unavailable
### 2. Enterprise Transport Features
- **Streaming HTTP/2**: Full multiplexing, server push, and flow control support
- **Adaptive Compression**: Dynamic selection of Gzip, Brotli, or Zstd based on content analysis
- **Chunked Transfer Encoding**: Efficient handling of large payloads with streaming
- **Connection Pooling**: Intelligent connection reuse with keep-alive management
- **TLS/mTLS Support**: Enterprise-grade security with certificate validation
### 3. Plugin System Architecture
- **Hot Reload Support**: Update plugins without service interruption
- **ABI-Stable Interface**: Binary compatibility across Rust versions
- **Plugin Isolation**: Sandboxed execution with resource limits
- **Dynamic Discovery**: Runtime plugin loading with dependency resolution
- **Lifecycle Management**: Automated plugin health monitoring and recovery
### 4. Protocol Extensions
- **Schema Introspection**: Complete runtime discovery of server capabilities
- **Batch Operations**: Efficient bulk request processing with transaction support
- **Progressive Content Delivery**: Streaming responses for large datasets
- **Rich Metadata Support**: Comprehensive annotations and capability negotiation
- **Custom Method Extensions**: Seamless protocol extensibility
### 5. Production Observability
- **Structured Logging**: Contextual tracing with correlation IDs
- **Metrics Collection**: Performance counters, histograms, and gauges
- **Distributed Tracing**: OpenTelemetry integration for request flow analysis
- **Error Forensics**: Detailed error context with stack traces and recovery hints
## Technical Architecture
### Core Components
| **Transport Layer** | Multi-protocol transport abstraction | STDIO, HTTP/1.1, HTTP/2, WebSocket, SSE |
| **Protocol Engine** | MCP 2025-06-18 implementation | JSON-RPC, batch operations, streaming |
| **Plugin Runtime** | Dynamic extension system | Hot reload, sandboxing, versioning |
| **Resilience Core** | Fault tolerance mechanisms | Circuit breakers, retries, health checks |
| **Security Module** | Authentication and authorization | JWT, OAuth2, mTLS, rate limiting |
### Performance Characteristics
- **Zero-Copy Operations**: Minimal memory allocation in hot paths
- **Async/Await Runtime**: Tokio-based non-blocking I/O
- **Connection Multiplexing**: Single TCP connection for multiple streams
- **Smart Buffering**: Adaptive buffer sizing based on throughput
- **CPU Affinity**: Thread pinning for cache optimization
## Installation
### Standard Installation
```toml
[dependencies]
prism-mcp-rs = "0.1.0"
tokio = { version = "1", features = ["full"] }
serde_json = "1.0"
async-trait = "0.1"
```
### Feature Matrix
| **Core Transports** | `stdio`, `http`, `websocket` | Basic connectivity |
| **HTTP Extensions** | `sse`, `http2`, `chunked-encoding`, `compression` | Advanced HTTP capabilities |
| **Security** | `auth`, `tls` | Authentication and encryption |
| **Extensions** | `plugin` | Runtime extensibility |
| **Bundles** | `full`, `minimal` | Convenience feature sets |
### Advanced Configuration
```toml
# High-performance configuration
[dependencies]
prism-mcp-rs = {
version = "0.1.0",
features = ["http2", "compression", "plugin", "auth", "tls"]
}
# Memory-constrained environments
[dependencies]
prism-mcp-rs = {
version = "0.1.0",
default-features = false,
features = ["stdio"]
}
```
## Clean & Simple API
### 30-Second Server Setup
```rust
use prism_mcp_rs::prelude::*;
use std::collections::HashMap;
#[derive(Clone)]
struct SystemToolHandler;
#[async_trait]
impl ToolHandler for SystemToolHandler {
async fn call(&self, arguments: HashMap<String, Value>) -> McpResult<ToolResult> {
match arguments.get("tool_name").and_then(|v| v.as_str()) {
Some("system_info") => {
let info = format!(
"Host: {}, OS: {}",
hostname::get().unwrap_or_default().to_string_lossy(),
std::env::consts::OS
);
Ok(ToolResult {
content: vec![ContentBlock::text(&info)],
is_error: Some(false),
meta: None,
structured_content: None,
})
},
_ => Err(McpError::invalid_request("Unknown tool"))
}
}
}
#[tokio::main]
async fn main() -> McpResult<()> {
let mut server = McpServer::new(
"system-server".to_string(),
"1.0.0".to_string()
);
// Add the system_info tool using the async add_tool method
server.add_tool(
"system_info",
Some("Get system information"),
json!({"type": "object", "properties": {}}),
SystemToolHandler,
).await?;
// Start server with STDIO transport
let transport = StdioServerTransport::new();
server.start(transport).await
}
```
### Enterprise-Grade Client
```rust
use prism_mcp_rs::prelude::*;
use prism_mcp_rs::transport::StdioClientTransport;
let transport = StdioClientTransport::new("./server");
let client = McpClient::new(
"test-client".to_string(),
"1.0.0".to_string()
);
client.initialize().await?;
client.set_transport(Box::new(transport)).await?;
// Make requests to the server
let tools_response = client.list_tools(None, None).await?;
let tool_result = client.call_tool(
"system_info".to_string(),
json!({})
).await?;
println!("Available tools: {:?}", tools_response);
println!("Tool result: {:?}", tool_result);
```
### Hot-Reloadable Plugins
```rust
use prism_mcp_rs::prelude::*;
use prism_mcp_rs::plugin::*;
use std::any::Any;
struct WeatherPlugin {
api_key: String,
}
#[async_trait]
impl ToolPlugin for WeatherPlugin {
fn metadata(&self) -> PluginMetadata {
PluginMetadata {
id: "weather-plugin".to_string(),
name: "Weather Plugin".to_string(),
version: "1.0.0".to_string(),
author: Some("Example Author".to_string()),
description: Some("Provides weather information".to_string()),
homepage: None,
license: Some("MIT".to_string()),
mcp_version: "1.1.0".to_string(),
capabilities: PluginCapabilities::default(),
dependencies: vec![],
}
}
fn tool_definition(&self) -> Tool {
Tool::new(
"get_weather".to_string(),
Some("Get weather information for a location".to_string()),
json!({
"type": "object",
"properties": {
"location": {"type": "string", "description": "Location to get weather for"}
},
"required": ["location"]
}),
EchoTool // Placeholder - would use actual weather handler
)
}
async fn execute(&self, arguments: Value) -> McpResult<ToolResult> {
let location = arguments["location"].as_str().unwrap_or("Unknown");
let weather_data = json!({
"location": location,
"temperature": "22°C",
"condition": "Sunny"
});
Ok(ToolResult {
content: vec![ContentBlock::text(&format!("Weather in {}: {}", location, weather_data))],
is_error: Some(false),
meta: None,
structured_content: Some(weather_data),
})
}
fn as_any(&self) -> &dyn Any {
self
}
}
// Runtime plugin management
let mut plugin_manager = PluginManager::new();
plugin_manager.reload_plugin("weather_plugin").await?; // Hot reload support
```
## Architectural Innovations
### Zero-Configuration Service Discovery
Automatic capability negotiation and runtime schema introspection eliminates manual configuration:
```rust
// Client connects and discovers server capabilities
let transport = StdioClientTransport::new("./server");
let client = McpClient::new("discovery-client".to_string(), "1.0.0".to_string());
client.initialize().await?;
client.set_transport(Box::new(transport)).await?;
// Discover server capabilities through initialization
let server_info = client.get_server_info().await?;
println!("Server capabilities: {:?}", server_info.capabilities);
```
### Fault-Tolerant by Design
Built-in resilience patterns prevent cascading failures in distributed AI systems:
```rust
// Basic tool call with proper error handling
let result = match client.call_tool("analyze".to_string(), data).await {
Ok(result) => result,
Err(e) => {
eprintln!("Tool call failed: {}", e);
// Implement your own fallback logic here
return Err(e);
}
};
```
### Plugin Ecosystem Revolution
Hot-swappable plugins with ABI stability across Rust versions:
```rust
// Plugin lifecycle management
plugin_manager.unload_plugin("analyzer_v1").await?;
plugin_manager.load_plugin("analyzer_v2.so").await?;
// Plugin health monitoring
let health = plugin_manager.check_plugin_health("analyzer_v2").await?;
```
## New Use Cases Enabled
### **Multi-Agent AI Orchestration**
Combine multiple AI services with automatic failover and load balancing.
### **Enterprise Integration Hubs**
Connect legacy systems to modern AI tools with protocol translation and security policies.
### **Real-Time AI Pipelines**
Build streaming data processing pipelines with sub-millisecond latency guarantees.
### **Federated AI Networks**
Create distributed AI service meshes with automatic service discovery and routing.
### **Edge AI Deployment**
Deploy AI capabilities to edge devices with offline-first architecture and smart sync.
## Production-Ready Performance
| **Zero-downtime deployments** | < 100ms | Keep AI services running during updates |
| **Automatic failover** | < 50ms | No user-visible service interruptions |
| **Memory efficiency** | 2-12MB baseline | Deploy to edge and resource-constrained environments |
| **Protocol overhead** | < 0.5ms | Sub-millisecond response times for real-time AI |
## Security & Supply Chain
### **🔒 Security-First Design**
- **Memory Safety**: 100% safe Rust with minimal unsafe blocks (only in plugin FFI)
- **TLS 1.3**: Modern encryption with rustls and ring cryptography
- **Supply Chain Security**: Comprehensive dependency auditing with cargo-audit, cargo-deny, and cargo-vet
- **Vulnerability Monitoring**: Automated security scans and dependency updates
- **License Compliance**: All dependencies verified against approved open-source licenses
### **🛡️ Security Features**
- **Authentication**: JWT tokens with configurable expiration and refresh
- **Authorization**: Role-based access control with fine-grained permissions
- **Input Validation**: Comprehensive request validation and sanitization
- **Rate Limiting**: Configurable request throttling and DDoS protection
- **Audit Logging**: Security event logging with structured output
### **📊 Supply Chain Transparency**
- **Dependencies**: 379 crates, all security-audited
- **Vulnerabilities**: Zero known security vulnerabilities
- **License Review**: MIT-compatible licensing across entire dependency tree
- **Update Frequency**: Weekly automated security audits and monthly dependency updates
- **Audit Trail**: Complete supply chain verification with Mozilla import chain
### **🔧 Security Tools**
```bash
# Run security audit
./scripts/security-audit.sh
# Update dependencies safely
./scripts/update-dependencies.sh
# Check supply chain status
cargo vet check
cargo deny check all
cargo audit
```
## Documentation
### **📚 Getting Started**
- [Quick Start Guide](docs/GETTING_STARTED.md) - Installation, setup, and first steps
- [AI Tool Integration](docs/AI_TOOL_INTEGRATION.md) - Connect to Claude, Cursor, VS Code, Windsurf
- [Configuration Examples](docs/examples/ai-tool-configs/README.md) - Ready-to-use configuration templates
- [API Reference](https://docs.rs/prism-mcp-rs) - Complete API documentation
### **🚀 Deployment & Production**
- [Deployment Guide](docs/DEPLOYMENT_GUIDE.md) - Production deployment strategies
- [Troubleshooting Guide](docs/TROUBLESHOOTING.md) - Common issues and solutions
### **🏗️ Development Guides**
- [Architecture Guide](docs/ARCHITECTURE.md) - System design and components
- [Plugin Development](docs/guides/plugins.md) - Building custom plugins
- [Plugin Types Reference](docs/guides/plugin-types.md) - Detailed component specifications
- [Error Handling](docs/guides/error-handling.md) - Comprehensive error management patterns
- [Performance Tuning](docs/guides/performance.md) - Optimization strategies
- [Authentication Guide](docs/guides/authentication.md) - Authentication and authorization
- [Development Setup](docs/DEVELOPMENT.md) - Development environment and workflows
### **🔄 Migration & Updates**
- [Migration Guide](docs/guides/migration.md) - Migrating from other MCP implementations
- [Changelog](CHANGELOG.md) - Version history and breaking changes
### **🔒 Security & Policies**
- [Security Policy](SECURITY.md) - Vulnerability reporting and security practices
## Contributing
Contributions are welcome! Please review our [Contributing Guidelines](CONTRIBUTING.md) and [Code of Conduct](CODE_OF_CONDUCT.md).
See our [Contributors](CONTRIBUTORS.md) for a list of everyone who has contributed to this project.
## License
MIT License - see [LICENSE](LICENSE) for details.
## Support
- GitHub Issues: [Bug Reports & Feature Requests](https://github.com/prismworks-ai/prism-mcp-rs/issues)
- Discord: [Community Support](https://discord.gg/prismworks)
- Email: developers@prismworks.ai