This server enables AI agents to connect to and interact with any gRPC service that supports server reflection — no proto files or code generation required.
Connect to gRPC endpoints: Establish a connection to any gRPC server by providing a host:port address, with optional TLS and custom timeout configuration
List available services: Auto-discover and list all gRPC services exposed by the connected server via server reflection
List service methods: Retrieve all RPC methods for a specific service, including unary, server-streaming, client-streaming, and bidirectional streaming methods
Inspect service descriptors: Fetch the full schema for a service, including all methods, request/response types, and streaming modes
Invoke RPC methods: Call any RPC method using a JSON-serialized request body, with support for optional metadata headers and custom timeouts
Health checks: Query the standard gRPC Health Checking Protocol to check the health status of the overall server or a specific service
Disconnect: Cleanly terminate the connection and clear all cached service data
Allows inspecting live Istio service meshes and invoking RPCs on Istio components via gRPC server reflection.
Enables debugging Kubernetes microservices by invoking gRPC RPCs directly from AI agents without kubectl.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@@supernova123/grpc-mcp-server connect to localhost:50051 and list all services"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Connect AI agents to any gRPC service — no proto files needed.
Most gRPC services are invisible to AI tools. This MCP server uses gRPC Server Reflection to auto-discover services, methods, and types at runtime, then exposes them as callable tools for Claude, Cursor, and any MCP-compatible agent.
gRPC powers Kubernetes, Istio, Envoy, and thousands of microservices — but AI agents can't talk to any of them. Until now, you'd need to manually define proto schemas, generate clients, and wire everything together. This server does it automatically: point it at any gRPC endpoint with reflection enabled, and it discovers everything.
Use cases:
Debug microservices by invoking RPCs directly from Claude
Inspect live service meshes (Istio, Envoy) without kubectl
Build AI-powered ops tools that query gRPC health endpoints
Prototype API integrations without writing client code
Test gRPC services during development with natural language
Related MCP server: gRPC Invoke MCP
Tool | Description |
| Connect to a gRPC server and auto-discover all services via reflection |
| List every gRPC service on the connected endpoint |
| List all RPC methods for a service (unary, server-stream, client-stream, bidi) |
| Get full service schema: methods, request/response types, streaming modes |
| Call any RPC method with a JSON-serialized request body |
| Standard gRPC Health Checking Protocol (v1) |
| Clear cached service data and disconnect |
Add to your claude_desktop_config.json:
{
"mcpServers": {
"grpc": {
"command": "npx",
"args": ["-y", "@supernova123/grpc-mcp-server"],
"env": {
"GRPC_ENDPOINT": "localhost:50051"
}
}
}
}{
"mcp": {
"servers": {
"grpc": {
"command": "npx",
"args": ["-y", "@supernova123/grpc-mcp-server"],
"env": {
"GRPC_ENDPOINT": "localhost:50051"
}
}
}
}
}npx @supernova123/grpc-mcp-serverConnect to a gRPC server:
connect_endpoint(endpoint="localhost:50051")Discover available services:
list_services()Inspect a service's methods:
list_methods(service_name="grpc.health.v1.Health")Invoke an RPC:
invoke_rpc(
service_name="grpc.health.v1.Health",
method_name="Check",
request={"service": ""}
)Variable | Description | Default |
| Target gRPC endpoint (host:port) | (none — use |
| Request timeout in milliseconds |
|
| Enable TLS connections |
|
Node.js 18+
Target gRPC server must support gRPC Server Reflection (v1)
Most gRPC servers have reflection enabled in development. For production servers, ensure grpc.reflection.V1Reflection is registered.
Connects to your gRPC endpoint via the reflection API
Fetches the full service descriptor (services → methods → types)
Dynamically generates MCP tool definitions from the schema
Invokes RPCs by serializing JSON requests to protobuf and back
No proto files. No code generation. No compile step.
MIT
Connect to a gRPC server endpoint and discover available services via server reflection
Inputs: endpoint (required), use_tls, timeout_ms.
Disconnect from the current gRPC endpoint and clear cached service data
Inputs: no named parameters.
Get the full descriptor for a gRPC service including all methods, request/response types, and streaming modes
Inputs: service_name (required).
Check gRPC server health using the standard Health Checking Protocol
Inputs: service, timeout_ms.
Invoke a gRPC method with a JSON-serialized request body
Inputs: service_name (required), method_name (required), request, timeout_ms, +1 more.
List all methods for a specific gRPC service
Inputs: service_name (required).
List all gRPC services discovered via server reflection on the connected endpoint
Inputs: no named parameters.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 7 tools
Each tool has a clear, distinct purpose: connection management, service discovery, health checking, and invocation. There is no overlap in functionality.
All tools use consistent snake_case with a verb_noun pattern (e.g., connect_endpoint, list_services, invoke_rpc). The pattern is uniform and descriptive.
Seven tools is an ideal size for a gRPC MCP server, covering all core operations without being excessive or insufficient.
The tool set covers the full lifecycle: connect, discover, inspect, health check, invoke. Minor gap: explicit support for streaming modes could be clarified, but overall complete.
MCP server for OnceAsk, the AI-native current-address layer for people and agents.
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
