Skip to main content
Glama
orzcls

Gemini CLI MCP Server

by orzcls
OverviewSchemaSourceRelated ServersDiscussionsAdmin
JavaScript
Local

🚀 Gemini MCP Tool - Windows Fixed Version

npm version License: MIT

Latest Version v1.0.21 - Fixed cross-terminal compatibility issues and fetch-chunk format errors

A Windows-compatible Model Context Protocol (MCP) server that enables AI assistants to interact with Google's Gemini CLI. This is a fixed version specifically designed to work seamlessly on Windows environments with PowerShell support.

Note: This is an enhanced version of the original gemini-mcp-tool with Windows-specific fixes and improvements.

🆕 Latest Updates (v1.0.21)

  • 🔧 Fixed Cross-Terminal Compatibility - Resolved Node.js path not found issues in different terminal environments

  • 📦 Fixed fetch-chunk Format Error - Fixed MCP protocol format mismatch in chunked responses

  • 🛡️ Enhanced PATH Environment Variable Handling - Automatically adds common Node.js installation paths

  • ✅ Full Compatibility with All Terminals - Supports PowerShell, CMD, VS Code Terminal, Trae AI, CherryStudio, etc.

  • 🚀 Improved Error Handling - Better error messages and debug output

v1.0.3 Updates

  • 🆕 PowerShell Path Parameter Support - Added optional powershellPath parameter allowing users to customize PowerShell executable path

  • ✅ Fixed PowerShell Execution Error - Resolved spawn powershell.exe ENOENT issue

  • ✅ Improved Windows Compatibility - Automatic detection of available PowerShell versions

  • ✅ Fixed Undefined Variable Error - Fixed args variable issue in executeCommandWithPipedInput function

  • ✅ Enhanced Error Handling - Better error messages and debug output

  • ✅ Backward Compatibility - Existing configurations require no modification, automatically uses default detection logic

Related MCP server: DeepView MCP

✨ Features

  • 🪟 Windows Compatible: Full PowerShell support with Windows-specific path handling

  • 📊 Large Context Window: Leverage Gemini's massive token window for analyzing entire codebases

  • 📁 File Analysis: Analyze files using @filename syntax

  • 🔒 Sandbox Mode: Safe code execution environment

  • 🔗 MCP Integration: Seamless integration with MCP-compatible AI assistants (Trae AI, Claude Desktop)

  • ⚡ NPX Ready: Easy installation and usage with NPX

  • 🔧 Environment Variable Support: Flexible API key configuration

This Windows-fixed version resolves:

  • PowerShell parameter passing issues

  • Character encoding problems with Chinese/Unicode text

  • Command line argument escaping on Windows

  • Environment variable handling

📋 Prerequisites

Before using this tool, ensure you have:

  1. Node.js (v16.0.0 or higher)

    node --version  # Should be v16+

  2. Google Gemini CLI installed and configured

    npm install -g @google/generative-ai-cli

# Verify installation
gemini --version

  3. API Key: Get your API key from Google AI Studio

📦 Installation

Quick Start with NPX (Recommended)

# Use latest version (recommended)
npx gemini-mcp-tool-windows-fixed@1.0.21

# Or use latest version tag
npx -y gemini-mcp-tool-windows-fixed@latest

Global Installation

# Install latest version
npm install -g gemini-mcp-tool-windows-fixed@1.0.21

# Run the tool
gemini-mcp-tool-windows-fixed

Updating Existing Installation

If you previously installed an older version:

# Uninstall old version and install latest
npm uninstall -g gemini-mcp-tool-windows-fixed
npm cache clean --force
npm install -g gemini-mcp-tool-windows-fixed@1.0.21

⚙️ MCP Client Configuration

Claude Code (One-Line Setup)

# One-command setup for Claude Code
claude mcp add gemini-cli -- npx -y gemini-mcp-tool-windows-fixed@1.0.21

Verify Installation: Type /mcp inside Claude Code to verify the gemini-cli MCP is active. 1

