Skip to main content
Glama

📄 Available languages:

grpc-mcp

grpc-mcp is an MCP server built with Node.js/TypeScript. It enables easy gRPC requests and Protocol Buffer file information retrieval.

Features

  • Retrieve service/method info from Protocol Buffer files

  • Send requests to gRPC servers (with SSL, timeout, headers, etc.)

  • Get response time statistics

  • Operate via natural language from MCP clients or VSCode extensions

Related MCP server: gcp-mcp-server

Limitations

  • This tool does NOT support gRPC streaming (server streaming, client streaming, or bidirectional streaming). Only single-request single-response (unary) RPCs are supported.

AI instruction prompts

This repository includes prompt templates to instruct AI agents using natural language. The templates and usage examples help automate gRPC requests and Protocol Buffer handling. See the prompt files below:

Usage

MCP Client Example

use npx.

{
  "servers": {
    "grpc-mcp-sample": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "grpc-mcp"]
    }
  }
}

or use install module.

{
  "servers": {
    "grpc-mcp-sample": {
      "type": "stdio",
      "command": "node",
      "args": ["C:~\\node_modules\\grpc-mcp\\dist\\index.js"]
    }
  }
}

Start Server

node C:~\node_modules\grpc-mcp\dist\index.js

Dependencies

  • @grpc/grpc-js

  • @grpc/proto-loader

  • fastmcp

  • zod

MCP Tool Basic Operations

1. Load Proto Files

Specify the directory containing proto files to get service/method info.

{
  "tool": "loadProto",
  "parameters": {
    "dir": "C:\\Users\\proto"
  }
}

2. Get Method Information

Specify service/method to get request/response structure.

{
  "tool": "getMethodInformation",
  "parameters": {
    "path": "C:\\Users\\proto\\your.proto",
    "service": "YourService",
    "method": "YourMethod"
  }
}

3. Send gRPC Request

Specify proto, service, method, request body, SSL, timeout, etc.

{
  "tool": "sendRequest",
  "parameters": {
    "path": "C:\\Users\\proto\\your.proto",
    "address": "localhost:6565",
    "service": "YourService",
    "method": "YourMethod",
    "body": "{\"key\": \"value\"}",
    "config": {
      "SSL": false, // true: enabled, false: disabled
      "deadLine": 1000 // milliseconds
    }
  }
}

Response Example

{
  "analyze": {
    "time": 123 // response time (ms)
  },
  "response": {
    "ok": true,
    "body": "{...}" // response body (JSON string)
    // on failure:
    // "ok": false,
    // "error": { "code": 14, "details": "UNAVAILABLE" }
  }
}

License

MIT

MCP Tool Usage Examples

Natural Language Usage Examples

  • Send gRPC request

    • e.g. "Set id:123 in the request and call GetUser method of User service"

  • Multiple requests/statistics

    • e.g. "Call GetUser of Hoge service 10 times and show average/max/min response time"

  • Summarize/extract response

    • e.g. "Summarize user list in GetUser response"

    • e.g. "Show only error details if failed"

  • Get method info

    • e.g. "Show request/response structure for Sample method of Sample service in sample.proto"


For Developers

Setup & Build

npm install
npm run build

Lint & Format

npm run lint
npm run prettier:write

Example Implementation

// Import loader and client from grpc-mcp library
import { loader, client } from "grpc-mcp";

async function main() {
  // Load proto files from the proto directory
  const protoList = await loader.loadAsync("./proto/");
  const proto = protoList[0];
  const service = proto.services[0];
  const method = service.methods[0];

  // Get method information and print it
  const info = await loader.getMethodAsync(proto.path, service.name, method);
  console.log(info);

  // Send a gRPC request and print the response
  const response = await client.requestAsync({
    path: proto.path,
    address: "localhost:6565",
    service: service.name,
    method: method,
    body: JSON.stringify({ key: "value" }),
    config: { SSL: false },
  });
  console.log(response);
}

main();

Available Tools

3 tools
getMethodInformationC

Get information about methods in a proto file

Inputs: path (required), service (required), method (required).

loadProtoB

Load a proto file and return its content

Inputs: dir (required).

sendRequestC

Send a request to a gRPC server

Inputs: path (required), address (required), service (required), method (required), +3 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 3 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: sending requests, loading proto definitions, and retrieving method information. There is no overlap or ambiguity in their intended functions.

    Naming Consistency5/5

    All tool names follow a consistent camelCase verb-noun pattern (sendRequest, loadProto, getMethodInformation). Naming is uniform and predictable.

    Tool Count4/5

    Three tools is compact but sufficient for the core gRPC workflow: load definitions, inspect methods, and send requests. It is slightly minimal but not overly thin for the stated purpose.

    Completeness4/5

    The set covers the essential lifecycle: loading proto files, retrieving method details, and making requests. Minor gaps like service listing or advanced request features exist, but core operations are supported.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • -
      license
      Not graded
      quality
      Not graded
      maintenance
      Dynamically exposes Python SDKs (Kubernetes, GitHub, Azure) through an agent-friendly gRPC interface. Enables interaction with cloud services and platforms using natural language by automatically converting SDK functionality into callable functions.
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      Model Context Protocol server for Google Cloud Platform, enabling interaction with Resource Manager, Compute Engine, Cloud Storage, BigQuery, Pub/Sub, and Cloud Logging via natural language.
      3
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server for calling gRPC methods from AI agents, enabling them to inspect gRPC APIs and invoke unary RPCs using server reflection or local .proto files.
      57 npm
      1
      MIT