Build Model Context Protocol (MCP) servers and clients in Rust — from a five-line tool server to serverless AWS Lambda deployments.
Turul gives you the full MCP surface (tools, resources, prompts, completion, notifications, extensions) behind a zero-configuration builder API: annotate a function or derive on a struct, add it to the builder, run. The framework generates the schemas, wires the transport, and keeps you spec-compliant.
Production-ready Rust framework for Model Context Protocol (MCP) servers and clients. Default build targets MCP 2026-07-28 (stateless core); 2025-11-25 stays supported as an opt-in lane. Zero-config builder API, derive/function macros, Streamable HTTP + SSE, AWS Lambda, pluggable storage.
The default build targets MCP 2026-07-28, the current specification. The previous spec, 2025-11-25, remains buildable as an opt-in lane (--no-default-features --features protocol-2025-11-25) from a workspace checkout only — not supported from crates.io: the published 2025-11-25 crates resolve turul-rpc 0.1 while the 0.4 crates use 0.2, so enabling the feature on a published 0.4.x crate fails to compile.
A server speaks one spec or the other — never both at once. The two protocol features are mutually exclusive at compile time, so a given server binary is either 2026-07-28 or 2025-11-25. The client is different: it links both and negotiates per connection. See Single-era servers for what that means for clients trying to reach you.
Pre-1.0 (0.4.x): production-shaped — comprehensive test coverage, zero-warning gates — but public APIs may still change before 1.0.0.
📚 Comprehensive Examples: Real-world business applications and framework demonstrations (most build on the 2026-07-28 default lane; a 2025-11-25 regression set is pinned to the opt-in, and client-using examples are built by explicit CI steps — see EXAMPLES.md)
🧪 Framework-Native Test Suite: Core framework tests, SessionContext integration tests, and framework-native integration tests
⚡ Multiple Development Patterns: Derive macros, function attributes, declarative macros, and manual implementation
🌐 Transport Flexibility: Streamable HTTP via StreamableHttpHandler with SSE streaming (stdio planned)
☁️ Serverless Support: AWS Lambda integration with streaming responses and SQS event processing
🔧 Development Features: Session management, real-time notifications, performance monitoring, and UUID v7 support
🚀 Quick Start
Dependencies
The macros need six crates, not two.#[mcp_tool] and #[derive(McpTool)]
expand to code that names serde_json, async_trait, turul_mcp_builders and
turul_mcp_protocol directly. Generated code is compiled in your crate, so
those names resolve against your dependency list — all four must be your
direct dependencies alongside the two obvious ones. Omit them and you get a wall
of E0433 cannot find module or crate … plus unsatisfied Has* trait bounds
pointing at macro-generated code.
This is how the framework works, not a defect: all 33 macro-using examples in
this repo declare the same six. The list below is simply what those examples
already do.
use turul_mcp_derive::mcp_tool;
use turul_mcp_server::prelude::*;
#[mcp_tool(name = "add", description = "Add two numbers")]
async fn add(
#[param(description = "First number")] a: f64,
#[param(description = "Second number")] b: f64,
) -> McpResult<f64> {
Ok(a + b) // Function macro wraps as {"result": 8.0} (override with output_field)
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Bind the address through a typed `let` — inlining `.parse()?` into
// `.bind_address(...)` makes `?` resolve against McpError, which has no
// `From<AddrParseError>`, and fails to compile.
let bind_address: std::net::SocketAddr = "127.0.0.1:8641".parse()?;
let server = McpServer::builder()
.name("calculator-server")
.version("1.0.0")
.tool_fn(add) // Use function name directly
.bind_address(bind_address)
.build()?;
server.run().await?; // `run()` yields Result<(), McpError>, so `?` then Ok(())
Ok(())
}
Create resources that provide data and files using the .resource_fn() method:
use turul_mcp_derive::mcp_resource;
use turul_mcp_server::prelude::*;
use turul_mcp_protocol::resources::ResourceContent;
// Static resource
#[mcp_resource(
uri = "file:///config.json",
name = "config",
description = "Application configuration"
)]
async fn get_config() -> McpResult<Vec<ResourceContent>> {
let config = serde_json::json!({
"app_name": "My Server",
"version": "1.0.0"
});
Ok(vec![ResourceContent::blob(
"file:///config.json",
serde_json::to_string_pretty(&config).unwrap(),
"application/json".to_string()
)])
}
// Template resource with parameter extraction
#[mcp_resource(
uri = "file:///users/{user_id}.json",
name = "user_profile",
description = "User profile data"
)]
async fn get_user_profile(user_id: String) -> McpResult<Vec<ResourceContent>> {
let profile = serde_json::json!({
"user_id": user_id,
"username": format!("user_{}", user_id),
"email": format!("{}@example.com", user_id)
});
Ok(vec![ResourceContent::blob(
format!("file:///users/{}.json", user_id),
serde_json::to_string_pretty(&profile).unwrap(),
"application/json".to_string()
)])
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let bind_address: std::net::SocketAddr = "127.0.0.1:8643".parse()?; // Different port
let server = McpServer::builder()
.name("resource-server")
.version("1.0.0")
.resource_fn(get_config) // Static resource
.resource_fn(get_user_profile) // Template: file:///users/{user_id}.json
.bind_address(bind_address)
.build()?;
server.run().await?;
Ok(())
}
The framework automatically:
Detects URI templates ({user_id} patterns)
Extracts template variables from requests
Maps them to function parameters
Registers appropriate resource handlers
The MCP 2026-07-28 specification
The default build targets MCP 2026-07-28, the current specification — a stateless
rewrite of the protocol with several core methods removed. New to MCP? You can skim
this section and come back later. Migrating from 2025-11-25? Read it first.
What's new (and implemented here)
Stateless core — server/discover advertises versions/capabilities/identity;
every request carries protocolVersion + clientInfo + clientCapabilities in
_meta under io.modelcontextprotocol/*. Any server instance serves any request.
MRTR (Multi-Round-Trip Requests, SEP-2322) — a tool/resource/prompt returns an
InputRequiredResult to ask for elicitation/sampling/roots input; the client
answers and retries the original call. This replaces all server-initiated requests.
→ examples/mrtr-elicitation-server
subscriptions/listen — the ack-first, filtered, long-lived POST SSE stream that
replaces 2025's GET-SSE resumability and the resources/subscribe RPC.
SEP-2243 request-metadata headers — Mcp-Method / Mcp-Name / Mcp-Param-* let
infrastructure route on method/tool/arguments without parsing JSON bodies.
→ examples/header-bound-tools-server
Origin validation / DNS-rebinding protection — on by default (ADR-031).
→ examples/origin-policy-server
JSON Schema 2020-12, caching headers (ttlMs / cacheScope on list/read
results), and OAuth 2.1 Resource Server hardening (RFC 9207/9728).
What changed from 2025-11-25
No handshake — initialize → notifications/initialized → Mcp-Session-Id is
gone; capabilities ride per-request _meta instead.
Error codes — resource-not-found moved from -32002 to -32602; new
-32020 (header mismatch), -32021 (missing required client capability),
-32022 (unsupported protocol version).
Per-request logging — log level is set per-request via io.modelcontextprotocol/logLevel
in _meta; servers must not emit notifications/message for requests that didn't opt in.
Deprecations (SEP-2577) — Roots, Sampling, and Logging are deprecated (earliest
removal 2027-07-28). Still implemented; on 2026 the server-initiated forms ride MRTR.
What's removed from the core (2026 default → these 404 / 405)
the Tasks extension (tasks/get polling + tasks/update)
2025-11-25 remains buildable as the opt-in stateful lane
(--no-default-features --features protocol-2025-11-25) from a workspace checkout only — not supported from crates.io: the published 2025-11-25 crates resolve turul-rpc 0.1 while the 0.4 crates use 0.2, so enabling the feature on a published 0.4.x crate fails to compile. In a checkout the handshake, sessions,
GET SSE, and core tasks all work there. Per-requirement compliance status:
docs/plans/2026-07-28-spec-compliance.md.
Single-era servers (not dual-era)
The 2026-07-28 spec names three server postures in
§Versioning and Compatibility:
modern (per-request _meta), legacy (initialize handshake), and dual-era —
one implementation serving both, which the spec permits to run "concurrently on the same
endpoint or process".
Turul servers are single-era by construction.protocol-2026-07-28 and
protocol-2025-11-25 are mutually exclusive Cargo features enforced by a
compile_error!, so a binary is one era or the other — never both. Turul does not
implement dual-era servers.
This is a conformant choice: the spec makes dual-era a MAY, not a requirement. But it
has one consequence worth knowing before you pick a lane, because it is not symmetric:
Client era
Turul server built as
Outcome
Modern (2026-07-28)
2026-07-28 default
Works
Legacy (2025-11-25)
2025-11-25 opt-in
Works
Legacy (2025-11-25)
2026-07-28 default
Fails — legacy clients have no fall-forward mechanism
Modern (2026-07-28)
2025-11-25 opt-in
Fails
A legacy client sending initialize to a 2026-default turul server gets:
The data.supported list is deliberate — the spec says a modern-only server SHOULD
name the versions it supports in any error it returns to initialize, because for a
legacy client "this message may be the only diagnostic they can surface to users".
If you need to serve both eras, run two instances (one per lane) behind your own
routing. There is no single-binary dual-era mode, and adding one is not a flag: the
server's whole type vocabulary and the derive macros' expansion both resolve through the
single-spec turul-mcp-protocol alias.
Clients are unaffected.turul-mcp-client links both protocol crates and picks the
era per connection — it probes server/discover and falls back to initialize only on
-32601. So a turul client reaches both kinds of server; only turul servers are
single-era.
🚀 Running & Testing the Framework
Quick Start - Verify Everything Works
# 1. Build the framework
cargo build --workspace
# 2. Run compliance tests
cargo test -p turul-mcp-framework-integration-tests --test compliance
# 3. Start a simple server
cargo run -p minimal-server
# 4. Test the server (in another terminal) — 2026-07-28 stateless: no handshake,
# capabilities travel in per-request `_meta`, no Mcp-Session-Id header.
curl -X POST http://127.0.0.1:8641/mcp \
-H 'Content-Type: application/json' \
-H 'MCP-Protocol-Version: 2026-07-28' \
-H 'Mcp-Method: server/discover' \
-d '{"jsonrpc":"2.0","method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"test","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{}}},"id":1}'
Example Servers - Ready to Run
Core Test Servers (manifest-pinned to the 2025-11-25 opt-in lane — they are the stateful regression fixtures, so use the 2025 handshake against them, not the 2026 server/discover curls below):
# Tools server (test tools)
cargo run --package tools-test-server -- --port 8002
# Resource server (test resources)
cargo run --package resource-test-server -- --port 8080
# Prompts server (test prompts)
cargo run --package prompts-test-server -- --port 8081
Business Application Servers:
# Development team resources
cargo run -p resources-server -- --port 8041
# AI development prompts
cargo run -p prompts-server -- --port 8040
# Real-time notifications
cargo run -p notification-server
# Session management demo (2025-11-25 stateful lane — manifest-pinned)
cargo run -p stateful-server
The default build is stateless: there is no initialize handshake and no Mcp-Session-Id
header. Capabilities, client info, and the protocol version travel in _meta on every
request under the io.modelcontextprotocol/* namespace. Use a 2026-default server such
as minimal-server (port 8641) — the *-test-server fixtures above are 2025-pinned and
will not answer server/discover.
2025-11-25 (opt-in): build with --no-default-features --features protocol-2025-11-25
and the stateful handshake applies instead — initialize → notifications/initialized →
Mcp-Session-Id header on every subsequent request:
For detailed testing instructions, server running guides, and compliance verification:
📚 Testing: lane-by-lane gates run via ./scripts/ci-gates.sh all; the per-requirement test inventory is docs/plans/2026-07-28-spec-compliance.md §E2E test plan
🔧 Driving it by hand: docs/manual-e2e-matrix.md — which client to point at which server, per lane and across lanes, plus the interop, Lambda and curl paths
This guide includes:
✅ All server running instructions with expected outputs
# Create and run compliance check
cat > quick_check.sh << 'EOF'
#!/bin/bash
PORT=${1:-8080}
echo "🧪 Testing MCP server on port $PORT"
DISCOVER_RESPONSE=$(curl -s -X POST http://127.0.0.1:$PORT/mcp \
-H 'Content-Type: application/json' \
-H 'MCP-Protocol-Version: 2026-07-28' \
-H 'Mcp-Method: server/discover' \
-d '{"jsonrpc":"2.0","method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"test","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{}}},"id":1}')
if [[ $(echo $DISCOVER_RESPONSE | jq -r '.result.serverInfo.name // empty') != "" ]]; then
echo "✅ MCP 2026-07-28 server/discover responded"
else
echo "❌ Not compliant"
exit 1
fi
EOF
chmod +x quick_check.sh
# Test any server
cargo run -p minimal-server &
./quick_check.sh 8641
Turul MCP vs Turul RPC
This project ships two layered surfaces. Most users only need the MCP layer.
turul-mcp (this framework) — the Model Context Protocol implementation. Tools, resources, prompts, sampling, elicitation, tasks, sessions, Streamable HTTP/SSE transport, the macro suite, storage backends.
turul-rpc — generic, transport-agnostic typed JSON-RPC 2.0 framework: dispatch, domain/protocol error separation, optional session context, async handler trait, batch processing, notifications. No MCP knowledge. Useful as a foundation for any non-MCP request/response service that wants the same handler-returns-domain-error contract Turul uses internally.
Turul MCP is built on top of Turul RPC. The turul-mcp-json-rpc-server crate, which historically carried the JSON-RPC implementation, is a thin re-export shim over turul-rpc since v0.3.39. Existing 0.3.x users do not need to change anything — turul_mcp_json_rpc_server::* imports continue to compile and behave identically. New code (and new tools/agents reading this README) should depend on turul-rpc directly. See ADR-025.
🏛️ Architecture Overview
Middleware System
The framework provides a trait-based middleware architecture for cross-cutting concerns like authentication, logging, and rate limiting:
use turul_mcp_server::prelude::*;
use std::sync::Arc;
let server = McpServer::builder()
.middleware(Arc::new(AuthMiddleware::new()))
.middleware(Arc::new(LoggingMiddleware))
.middleware(Arc::new(RateLimitMiddleware::new(5, 60)))
.build()?;
Key Features:
✅ Transport-agnostic (HTTP, Lambda, etc.)
✅ Session-aware (read/write session state)
✅ Error short-circuiting with semantic JSON-RPC codes
✅ Execution order control (FIFO before, LIFO after dispatch)
Examples:
examples/middleware-logging-server - Request timing and tracing (HTTP)
turul-mcp-task-storage - Task storage for long-running operations (InMemory, with pluggable backends)
turul-mcp-server-state-storage - Server-global state for dynamic tool coordination
turul-mcp-aws-lambda - AWS Lambda integration for serverless deployment
turul-mcp-oauth - OAuth 2.1 Resource Server support (JWT validation, Bearer middleware)
Tasks Architecture
Tasks moved from a core capability (2025-11-25) to an extension (2026-07-28), and the framework implements both:
2026-07-28 — the io.modelcontextprotocol/tasks extension (SEP-2663) in turul-mcp-ext-tasks, wired into the server behind the opt-in ext-tasks feature (.with_ext_tasks(store) + .ext_task_tool(...)) and the client (call_tool_or_task, task_get/task_update/task_cancel/task_wait). Server election, the -32003 capability gate, mid-task input via tasks/update, and notifications/tasks over subscriptions/listen are all implemented. See examples/ext-tasks-server.
2025-11-25 opt-in — the original in-tree core task runtime, gated to #[cfg(feature = "protocol-2025-11-25")] (protocol types, storage, runtime, handlers, tests).
Enabling it, per lane:
2026-07-28 — enable the ext-tasks feature, register the store with
.with_ext_tasks(store), and mark electable tools with .ext_task_tool(tool).
2025-11-25 opt-in — add task_support = "optional" ("optional" / "required" /
"forbidden") to the tool macro to enable the "Run as Task" button in MCP Inspector;
requires .with_task_storage() on the builder. This attribute does not compile on
the 2026 default lane — tasks are an extension there, not a tool attribute.
2026-07-28 note: Roots, Sampling, and Logging are deprecated in the 2026-07-28 spec
(SEP-2577, earliest removal 2027-07-28). They remain implemented; on the 2026 default
the server-initiated forms ride Multi Round-Trip Requests, and notifications/message
requires the per-request logLevel opt-in.
Comprehensive Server Builder
All MCP areas supported with consistent builder pattern:
⚠️ Roots (RootDefinition) - Secure file system access boundaries — deprecated on 2026 (SEP-2577); rides MRTR
⚠️ Sampling (SamplingDefinition) - AI model integration patterns — deprecated on 2026 (SEP-2577); rides MRTR
✅ Tasks — Tasks extension on 2026 (turul-mcp-ext-tasks); core capability on the 2025-11-25 opt-in
✅ Session Management - Stateful operations with UUID v7 — 2025-11-25 opt-in only; the 2026 core is stateless
Transport Support
Streamable HTTP - Production transport via StreamableHttpHandler (HTTP/1.1 & HTTP/2 with chunked SSE; stateless on the 2026-07-28 default, stateful with GET SSE on the 2025-11-25 opt-in)
HTTP+SSE (Legacy) - Backward-compatible transport via SessionMcpHandler (protocol <= 2024-11-05)
AWS Lambda - Serverless deployment with streaming responses
Stdio - Planned for future implementation
Note: The framework auto-selects transport handler based on protocol version negotiation.
📚 Examples Overview
🏢 Real-World Business Applications
Development servers for actual business problems:
audit-trail-server → Application Audit & Compliance System (SQLite-backed)
elicitation-server → Customer Onboarding Platform
notification-server → Development Team Alert System
Best for: Dynamic tools, configuration-driven systems
use turul_mcp_server::prelude::*;
use serde_json::json;
let multiply_tool = ToolBuilder::new("multiply")
.description("Multiply two numbers")
.number_param("a", "First number")
.number_param("b", "Second number")
.number_output() // Generates {"result": number} schema
.execute(|args| async move {
let a = args.get("a").and_then(|v| v.as_f64())
.ok_or("Missing parameter 'a'")?;
let b = args.get("b").and_then(|v| v.as_f64())
.ok_or("Missing parameter 'b'")?;
Ok(json!({"result": a * b}))
})
.build()
.map_err(|e| format!("Failed to build tool: {}", e))?;
// Usage in server
let server = McpServer::builder()
.name("calculator-server")
.version("1.0.0")
.tool(multiply_tool)
.build()?;
4. Manual Implementation (Maximum Control)
Best for: Performance optimization, custom behavior
use turul_mcp_server::prelude::*; // Re-exports builders prelude + framework traits
use turul_mcp_protocol::{ToolSchema, ToolResult, schema::JsonSchema, McpResult};
use async_trait::async_trait;
use serde_json::Value;
use std::collections::HashMap;
struct ManualTool;
impl HasBaseMetadata for ManualTool {
fn name(&self) -> &str { "manual_tool" }
}
impl HasDescription for ManualTool {
fn description(&self) -> Option<&str> { Some("Manual implementation with full control") }
}
impl HasInputSchema for ManualTool {
fn input_schema(&self) -> &ToolSchema {
static SCHEMA: std::sync::OnceLock<ToolSchema> = std::sync::OnceLock::new();
SCHEMA.get_or_init(|| {
ToolSchema::object()
.with_properties(HashMap::from([
("input".to_string(), JsonSchema::string())
]))
})
}
}
impl HasOutputSchema for ManualTool {
fn output_schema(&self) -> Option<&ToolSchema> { None }
}
impl HasAnnotations for ManualTool {
fn annotations(&self) -> Option<&ToolAnnotations> { None }
}
impl HasToolMeta for ManualTool {
fn tool_meta(&self) -> Option<&HashMap<String, Value>> { None }
}
impl HasIcons for ManualTool {} // No icons
impl HasExecution for ManualTool {} // No task support
#[async_trait]
impl McpTool for ManualTool {
async fn call(&self, _args: Value, _session: Option<SessionContext>)
-> McpResult<CallToolResult> {
// Full control over implementation
Ok(CallToolResult::success(vec![
ToolResult::text("Manual tool with complete control")
]))
}
}
// Usage in server
let server = McpServer::builder()
.name("manual-server")
.version("1.0.0")
.tool(ManualTool)
.build()?;
🔧 Client Library
Comprehensive MCP client for HTTP transport:
use turul_mcp_client::{McpClient, McpClientBuilder, transport::HttpTransport};
use std::time::Duration;
// Create HTTP transport
let transport = HttpTransport::new("http://localhost:8080/mcp")?;
// Create client using builder pattern
let client = McpClientBuilder::new()
.with_transport(Box::new(transport))
.build();
// Connect — negotiates the wire spec per connection
// (2026-07-28 `server/discover` first, falls back to 2025-11-25 `initialize`)
client.connect().await?;
// List available tools
let tools = client.list_tools().await?;
// Call a tool
let result = client.call_tool("add", json!({
"a": 10.0,
"b": 20.0
})).await?;
// List and read resources
let resources = client.list_resources().await?;
let content = client.read_resource("config://app.json").await?;
🚀 Performance Features
Modern Architecture
UUID v7 - Time-ordered IDs for better database performance and observability
Workspace Dependencies - Consistent dependency management across the framework crates and examples
Rust 2024 Edition - Latest language features and performance improvements
Tokio/Hyper - High-performance async runtime with HTTP/2 support
Development Quality
Session Management - Automatic cleanup and state persistence
The 2026 core is stateless. Sessions, the Mcp-Session-Id header, and the session
lifecycle (DELETE termination, TTL/expiry) are part of the 2025-11-25 opt-in lane;
the client-initialise-server + session-management-compliance-test packages exercise
them under that pin.
🛠️ Development & Testing
Building the Framework
# Build all workspace crates
cargo build
# Build with release optimizations
cargo build --release
Running Tests
The framework includes a comprehensive test suite covering all functionality. Test server binaries are automatically built when needed - no manual setup required.
# Run all tests (recommended - includes E2E integration tests)
cargo test --workspace
# Run the full lane-by-lane gate suite (2026 default + 2025 opt-in matrix)
./scripts/ci-gates.sh all
# Run a 2026 wire-acceptance suite directly
cargo test -p turul-mcp-server --no-default-features --features http,sse,protocol-2026-07-28 --test discover_stateless_2026
# Run with logging output
RUST_LOG=info cargo test --workspace
Key Features:
✅ Auto-build test servers - Missing test binaries are built automatically on first test run
✅ Zero configuration - Just run cargo test and everything works
✅ Clean workspace support - cargo clean && cargo test works without manual steps
The test infrastructure automatically builds required test server binaries (resource-test-server, prompts-test-server, tools-test-server, etc.) when running integration tests. This ensures a seamless developer experience.
Notifications & Streaming
On the 2026 default, notifications ride POST SSE — request-scoped notifications
(notifications/progress, notifications/message) flow on the originating request's
own response stream, and server-push subscriptions use the long-lived
subscriptions/listen POST stream. The 2025-era GET-SSE endpoint and
Mcp-Session-Id-keyed streams are part of the 2025-11-25 opt-in lane (the HTTP+SSE
transport is deprecated upstream, SEP-2596).
Live demo: cargo run -p notification-server, then drive it with
cargo run -p streamable-http-client http://127.0.0.1:8005/mcp (opens a
subscriptions/listen stream and triggers list-changed + resource-update deliveries).
Rust Community - For exceptional tooling and ecosystem
📋 Development Status & Current Limitations
🎯 Current Framework State
MCP 2026-07-28: default build targets the current stateless spec; 2025-11-25 remains buildable from a workspace checkout as the opt-in stateful line (not supported from crates.io)
Examples Validated: 54 active examples compile under their lane's CI gates (2026-07-28 default lane plus the pinned 2025-11-25 regression set — see EXAMPLES.md)
SSE Streaming Verified: Real-time notifications and session-aware logging working correctly
Pre-1.0 (0.4.x): production-shaped with comprehensive test coverage; public APIs may still change before 1.0.0
🚧 Current Limitations
Transport & Streaming:
Lambda SSE: Snapshot-based responses via handle(), real-time streaming via run_streaming() / run_streaming_with() with graceful completion-invocation handling
Additional transport variants: Streamable HTTP and legacy HTTP+SSE are supported; stdio remains planned
CI Environment Testing: SSE tests require port binding capabilities (graceful fallbacks implemented)
Features & Integration:
Resource Subscriptions: on the 2026-07-28 default, resource-update notifications ride the subscriptions/listen stream (resources.subscribe is advertised); the 2025-11-25 opt-in path does not implement the legacy resources/subscribe RPC
Authentication Middleware: OAuth 2.1 Resource Server support via turul-mcp-oauth (JWT validation, Bearer token middleware, .well-known metadata)
Cross-platform Compatibility: Primarily tested on Linux development environments
Concurrency Stress Testing: Some resource tests show occasional failures under extreme load
Browser Compatibility: CORS support available but may need tuning for specific client requirements
Framework Philosophy: We prioritize honest documentation over inflated claims. The limitations above reflect our commitment to transparency about the current development state.
💡 Need help? Open an issue or check our examples covering everything from simple calculators to enterprise systems.
T
Turul MCP Framework
aussierobots·2 stars·
Production-ready Rust framework for Model Context Protocol (MCP) servers and clients. Default build targets MCP 2026-07-28 (stateless core); 2025-11-25 stays supported as an opt-in lane. Zero-config b