Alternative: Import from Claude Desktop

If you already have it configured in Claude Desktop:

  1. Add to your Claude Desktop config (see below)

  2. Import to Claude Code:

    claude mcp add-from-claude-desktop

Trae AI (Recommended)

  1. Open: %APPDATA%\Trae\User\mcp.json

  2. Add this configuration:

{
  "mcpServers": {
    "gemini-cli": {
      "name": "gemini-cli",
      "description": "Windows-compatible Gemini MCP Tool",
      "baseUrl": "",
      "command": "npx",
      "args": [
        "-y",
        "gemini-mcp-tool-windows-fixed@1.0.21"
      ],
      "env": {
        "GEMINI_API_KEY": "YOUR_ACTUAL_API_KEY_HERE"
      },
      "isActive": true,
      "providerUrl": "https://github.com/orzcls/gemini-mcp-tool-windows-fixed"
    }
  }
}

Claude Desktop

  1. Open: %APPDATA%\Claude\claude_desktop_config.json

  2. Add this configuration:

{
  "mcpServers": {
    "gemini-cli": {
      "command": "npx",
      "args": ["-y", "gemini-mcp-tool-windows-fixed@1.0.21"],
      "env": {
        "GEMINI_API_KEY": "YOUR_ACTUAL_API_KEY_HERE"
      }
    }
  }
}

🔑 API Key Configuration

Option 1: MCP Configuration (Recommended)

Replace YOUR_ACTUAL_API_KEY_HERE in the configuration above with your actual API key.

Option 2: Environment Variable

# Temporary (current session)
$env:GEMINI_API_KEY = "your-actual-api-key"

# Permanent (user level)
[Environment]::SetEnvironmentVariable("GEMINI_API_KEY", "your-actual-api-key", "User")

# Verify
echo $env:GEMINI_API_KEY

Configuration File Locations

Claude Desktop:

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Linux: ~/.config/claude/claude_desktop_config.json

Trae AI:

  • Windows: %APPDATA%\Trae\User\mcp.json

🛠️ Available Tools

This MCP server provides the following tools for AI assistants:

1. ask-gemini

Interact with Google Gemini for analysis and questions.

Parameters:

  • prompt (required): The analysis request. Use @ syntax for file references

  • model (optional): Gemini model to use (default: gemini-2.5-pro)

  • sandbox (optional): Enable sandbox mode for safe code execution

  • changeMode (optional): Enable structured change mode

  • chunkIndex (optional): Chunk index for continuation

  • chunkCacheKey (optional): Cache key for continuation

2. brainstorm

Generate creative ideas using various brainstorming frameworks.

Parameters:

  • prompt (required): Brainstorming challenge or question

  • model (optional): Gemini model to use

  • methodology (optional): Framework (divergent, convergent, scamper, design-thinking, lateral, auto)

  • domain (optional): Domain context (software, business, creative, etc.)

  • constraints (optional): Known limitations or requirements

  • existingContext (optional): Background information

  • ideaCount (optional): Number of ideas to generate (default: 12)

  • includeAnalysis (optional): Include feasibility analysis (default: true)

3. fetch-chunk

Retrieve cached chunks from changeMode responses.

Parameters:

  • cacheKey (required): Cache key from initial response

  • chunkIndex (required): Chunk index to retrieve (1-based)

4. timeout-test

Test timeout prevention mechanisms.

Parameters:

  • duration (required): Duration in milliseconds (minimum: 10ms)

5. ping

Test connection to the server.

Parameters:

  • prompt (optional): Message to echo back

6. Help

Display help information about available tools.

🎯 Usage Examples

Once configured, you can use the following tools through your MCP client:

Natural Language Examples 2

With File References (using @ syntax):

  • "ask gemini to analyze @src/main.js and explain what it does"

  • "use gemini to summarize @. the current directory"

  • "analyze @package.json and tell me about dependencies"

