Click on "Install 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., "@gRPC MCP Server call GetUser method of UserService with id 123"
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.
📄 Available languages:
grpc-mcp is an MCP server built with Node.js/TypeScript. It enables easy gRPC requests and Protocol Buffer file information retrieval.
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: Pro Tools MCP Server
This tool does NOT support gRPC streaming (server streaming, client streaming, or bidirectional streaming). Only single-request single-response (unary) RPCs are supported.
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:
English: grpc-mcp.prompt.md
Japanese: grpc-mcp.ja.prompt.md
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"]
}
}
}node C:~\node_modules\grpc-mcp\dist\index.js@grpc/grpc-js
@grpc/proto-loader
fastmcp
zod
Specify the directory containing proto files to get service/method info.
{
"tool": "loadProto",
"parameters": {
"dir": "C:\\Users\\proto"
}
}Specify service/method to get request/response structure.
{
"tool": "getMethodInformation",
"parameters": {
"path": "C:\\Users\\proto\\your.proto",
"service": "YourService",
"method": "YourMethod"
}
}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
}
}
}{
"analyze": {
"time": 123 // response time (ms)
},
"response": {
"ok": true,
"body": "{...}" // response body (JSON string)
// on failure:
// "ok": false,
// "error": { "code": 14, "details": "UNAVAILABLE" }
}
}MIT
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"
npm install
npm run buildnpm run lint
npm run prettier:write// 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();Get information about methods in a proto file
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path to the proto file (Full path) | |
| service | Yes | Service name (e.g., UserService) | |
| method | Yes | Method name (e.g., GetUser) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description does not disclose behavioral traits like read-only nature, permissions, or error cases. It is incomplete for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with the purpose. Efficient, but could be more concise by including key details like return format.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description does not explain what the result looks like. It covers the basics but leaves questions about output format and error handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with self-explanatory parameter descriptions. The tool description adds no extra meaning or constraints beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get information about methods in a proto file' clearly states the verb and resource, and it distinguishes from siblings like loadProto (loads file) and sendRequest (sends request). However, it is vague on what 'information' means (e.g., signature, doc?).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus loadProto or sendRequest. The description does not mention prerequisites, context, or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Load a proto file and return its content
| Name | Required | Description | Default |
|---|---|---|---|
| dir | Yes | Directory containing the proto file (e.g., /path/to/proto) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only states the basic operation without disclosing side effects, safety profile, or error conditions. For a read operation, this is minimal disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of 8 words, highly concise with no superfluous content. Every word is necessary to convey the basic purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description should explain the return format. It says 'return its content' but does not specify what the content looks like (e.g., raw text, parsed structure). Additionally, the parameter is a directory, but the description refers to a file, causing ambiguity about whether it loads a single file or multiple.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter, and the description does not add meaningful information beyond what the schema already provides. It repeats the same idea but less precisely.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (load) and resource (proto file) along with the outcome (return its content). It distinguishes itself from sibling tools like getMethodInformation and sendRequest, which have different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or conditions for use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Send a request to a gRPC server
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path to the proto file (Full path) | |
| address | Yes | Address of the gRPC server (e.g., localhost:6565) | |
| service | Yes | Service name (e.g., UserService) | |
| method | Yes | Method name (e.g., GetUser) | |
| body | Yes | Request body in JSON format | |
| headers | No | Optional headers to include in the request | |
| config | No | Configuration options for the request |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description provides no behavioral details beyond the basic action. No annotations exist to compensate. It fails to disclose error behavior, state modifications, authentication needs, or any other traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (one sentence) but lacks informative content. It is not wasteful, but brevity comes at the cost of missing key details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 7 parameters, 5 required, nested objects, and no output schema, the description is insufficient. It does not explain return values, error handling, or usage patterns.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter information, but the schema already describes each parameter adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb and resource: 'send a request to a gRPC server'. It distinguishes from sibling tools 'getMethodInformation' and 'loadProto', which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. It does not mention prerequisites or contexts where this tool is appropriate or inappropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v2.0.1getMethodInformation3 fields changedInput schema / additionalPropertiesRemoved value: -falseInput schema / properties / method / descriptionPrevious value: -"Method name (e.g., GetAddress)"New value: +"Method name (e.g., GetUser)"Input schema / properties / service / descriptionPrevious value: -"Service name (e.g., AddressService)"New value: +"Service name (e.g., UserService)"loadProto1 field changedInput schema / additionalPropertiesRemoved value: -falsesendRequest6 fields changedInput schema / additionalPropertiesRemoved value: -falseInput schema / properties / address / descriptionPrevious value: -"Address of the gRPC server (e.g., it2.trylion-customer-api.askul-it.com:443)"New value: +"Address of the gRPC server (e.g., localhost:6565)"Input schema / properties / config / additionalPropertiesRemoved value: -falseInput schema / properties / headers / propertyNamesAdded value: +{
+ "type": "string"
+}Input schema / properties / method / descriptionPrevious value: -"Method name (e.g., GetAddress)"New value: +"Method name (e.g., GetUser)"Input schema / properties / service / descriptionPrevious value: -"Service name (e.g., AddressService)"New value: +"Service name (e.g., UserService)"v1.0.0getMethodInformationloadProtosendRequestEach tool has a clearly distinct purpose with no overlap: getMethodInformation retrieves metadata about methods, loadProto loads file content, and sendRequest sends requests to a server. An agent can easily differentiate these functions without confusion.
The naming is mixed: getMethodInformation and loadProto use camelCase, while sendRequest uses snake_case. This inconsistency in convention reduces predictability, though the names remain readable and descriptive.
With only 3 tools, the server feels thin for a gRPC domain, which typically involves operations like listing services, invoking methods, or handling streams. While the tools cover basic tasks, the count is borderline low for comprehensive gRPC interactions.
The toolset has significant gaps for gRPC operations: it lacks capabilities for listing services or methods, handling streaming calls, or managing server connections. This incompleteness will likely cause agent failures in common gRPC workflows.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Interact with your Google Bigtable resources using natural language commands.
Interact with your Google Cloud Firestore resources using natural language commands.
GibsonAI MCP server: manage your databases with natural language
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Yuki4-dev/grpc-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
