grpcmcp

What is grpcmcp?

grpcmcp is an MCP server that proxies to a gRPC backend using a provided protobuf descriptor file or server reflection. It exposes unary gRPC methods as MCP tools for AI agents and clients.

How to use grpcmcp?

Install with go install github.com/adiom-data/grpcmcp, then run with flags like --reflect for reflection or --descriptors for a descriptor file. Use --hostport to serve over HTTP (Streamable HTTP or SSE) or configure via command/args in an MCP client for STDIN transport.

Key features of grpcmcp

• Proxies to gRPC backends using reflection or descriptor files
• Exposes unary gRPC methods as MCP tools
• Supports Streamable HTTP, legacy SSE, and STDIN transports
• Filters services with the --services flag
• Attaches Bearer tokens or custom headers to backend calls
• Can be embedded as a Go library

Use cases of grpcmcp

• Enable AI agents to call gRPC services via natural language
• Bridge existing gRPC infrastructure to MCP-compatible clients
• Expose selected gRPC endpoints through a controlled MCP interface

FAQ from grpcmcp

What gRPC methods does grpcmcp support?

Only unary gRPC methods are exposed as MCP tools. Client-streaming, server-streaming, and bidi-streaming methods are skipped.

What transports does grpcmcp support for client connections?

grpcmcp supports Streamable HTTP (default when --hostport is set), legacy SSE, and STDIN transport.

Can grpcmcp be used as a Go library?

Yes, it can be embedded via grpcmcp.NewServer() with a Config struct, allowing custom descriptor loading, HTTP clients, and dynamic header providers.

How does authentication work with grpcmcp?

Outbound backend auth is configured via --bearer, --bearer-env, or --header flags. For dynamic auth, use ToolHeaderProvider in library mode. Inbound MCP auth is handled by wrapping the HTTP handler with standard Go middleware.

How are 64-bit integers handled in MCP schemas?

With the --string64 flag, 64-bit protobuf integer fields (int64, uint64, etc.) are exposed only as strings in MCP JSON schemas to avoid precision loss for JavaScript clients.