General Questions (without files):

  • "ask gemini to search for the latest tech news"

  • "use gemini to explain div centering"

  • "ask gemini about best practices for React development related to @file_im_confused_about"

  • "use gemini to explain index.html"

  • "understand the massive project using gemini"

  • "ask gemini to search for latest news"

Using Gemini CLI's Sandbox Mode (-s): 2 The sandbox mode allows you to safely test code changes, run scripts, or execute potentially risky operations in an isolated environment.

  • "use gemini sandbox to create and run a Python script that processes data"

  • "ask gemini to safely test @script.py and explain what it does"

  • "use gemini sandbox to install numpy and create a data visualization"

  • "test this code safely: Create a script that makes HTTP requests to an API"

Slash Commands (for Claude Code Users) 2

You can use these commands directly in Claude Code's interface (compatibility with other clients has not been tested):

  • /analyze: Analyzes files or directories using Gemini, or asks general questions

    • prompt (required): The analysis prompt. Use @ syntax to include files (e.g., /analyze prompt:@src/ summarize this directory) or ask general questions (e.g., /analyze prompt:Please use a web search to find the latest news stories)

  • /sandbox: Safely tests code or scripts in Gemini's sandbox environment

    • prompt (required): Code testing request (e.g., /sandbox prompt:Create and run a Python script that processes CSV data or /sandbox prompt:@script.py Test this script safely)

  • /help: Displays the Gemini CLI help information

  • /ping: Tests the connection to the server

    • message (optional): A message to echo back

Available Tools

  • ask-gemini: Send prompts to Gemini

    "Explain how MCP works"

  • analyze-file: Analyze specific files using @filename syntax

    "Analyze @package.json and suggest improvements"

  • sandbox-mode: Execute code in a safe environment

    "Run this Python code in sandbox mode: print('Hello World')"

🔧 Windows-Specific Fixes

This version includes the following Windows-specific improvements:

  1. PowerShell Parameter Handling: Fixed argument passing to avoid parameter splitting

  2. Character Encoding: Proper UTF-8 handling for Chinese and Unicode characters

  3. Quote Escaping: Correct escaping of quotes in command arguments

  4. Environment Variables: Improved .env file loading and environment variable handling

  5. Path Resolution: Windows-compatible path handling

🧪 Testing Installation

1. Test Gemini CLI

gemini -p "Hello, how are you?"

2. Test MCP Tool

npx -y gemini-mcp-tool-windows-fixed
# Should show: [GMCPT] Gemini CLI MCP Server (Fixed) started

3. Test MCP Integration

  1. Restart your MCP client (Trae AI, Claude Desktop)

  2. Try asking: "Use gemini to explain what MCP is"

  3. Check for successful responses

🐛 Troubleshooting

Common Issues

"Command not found: gemini"

npm install -g @google/generative-ai-cli

"API key not found"

# Check if API key is set
echo $env:GEMINI_API_KEY

# Set if empty
$env:GEMINI_API_KEY = "your-api-key"

"Permission denied"

# Check execution policy
Get-ExecutionPolicy
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

For detailed troubleshooting, see INSTALL-GUIDE.md.

🔧 Windows-Specific Fixes

This version includes several Windows-specific improvements:

  • PowerShell Integration: Native PowerShell command execution

  • Path Handling: Proper Windows path resolution

  • Environment Variables: Enhanced environment variable support

  • Error Handling: Better error messages for Windows environments

  • Dependency Management: Simplified dependency structure

🤝 Contributing

Contributions are welcome! Please:

  1. Fork the repository

  2. Create a feature branch

  3. Test on Windows environments

  4. Submit a pull request

📄 License

MIT License - see LICENSE file for details.

🙏 Acknowledgments

📞 Support

If you encounter any issues or have questions:

  1. Check the Issues page

  2. Create a new issue with detailed information about your problem

  3. Include your Windows version, Node.js version, and error messages

Made with ❤️ for Windows developers

Note: This is a Windows-optimized fork of the original gemini-mcp-tool. For other platforms, consider using the original version.

Available Tools

6 tools
ask-geminiC

model selection [-m], sandbox [-s], and changeMode:boolean for providing edits

