GgRMCP Go gRPC Gateway MCP Server for Claude

Overview

GgRMCP is a lightweight Go-based gateway that turns existing gRPC services into MCP (Model Context Protocol) server tools so models like Claude can call your RPC endpoints directly. Instead of reimplementing service logic or writing separate HTTP wrappers, GgRMCP reads compiled protobuf descriptors and exposes each gRPC method as a callable MCP tool, translating incoming MCP tool calls into gRPC requests and returning results to the model.

This approach is useful when you want a large language model to interact with internal microservices, business logic, or third-party gRPC APIs in a safe, predictable way. By reusing your proto definitions and a running gRPC backend, GgRMCP reduces glue code and provides a consistent MCP interface that agent frameworks and model integrations can use to discover and invoke tools.

Features

• Automatically expose gRPC methods as MCP tools using protobuf FileDescriptorSet
• No changes to your service code required — operates as a gateway/proxy
• Translates MCP tool invocations into gRPC requests and returns responses
• Support for unary RPCs (and a clear migration path for streaming if supported)
• Simple CLI and environment configuration for deployment
• Works with standard protoc toolchain (generate descriptor set with –include_imports)

Installation / Configuration

Prerequisites:

• Go 1.18+ (to build the gateway)
• protoc (Protocol Buffers compiler)
• A running gRPC service to proxy

Clone and build:

git clone https://github.com/aalobaidi/ggRMCP.git
cd ggRMCP
go build -o ggrmcp ./cmd/ggrmcp

Generate a FileDescriptorSet from your proto files (example):

# From your proto root:
protoc \
  --proto_path=. \
  --include_imports \
  --descriptor_set_out=services.pb \
  path/to/your/service.proto

Run the gateway pointing at your gRPC service and descriptor file:

# Basic example
./ggrmcp \
  --descriptor services.pb \
  --grpc-target localhost:50051 \
  --listen-addr :8080

Docker (example):

# Dockerfile snippet
FROM golang:1.20-alpine AS build
WORKDIR /src
COPY . .
RUN go build -o /bin/ggrmcp ./cmd/ggrmcp

FROM alpine
COPY --from=build /bin/ggrmcp /usr/local/bin/ggrmcp
ENTRYPOINT ["/usr/local/bin/ggrmcp"]

Common CLI flags / env vars (example table):

Adjust flags to match your operational environment or container orchestration setup.

Available Resources

When running, GgRMCP exposes:

• A tool manifest (MCP-compatible) describing available tools derived from gRPC methods. This manifest can be used by model agent frameworks to list and inspect available tools.
• Tool invocation endpoints that accept MCP-style requests and forward them to the specified gRPC method.
• Logging and basic error propagation so model responses can reflect backend errors when appropriate.

The manifest and invocation routes conform to MCP expectations: tooling that supports MCP should be able to discover tools and call them with minimal changes.

Use Cases

• Integrate Claude with internal microservices:
  • Example: Expose OrderService.PlaceOrder(OrderRequest) as an MCP tool so the model can place orders and receive structured confirmation objects without additional wrappers.
• Build agent-driven automation:
  • An automation agent can discover gRPC-backed tools via the manifest, chain calls (e.g., authenticate -> fetch user -> update record), and present model decisions as concrete RPC invocations.
• Rapid prototyping of model-enabled features:
  • During development you can compile proto files to a descriptor set and run GgRMCP locally to let the model interact with staging services without modifying service code.
• Safe, auditable tool invocation:
  • Because each gRPC method maps to a discrete tool with a schema based on the proto, calls are explicit, structured, and easier to log and audit.

Concrete example workflow

1. Compile proto descriptors: protoc –proto_path=. –include_imports –descriptor_set_out=svc.pb api/*.proto

2. Start your service: grpc-server –port 50051

3. Start GgRMCP: ./ggrmcp –descriptor svc.pb –grpc-target localhost:50051 –listen-addr :8080

4. From your MCP-compatible model agent, fetch the tool manifest, select a tool (e.g., /OrderService.PlaceOrder), and invoke it with a JSON payload matching the proto schema. GgRMCP will forward to the gRPC backend and return the response to the model.

Notes and Best Practices

• Keep your descriptor set synchronized with deployed service proto versions to avoid schema mismatches.
• For secure environments, enable TLS between GgRMCP and your gRPC backend and restrict the gateway’s network exposure.
• Validate and sanitize model inputs before forwarding to sensitive RPCs; treat model-driven calls as external inputs.

GgRMCP is a pragmatic bridge between gRPC microservices and MCP-compatible models, enabling language models to call real services with minimal glue code.