Skip to main content
Glama
orzcls

Gemini CLI MCP Server

by orzcls
OverviewSchemaSourceRelated ServersScoreDiscussionsAdmin
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

A3.7/5.0
Behavior3/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 that this retrieves 'cached chunks' and is for 'subsequent chunks,' implying it's a read operation without side effects, but lacks details on error handling, caching behavior, or response format. This is adequate but has gaps.

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 two sentences with zero waste, front-loading the purpose and following with usage guidance. Every word earns its place, making it highly efficient and well-structured.

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?

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is complete enough for basic understanding but lacks details on output (e.g., what the chunks contain) and error cases. It's minimally viable but could be more comprehensive.

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 the schema already documents both parameters ('cacheKey' and 'chunkIndex') fully. The description adds minimal value by referencing 'cache key provided in the initial changeMode response' and 'which chunk to retrieve,' but doesn't provide additional syntax or format details beyond the schema.

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 action ('Retrieves cached chunks') and resource ('from a changeMode response'), making the purpose understandable. However, it doesn't explicitly differentiate this tool from its siblings (like 'ask-gemini' or 'brainstorm'), which would require a 5.

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 provides clear context on when to use this tool ('after receiving a partial changeMode response'), which helps guide usage. It doesn't specify when not to use it or name explicit alternatives among siblings, preventing a score of 5.

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.3/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 but offers minimal insight. 'receive help information' implies a read-only operation but doesn't specify what kind of help (e.g., general guidance, error messages, usage tips), how it's delivered, or any constraints like rate limits. It lacks crucial context for safe and effective use.

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

Conciseness4/5

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

The description is extremely concise with just two words, which is appropriate for a simple tool. However, it's arguably under-specified rather than efficiently informative, as it doesn't convey enough meaning to be truly helpful. It earns a 4 for brevity but loses a point for lacking substance.

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 simplicity (0 parameters, no output schema), the description is incomplete. It doesn't explain what 'help information' entails, how it might be structured, or when it's useful compared to other tools. For even a basic tool, this leaves significant gaps in understanding its role and output.

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

Parameters4/5

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

The tool has 0 parameters, and schema description coverage is 100%, so there's no need for parameter documentation in the description. The baseline for this scenario is 4, as the description appropriately doesn't waste space on non-existent parameters.

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 a tautology that essentially restates the tool name 'Help' without specifying what kind of help is provided or what resource it accesses. It doesn't distinguish this tool from potential siblings like 'ask-gemini' or 'brainstorm' that might also provide assistance. The purpose remains vague rather than specific.

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

Usage Guidelines1/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 like 'ask-gemini' or 'brainstorm'. There's no mention of context, prerequisites, or exclusions. This leaves the agent with no information to make an informed choice among sibling tools.

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/5.0
Behavior1/5

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

With no annotations provided, the description carries full burden for behavioral disclosure but offers none. 'Echo' implies a simple return operation but doesn't specify whether this is a read-only operation, if it has side effects, what authentication might be needed, or any rate limits. The description fails to provide any behavioral context beyond the minimal implication of the word 'echo'.

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 single word 'Echo' is extremely concise but borders on under-specification rather than effective brevity. While it uses minimal words, it fails to provide meaningful information that would help an AI agent understand and use the tool effectively.

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?

For a tool with no annotations and no output schema, the description 'Echo' is insufficiently complete. While the tool appears simple with only one optional parameter, the description doesn't explain what the tool returns, how errors are handled, or provide any context about its purpose within the server alongside tools like 'ask-gemini' and 'fetch-chunk'.

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

Parameters4/5

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

With 0 required parameters and 100% schema description coverage, the baseline is high. The single optional parameter 'prompt' is fully documented in the schema with type, default value, and description. The tool description doesn't need to add parameter semantics since the schema already provides complete coverage for this simple tool.

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 'Echo' is a tautology that essentially restates the tool name 'ping' without clarifying what the tool actually does. While 'echo' suggests returning input, it doesn't specify what resource or operation is involved, nor does it distinguish this from sibling tools like 'ask-gemini' or 'fetch-chunk'.

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

Usage Guidelines1/5

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

The description provides absolutely no guidance on when to use this tool versus alternatives. There's no mention of context, prerequisites, or comparison to sibling tools like 'ask-gemini' for AI responses or 'fetch-chunk' for data retrieval.

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

timeout-testC

Test timeout prevention by running for a specified duration

ParametersJSON Schema
NameRequiredDescriptionDefault
durationYesDuration in milliseconds (minimum 10ms)

TDQS

C2.9/5.0
Behavior2/5

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

No annotations are provided, so the description carries full burden. It states the tool 'runs for a specified duration' to test timeout prevention, but doesn't disclose behavioral traits such as whether it's safe (non-destructive), what happens after the duration (e.g., returns a result or error), or any side effects. This is inadequate for a tool with potential timing implications.

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, efficient sentence: 'Test timeout prevention by running for a specified duration.' It's front-loaded with the core purpose, has zero waste, and is appropriately sized for a simple tool.

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 annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., success/failure, timing data), potential errors, or behavioral details like whether it's idempotent. For a tool that interacts with system timeouts, more context is needed for safe and 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?

Schema description coverage is 100%, with the parameter 'duration' fully documented in the schema as 'Duration in milliseconds (minimum 10ms).' The description adds no additional meaning beyond implying the duration controls runtime, so it meets the baseline of 3 where the schema does the heavy lifting.

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: 'Test timeout prevention by running for a specified duration.' It includes a specific verb ('test') and resource ('timeout prevention'), but doesn't differentiate from siblings (e.g., 'ping' which might also test system responsiveness). The purpose is unambiguous but lacks sibling comparison.

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 like 'ping' or other siblings. The description implies usage for testing timeouts but doesn't specify scenarios, prerequisites, or exclusions. This leaves the agent without context for tool selection.

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. Dates show when Glama detected each change.

  1. 6 tool updates
    • First observedask-gemini
    • First observedbrainstorm
    • First observedfetch-chunk
    • First observedHelp
    • First observedping
    • First observedtimeout-test
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

C2.6/5.0
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

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

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

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/orzcls/gemini-mcp-tool-windows-fixed'

If you have feedback or need assistance with the MCP directory API, please join our Discord server