ParametersJSON Schema
NameRequiredDescriptionDefault
promptYesAnalysis request. Use @ syntax to include files (e.g., '@largefile.js explain what this does') or ask general questions
modelNoOptional model to use (e.g., 'gemini-2.5-flash'). If not specified, uses the default model (gemini-2.5-pro).
sandboxNoUse sandbox mode (-s flag) to safely test code changes, execute scripts, or run potentially risky operations in an isolated environment
changeModeNoEnable structured change mode - formats prompts to prevent tool errors and returns structured edit suggestions that Claude can apply directly
chunkIndexNoWhich chunk to return (1-based)
chunkCacheKeyNoOptional cache key for continuation
powershellPathNoOptional custom PowerShell executable path (e.g., 'C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe' or 'pwsh'). If not specified, auto-detects available PowerShell.

TDQS

C2.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'sandbox mode' for safe testing and 'changeMode' for structured edits, which adds some context about safety and output formatting. However, it lacks critical details like rate limits, authentication needs, error handling, or what the tool returns (no output schema exists). The description is insufficient for a tool with 7 parameters and complex functionality.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is poorly structured—it reads like a fragmented parameter reference rather than a coherent tool description. It's not front-loaded with purpose, and the phrase 'providing edits' is tacked on ambiguously. While brief, it fails to communicate effectively, making it inefficient rather than concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (7 parameters, AI interaction, no output schema, and no annotations), the description is highly incomplete. It doesn't explain the core functionality, return values, error conditions, or practical usage scenarios. The schema handles parameter documentation, but the description adds little contextual value, leaving significant gaps for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the input schema already documents all parameters thoroughly. The description lists three parameters ('model selection [-m], sandbox [-s], and changeMode:boolean') but doesn't add meaningful semantics beyond what the schema provides (e.g., it doesn't explain interactions between parameters or usage nuances). This meets the baseline of 3 when schema coverage is high.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose2/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description is essentially a parameter list ('model selection [-m], sandbox [-s], and changeMode:boolean') rather than stating what the tool does. It mentions 'providing edits' at the end, which hints at functionality but doesn't clearly articulate the core purpose. The description fails to specify that this tool queries or interacts with a Gemini AI model.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives like 'brainstorm' or 'fetch-chunk' is provided. The description mentions 'providing edits' which might imply use cases involving code or text modifications, but it doesn't clarify context, prerequisites, or distinctions from sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

brainstormC

Generate novel ideas with dynamic context gathering. --> Creative frameworks (SCAMPER, Design Thinking, etc.), domain context integration, idea clustering, feasibility analysis, and iterative refinement.

ParametersJSON Schema
NameRequiredDescriptionDefault
promptYesPrimary brainstorming challenge or question to explore
modelNoOptional model to use (e.g., 'gemini-2.5-flash'). If not specified, uses the default model (gemini-2.5-pro).
methodologyNoBrainstorming framework: 'divergent' (generate many ideas), 'convergent' (refine existing), 'scamper' (systematic triggers), 'design-thinking' (human-centered), 'lateral' (unexpected connections), 'auto' (AI selects best)auto
domainNoDomain context for specialized brainstorming (e.g., 'software', 'business', 'creative', 'research', 'product', 'marketing')
constraintsNoKnown limitations, requirements, or boundaries (budget, time, technical, legal, etc.)
existingContextNoBackground information, previous attempts, or current state to build upon
ideaCountNoTarget number of ideas to generate (default: 10-15)
includeAnalysisNoInclude feasibility, impact, and implementation analysis for generated ideas
powershellPathNoOptional custom PowerShell executable path (e.g., 'C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe' or 'pwsh'). If not specified, auto-detects available PowerShell.

TDQS

