MCP Server with Apache Thrift and A2A Integration

[vishalmysore]

Pre-submission Checklist

• This post follows the MCP community guidelines

What would you like to share?

Hey MCP community! I want to share a pattern that lets you expose your MCP tools through multiple protocols while keeping all MCP capabilities. The key insight: you can implement your tools to be accessible via MCP, A2A, and Thrift simultaneously!

The Pattern 🔧

Here's the real power - your service can:

• Be called as an MCP tool
• Be accessed via Thrift RPC
• Simple Rest API

Here's the actual implementation:

@Agent(name = "WeatherAgent", description = "Weather forecasting agent with cross-language capabilities")
public class WeatherServiceA2A implements WeatherService.Iface {
    
    private final ThriftClientPool<WeatherService.Client> pythonClientPool;
    private final FinagleClient<WeatherService.FinagledClient> scalaClientPool;
    
    @Action(description = "Get weather forecast using distributed agents")
    @Override
    public String getForecast(String city) {
        // Load balancing between Python and Scala services
        if (shouldUsePythonService()) {
            return delegateToPython(city);
        } else {
            return delegateToScala(city);
        }
    }
    
    private String delegateToPython(String city) {
        try (ThriftClient<WeatherService.Client> client = pythonClientPool.acquire()) {
            return client.get().getForecast(city);
        }
    }
}

How It Works 🛠️

1. Interface Definition

   // weather_service.thrift
   service WeatherService {
       string getForecast(1: string city)
       double getTemperature(1: string city)
       map<string, double> getHistoricalData(1: string city, 2: string startDate, 3: string endDate)
   }

2. Key Components

   • @Agent annotation exposes it as an MCP-compatible service
   • WeatherService.Iface makes it a Thrift service
   • Can call other services via Thrift (like Python ML services)
   • Load balance between different implementations

Why This Matters 🌟

1. True Protocol Flexibility

   • MCP clients use it as a normal tool
   • Other services can call it via Thrift
   • Mix and match based on performance needs

2. Real Benefits

   • Call Python ML services directly
   • Load balance between implementations
   • High-performance when needed
   • Keep all MCP features

Example Use Cases 💡

1. ML Model Serving

   • Use MCP for agent interactions
   • Use Thrift for high-performance inference
   • Load balance between Python model servers

2. Data Processing

   • MCP for orchestration
   • Thrift for efficient data transfer
   • Scale across languages

Implementation Tips 📝

1. Connection Management

   private final ThriftClientPool<WeatherService.Client> pythonClientPool;
   private final FinagleClient<WeatherService.FinagledClient> scalaClientPool;

   • Pool connections for better performance
   • Support multiple backend services
   • Enable load balancing

2. Protocol Best Practices

   • Use @agent and @action for MCP compatibility
   • Implement Thrift interface for RPC
   • Handle errors appropriately for each protocol

Relevant Links

https://github.com/vishalmysore/mcp-apache-thrift
https://medium.com/@visrow/mcp-apache-thrift-polyglot-ai-orchestration-platform-67896a9e72b8