Add native MCP server support to position Restate as the reliability platform for AI agents

[bug-ops]

Native MCP (Model Context Protocol) Support in Restate

Summary

Model Context Protocol (MCP) servers in Restate. MCP is rapidly becoming the standard for AI agent tooling, with official SDKs from Anthropic and growing adoption across the ecosystem. By supporting MCP natively, Restate can become the go-to platform for building reliable, production-ready AI agent systems.

Context

MCP enables LLMs to interact with external tools and data sources through a standardized protocol. While MCP clients can connect directly to MCP servers, production deployments face challenges that Restate is uniquely positioned to solve:

• Reliability: MCP tool calls often involve external APIs that can fail
• State Management: Agent workflows need to maintain context across multiple tool calls
• Orchestration: Complex agent behaviors require coordinating multiple MCP servers
• Observability: Understanding what agents are doing in production

Restate's durable execution model is a perfect match for these requirements.

Proposal

I propose a phased approach to add MCP support to Restate:

Phase 1: Basic MCP Server Support (MVP)

Enable deploying MCP servers as Restate services with minimal changes:

# Deploy an MCP server to Restate
restate deployments register-mcp stdio://path/to/mcp-server

# Or with a container
restate deployments register-mcp docker://mcp/weather-server:latest

Implementation:

1. Create restate-mcp crate using rmcp
2. Add MCP discovery endpoint that translates MCP tools to Restate service methods
3. Support stdio transport initially (most common for MCP servers)
4. Map MCP tool calls to Restate handlers with automatic durability

Example usage:

// MCP tools automatically exposed as Restate services
const weather = await ctx.serviceClient(MCPWeatherService)
  .getTodaysForecast({ location: "Seattle" });

Phase 2: MCP Gateway Capabilities

Transform Restate into an intelligent MCP gateway:

// Single endpoint for multiple MCP servers
const gateway = ctx.serviceClient(MCPGateway);

// Discover all available tools
const tools = await gateway.listTools();

// Call any tool with automatic routing
const result = await gateway.callTool({
  tool: "web_search",  // Gateway finds the right server
  params: { query: "latest AI news" }
});

Features:

• Service discovery and registry for MCP servers
• Automatic routing based on tool names
• Load balancing across multiple servers
• Protocol version negotiation

Phase 3: Production Features

Add enterprise-grade capabilities:

1. Connection pooling for MCP servers
2. Caching frequently used tool results
3. Rate limiting and quota management
4. Security with per-tool access control
5. Monitoring with MCP-specific metrics

Phase 4: Advanced Integration

Deep integration with Restate features:

1. Workflows: First-class support for MCP tools in workflows
2. State: Automatic session management for stateful MCP interactions
3. Events: MCP servers can emit events into Restate
4. UI: MCP tool calls visible in Restate Admin UI

Benefits

1. For Restate users: Easy integration with the growing MCP ecosystem
2. For MCP developers: Production-ready deployment platform with built-in reliability
3. For the ecosystem: Bridges the gap between AI tools and distributed systems

Technical Approach

• Leverage existing rmcp crate for protocol implementation
• Minimal changes to core Restate - implement as a new service type
• Reuse existing deployment and discovery mechanisms
• Build on Restate's HTTP/2 streaming for transport

Success Metrics

• Deploy any MCP server to Restate with a single command
• Zero changes required to existing MCP server code
• Full durability and observability for MCP tool calls
• Performance overhead < 5ms per tool call

Why This Matters Now

1. AI Agent adoption is exploding: Every major AI company is building agent frameworks
2. MCP is becoming the standard: Official support from Anthropic, growing ecosystem
3. Production challenges are real: Agents need reliability, state, and orchestration
4. Unique positioning: Restate + MCP could own the "reliable AI agents" category

[bug-ops]

Example Use Case

// Research agent that coordinates multiple MCP tools reliably
@workflow("research-agent")
class ResearchWorkflow {
  @handler()
  async run(ctx: WorkflowContext, topic: string) {
    // 1. Search across multiple sources (with automatic retry)
    const sources = await ctx.run("gather-sources", async () => {
      return Promise.all([
        ctx.serviceClient(WebSearchMCP).search({ query: topic }),
        ctx.serviceClient(ArxivMCP).searchPapers({ topic }),
        ctx.serviceClient(NewsMCP).getRecent({ topic })
      ]);
    });
    
    // 2. Analyze with LLM (stateful, can resume after failures)
    const analysis = await ctx.run("analyze", async () => {
      return ctx.serviceClient(AnalysisMCP).deepAnalyze({
        sources,
        instructions: "Synthesize key findings"
      });
    });
    
    // 3. Generate report (durable, exactly-once delivery)
    await ctx.run("generate-report", async () => {
      return ctx.serviceClient(ReportMCP).create({
        title: `Research: ${topic}`,
        content: analysis
      });
    });
  }
}

This would be impossible to build reliably without Restate's guarantees.