C2.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'dynamic context gathering,' 'feasibility analysis,' and 'iterative refinement,' which hint at process complexity, but lacks critical details: whether this is a read-only or mutating operation, expected runtime, rate limits, authentication needs, or output format. For a tool with 9 parameters and no annotation coverage, this leaves significant behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence fragment followed by a list, which is moderately efficient but lacks clear structure. The list ('Creative frameworks...') is dense and could be better organized. While it avoids redundancy, it doesn't front-load the most critical information, and some phrases like 'dynamic context gathering' are vague without elaboration, reducing overall clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (9 parameters, no annotations, no output schema), the description is incomplete. It omits essential context: what the output looks like (e.g., list of ideas, structured analysis), how 'iterative refinement' works in practice, error conditions, or performance expectations. For a brainstorming tool with multiple parameters and no structured output, more guidance is needed to ensure effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so parameters are well-documented in the schema itself. The description adds minimal semantic value beyond the schema—it mentions 'creative frameworks' and 'domain context integration,' which loosely map to the 'methodology' and 'domain' parameters but don't provide additional syntax or usage insights. This meets the baseline for high schema coverage without compensating for gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate novel ideas with dynamic context gathering.' It specifies the verb ('generate') and resource ('novel ideas'), and mentions key capabilities like creative frameworks and analysis. However, it doesn't explicitly differentiate from sibling tools like 'ask-gemini' which might also generate ideas, leaving some ambiguity about when to choose this specific brainstorming tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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. It lists capabilities like 'creative frameworks' and 'domain context integration' but doesn't specify scenarios where this tool is preferred over sibling tools (e.g., 'ask-gemini' for general queries). There's no mention of prerequisites, constraints, or comparative use cases, leaving the agent with minimal contextual direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

fetch-chunkA

Retrieves cached chunks from a changeMode response. Use this to get subsequent chunks after receiving a partial changeMode response.

ParametersJSON Schema
NameRequiredDescriptionDefault
cacheKeyYesThe cache key provided in the initial changeMode response
chunkIndexYesWhich chunk to retrieve (1-based index)

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the behavioral burden. The word 'Retrieves' signals a read operation, and 'cached chunks' implies a non-destructive lookup from previously stored response data. It does not detail cache expiration or whether chunks can be re-fetched, but the core behavior is clear.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences deliver the core behavior and the intended usage context with no wasted words. The primary action is front-loaded and the follow-up guidance is immediately actionable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description gives enough context for a simple two-parameter fetch tool: where the cacheKey comes from and when to call it. With no output schema, it could have clarified the response shape or chunk count, but the invocation path is adequately complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the parameters are already well documented. The description adds context about when the cacheKey/chunkIndex are used, but it does not provide substantial extra meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: it retrieves cached chunks from a changeMode response. It also clarifies the tool's role as the follow-up mechanism for partial changeMode responses, making its purpose unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says to use this tool 'after receiving a partial changeMode response' and positions it as the way to get subsequent chunks. It does not mention exclusions or alternatives, but no directly competing sibling tool is apparent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

HelpC

receive help information

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

C2.1/5.0
Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description should disclose behavior but only states the generic purpose; no details on side effects, permissions, or output are given.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short but lacks substance; it is not informative enough despite being concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema or annotations, the description should provide more context (e.g., what help topics are covered), but it does not.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so schema coverage is 100%, meeting the baseline. The description adds minimal value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose2/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'receive help information' is vague and does not specify what kind of help or how it differs from sibling tools like ask-gemini.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives; no context or exclusions are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

pingC

Echo

ParametersJSON Schema
NameRequiredDescriptionDefault
promptNoMessage to echo

TDQS

C2.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Echo' only restates the core action and implies the prompt is returned, but it does not state side effects, safety traits, or response format. For a trivial tool this is minimally acceptable, but it still lacks explicit behavioral transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

While the description is extremely concise, it is under-specified rather than efficiently structured. A single word without context is not a well-formed definition, and the conciseness is the result of omission rather than careful pruning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite the tool's low complexity, the description leaves out important context such as the intended use (e.g., connectivity test or echo of user input) and the fact that the given prompt will be returned. There is no output schema, so the description should clarify return behavior, but it does not.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already has 100% coverage with the description 'Message to echo' for the prompt parameter. The description 'Echo' adds no additional meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose2/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description is a single word, 'Echo', which names an action but does not specify the resource or what is echoed. It is not a complete statement of purpose and leaves ambiguity about whether it echoes the prompt parameter or something else. This is more like a vague fragment than a clear tool definition.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 any of the sibling tools. There is no mention of typical use cases, prerequisites, or exclusions. An agent receives no context to decide whether to call ping instead of ask-gemini or brainstorm.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

timeout-testA

Test timeout prevention by running for a specified duration

ParametersJSON Schema
NameRequiredDescriptionDefault
durationYesDuration in milliseconds (minimum 10ms)

TDQS

A3.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states the tool runs for a specified duration but lacks details on side effects, return values, or whether it is read-only or destructive. This is insufficient for a tool that likely involves waiting or blocking.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence with no unnecessary words. Every word contributes to the core message.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with one parameter and no output schema, the description covers the essential idea. However, it lacks context on what 'timeout prevention' means, typical use cases, and expected behavior after the duration elapses.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% (duration parameter already described). The description adds no additional meaning beyond 'running for a specified duration', which is already implied by the parameter name. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Test timeout prevention by running for a specified duration'. It uses a specific verb ('Test') and resource ('timeout prevention'), distinguishing it from sibling tools like 'ping' or 'health'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for testing timeout prevention but provides no explicit guidance on when to use this tool vs alternatives. No exclusions or when-not-to-use are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

  1. 6 tool updates
    • First observedask-gemini
    • First observedbrainstorm
    • First observedfetch-chunk
    • First observedHelp
    • First observedping
    • First observedtimeout-test
Deploy Server
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

C2.6/5.0

Scored across 6 tools

Disambiguation3/5

The tools have distinct primary purposes (e.g., ask-gemini for model queries, brainstorm for idea generation, fetch-chunk for data retrieval), but some overlap exists in communication functions: Help provides general assistance while ping serves as a connectivity test, which could be confused for basic diagnostic purposes. The descriptions clarify their differences, but the boundaries between support tools are not perfectly sharp.

Naming Consistency2/5

Naming conventions are inconsistent across the set: ask-gemini and fetch-chunk use kebab-case with descriptive verbs, brainstorm is a single word, Help uses PascalCase, ping is lowercase, and timeout-test mixes kebab-case with a hyphen. There is no uniform pattern in verb usage or casing, making the tool names appear chaotic and unpredictable.

Tool Count4/5

With 6 tools, the count is reasonable for a CLI server focused on Gemini interactions and utility functions. It covers core operations like querying, idea generation, and testing without being overly bloated, though it might feel slightly thin if expanded to more advanced Gemini features. The scope aligns well with the provided tools.

Completeness3/5

The tool set covers basic interactions with Gemini (ask-gemini, brainstorm) and includes utility functions (fetch-chunk, Help, ping, timeout-test), but there are notable gaps for a comprehensive CLI server: missing operations for managing conversations, handling errors, or configuring settings. It supports core workflows but lacks full lifecycle coverage, which could limit agent effectiveness in complex scenarios.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers

  • MCP Gemini Server

    amitsh06
    F
    license
    Not graded
    quality
    D
    maintenance
    A server implementing the Model Context Protocol that enables AI assistants like Claude to interact with Google's Gemini API for text generation, text analysis, and chat conversations.
    -

  • DeepView MCP

    Mitek99
    A
    license
    Not graded
    quality
    D
    maintenance
    A Model Context Protocol server that enables IDEs like Cursor and Windsurf to analyze large codebases using Gemini's extensive context window.
    65
    MIT

  • MCP Gemini CLI

    kazuph
    -
    license
    Not graded
    quality
    Not graded
    maintenance
    A server that allows interaction with Google's Gemini AI through the Gemini CLI tool using the Model Context Protocol, providing a standardized interface for querying Gemini with various options and configurations.
    -

Appeared in Searches