Skip to main content
Glama
GlitterKill

Gemini MCP Ultimate

by GlitterKill

Gemini MCP Ultimate

Gemini MCP Ultimate Version License Platform Node npm

The Ultimate Model Context Protocol (MCP) Server for Gemini CLI

Supercharge Claude with Google's Gemini 3 Pro, massive 1M+ token context windows, and persistent sessions.

InstallationUsageToolsTroubleshooting


Why Use This?

Problem: Claude's context window costs tokens. Reading a 50,000-line codebase repeatedly burns through your API budget.

Solution: Offload large file analysis to Gemini's 1M+ token context window. Claude asks questions, Gemini searches its memory, you pay only for the answers.

Scenario

Without Gemini MCP

With Gemini MCP

Savings

Analyze 10,000-line codebase

~40,000 tokens/query

~500 tokens/query

98%

Review 500-page documentation

~200,000 tokens/query

~1,000 tokens/query

99.5%

Multi-file refactoring

Re-read all files each turn

Query existing session

90%+


Related MCP server: Claude Gemini MCP Integration

Table of Contents


Installation

Prerequisites

Requirement

Version

Installation

Node.js

v18+ (v16 minimum)

nodejs.org

Gemini CLI

Latest

npm install -g @google/gemini-cli

Google Account

-

Required for Gemini authentication

Quick Install

For Claude Code (CLI):

claude mcp add gemini-mcp-ultimate -- npx -y gemini-mcp-ultimate

For Claude Desktop:

Add to your MCP configuration file:

Platform

Configuration File Location

Windows

%APPDATA%\Claude\claude_desktop_config.json

macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Linux

~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "gemini-mcp-ultimate": {
      "command": "npx",
      "args": ["-y", "gemini-mcp-ultimate"]
    }
  }
}

Platform-Specific Instructions

Linux / macOS

  1. Install Node.js (if not already installed):

    # Using nvm (recommended)
    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
    nvm install 20
    nvm use 20
  2. Install Gemini CLI globally:

    npm install -g @google/gemini-cli
  3. Authenticate with Gemini:

    gemini
    # Follow the browser prompts to sign in with your Google account
  4. Add the MCP server:

    claude mcp add gemini-mcp-ultimate -- npx -y gemini-mcp-ultimate
  5. Restart Claude Code to load the new MCP server.

Windows

Important: Use PowerShell for all Windows commands, not Command Prompt (cmd.exe). PowerShell properly preserves system PATH and environment variables that the MCP server needs to locate Gemini.

Windows requires additional PATH configuration because MCP servers run in an isolated environment that may not inherit your user PATH.

  1. Open PowerShell (not Command Prompt):

    • Press Win + X and select "Windows PowerShell" or "Terminal"

    • Or search for "PowerShell" in the Start menu

    • Do not use cmd.exe as it may not have the correct PATH

  2. Install Node.js:

    • Download from nodejs.org (LTS recommended)

    • Or use nvm-windows:

      # After installing nvm-windows
      nvm install 20
      nvm use 20
  3. Install Gemini CLI globally (in PowerShell):

    npm install -g @google/gemini-cli
  4. Authenticate with Gemini (in PowerShell):

    gemini
    # Follow the browser prompts to sign in with your Google account
  5. Verify Gemini is accessible (in PowerShell):

    # Check that gemini.cmd exists in your npm global path
    Get-Command gemini
    # Should output the path, e.g.: C:\Users\YourName\AppData\Roaming\npm\gemini.cmd
    
    # Alternative using where.exe
    where.exe gemini
  6. Verify environment variables are set (important for nvm-windows users):

    # Check these are set correctly
    $env:PATH -split ';' | Where-Object { $_ -match 'node|npm|nvm' }
    
    # For nvm-windows users, verify these exist:
    echo $env:NVM_HOME
    echo $env:NVM_SYMLINK
  7. Add the MCP server (in PowerShell):

    claude mcp add gemini-mcp-ultimate -- npx -y gemini-mcp-ultimate
  8. Restart Claude Code to load the new MCP server.

  9. If the MCP server cannot find Gemini, see Windows Troubleshooting below.

Verify Installation

After installation, verify the MCP server is working:

  1. Open Claude Code or Claude Desktop

  2. Type /mcp to see connected servers

  3. You should see gemini-mcp-ultimate listed

  4. Test with: "Use Gemini to tell me what 2+2 equals"


Token Savings Examples

Example 1: Codebase Analysis

Scenario: Analyze a React application with 15,000 lines of code across 50 files.

Without Gemini MCP (Traditional approach):

User: "Explain the authentication flow in this codebase"
Claude: [Reads 50 files = ~60,000 tokens input]
Claude: [Generates response = ~2,000 tokens output]
Total: ~62,000 tokens per question

With Gemini MCP:

# First query - Gemini ingests the codebase once
User: "Ask Gemini to analyze @src/ and explain the authentication flow"
Claude: [Calls ask-gemini tool = ~200 tokens]
Gemini: [Reads files into its 1M context, returns summary = ~1,500 tokens returned]
Total first query: ~1,700 tokens

# Subsequent queries - No file re-reading
User: "What middleware is used for auth?"
Claude: [Calls ask-gemini with session_id = ~150 tokens]
Gemini: [Queries existing context, returns answer = ~500 tokens]
Total: ~650 tokens per follow-up

Token Savings:

Query

Traditional

With Gemini MCP

Savings

First analysis

62,000

1,700

97%

Follow-up #1

62,000

650

99%

Follow-up #2

62,000

650

99%

Follow-up #3

62,000

650

99%

Total (4 queries)

248,000

3,650

98.5%

Example 2: Documentation Review

Scenario: Review a 200-page API documentation PDF converted to markdown (~100,000 tokens).

# Load documentation into Gemini session
User: "Use Gemini to read @docs/api-reference.md and create a session for questions"

# Query specific endpoints without re-reading
User: "What are the rate limits for the /users endpoint?"
User: "Show me authentication header examples"
User: "What error codes can the /orders endpoint return?"

Each follow-up query costs ~500-1,000 tokens instead of ~100,000 tokens.

Example 3: Multi-File Refactoring

Scenario: Refactor error handling across 20 utility files.

# Gemini analyzes all files once
User: "Ask Gemini to review @src/utils/*.ts for inconsistent error handling"
Gemini: Returns analysis and patterns found

# Claude applies fixes based on Gemini's analysis
User: "Apply the suggested error handling pattern to all files"
Claude: Uses Gemini's recommendations without re-reading all files

Tools Reference

ask-gemini

The primary tool for interacting with Gemini CLI.

Parameter

Type

Default

Description

prompt

string

required

Your query. Use @filename to include files.

model

string

gemini-3-pro-preview

Model to use. Falls back to gemini-3-flash-preview on quota errors.

session_id

string/number

-

Resume a previous session by ID or index.

approval_mode

string

yolo

default, auto_edit, or yolo for autonomy control.

sandbox

boolean

false

Run in isolated sandbox environment.

include_directories

string[]

-

Additional directories to include in context.

allowed_tools

string[]

-

Whitelist specific tools Gemini can use.

output_format

string

text

text, json, or stream-json.

changeMode

boolean

false

Return edits in structured OLD/NEW format for Claude to apply.

Example prompts:

# Analyze a single file
"@src/index.ts explain the main entry point"

# Analyze multiple files
"@src/auth/*.ts @src/middleware/*.ts how does authentication work?"

# Resume a session
prompt: "What about the error handling?"
session_id: "5"

# Autonomous mode
prompt: "@src/utils/ fix all TypeScript errors"
approval_mode: "auto_edit"

brainstorm

Creative ideation using structured frameworks.

Parameter

Type

Default

Description

prompt

string

required

The challenge or topic to brainstorm.

ideaCount

number

12

Number of ideas to generate.

methodology

string

auto

Framework: divergent, convergent, scamper, design-thinking, lateral, auto.

domain

string

-

Domain context (e.g., software, business, marketing).

constraints

string

-

Limitations or requirements to consider.

includeAnalysis

boolean

true

Include feasibility/impact ratings.

Example:

prompt: "Ways to reduce API response times"
domain: "software"
methodology: "scamper"
ideaCount: 5

manage-sessions

List or delete Gemini conversation sessions.

Parameter

Type

Default

Description

action

string

list

list or delete.

session_id

string

-

Session ID to delete (required for delete action).

Example:

# List all sessions
action: "list"

# Delete a specific session
action: "delete"
session_id: "3"

manage-extensions

Install and manage Gemini CLI extensions.

Parameter

Type

Default

Description

action

string

required

list, install, uninstall, update, enable, disable, validate.

target

string

-

Extension name or URL.

scope

string

project

project or global.

all

boolean

-

Update all extensions (with update action).

Example:

# List installed extensions
action: "list"

# Install an extension
action: "install"
target: "conductor"

# Update all extensions
action: "update"
all: true

ping

Test connectivity with the MCP server.

prompt: "Hello from test"
# Returns: cmd "Hello from test"

Help

Display Gemini CLI help information.

# No parameters needed
# Returns full Gemini CLI help text

Usage Examples

1. Basic File Analysis

User prompt:

"Use Gemini to explain what @src/utils/commandExecutor.ts does"

What happens:

  1. Claude calls ask-gemini with the file reference

  2. Gemini reads the file and analyzes it

  3. Returns explanation to Claude

  4. Claude presents the answer

2. Multi-Turn Codebase Session

First query:

"Ask Gemini to analyze @src/ and create a session I can query"

Claude calls:

{
  "tool": "ask-gemini",
  "prompt": "@src/ analyze this codebase structure and key components"
}

Follow-up (using session):

"In that same session, how does error handling work?"

Claude calls:

{
  "tool": "ask-gemini",
  "prompt": "Explain the error handling patterns in this codebase",
  "session_id": "latest"
}

Benefit: The second query doesn't re-read any files. Gemini queries its existing context.

3. Autonomous Code Fixes

"Use Gemini in auto-edit mode to fix all ESLint errors in @src/"

Claude calls:

{
  "tool": "ask-gemini",
  "prompt": "@src/ fix all ESLint errors",
  "approval_mode": "auto_edit"
}

Gemini fixes files directly without asking for confirmation on each edit.

4. Brainstorming Session

"Brainstorm 5 ways to improve the CLI developer experience using design thinking"

Claude calls:

{
  "tool": "brainstorm",
  "prompt": "Ways to improve CLI developer experience",
  "methodology": "design-thinking",
  "ideaCount": 5,
  "domain": "software"
}

5. Extension Management

"Install the Gemini security extension"

Claude calls:

{
  "tool": "manage-extensions",
  "action": "install",
  "target": "https://github.com/gemini-cli-extensions/security"
}

6. Session Cleanup

"List my Gemini sessions and delete the old ones"

Claude calls:

{
  "tool": "manage-sessions",
  "action": "list"
}

Then for deletion:

{
  "tool": "manage-sessions",
  "action": "delete",
  "session_id": "2"
}

Troubleshooting

General Issues

MCP server not appearing in /mcp list:

  1. Restart Claude Code/Desktop completely

  2. Check that Node.js is installed: node --version

  3. Verify npx works: npx --version

"Gemini command not found" errors:

  1. Install Gemini CLI: npm install -g @google/gemini-cli

  2. Verify installation: gemini --version

  3. Re-authenticate: gemini (follow prompts)

Quota exceeded errors:

  • The server automatically falls back from gemini-3-pro-preview to gemini-3-flash-preview

  • You can explicitly request flash: model: "gemini-3-flash-preview"

Windows Troubleshooting

Always use PowerShell for troubleshooting. Command Prompt (cmd.exe) does not properly inherit environment variables.

Windows has unique challenges because:

  1. npm global commands are .cmd batch files, not executables

  2. MCP servers run in isolated environments without user PATH

  3. Node.js may be installed via nvm-windows with non-standard paths

If Gemini cannot be found:

  1. Open PowerShell and find your Gemini installation:

    # Use Get-Command (PowerShell native)
    Get-Command gemini | Select-Object Source
    
    # Or use where.exe (note the .exe to avoid PowerShell alias)
    where.exe gemini
    # Example output: C:\Users\YourName\AppData\Roaming\npm\gemini.cmd
  2. Verify your PATH includes npm global directory:

    # List PATH entries containing npm or node
    $env:PATH -split ';' | Where-Object { $_ -match 'npm|node|nvm' }
    
    # Check if npm global bin is in PATH
    $npmGlobal = Join-Path $env:APPDATA 'npm'
    if ($env:PATH -match [regex]::Escape($npmGlobal)) {
        Write-Host "npm global path is in PATH" -ForegroundColor Green
    } else {
        Write-Host "npm global path is NOT in PATH" -ForegroundColor Red
        Write-Host "Add this to your PATH: $npmGlobal"
    }
  3. Verify NVM environment variables (if using nvm-windows):

    # These should both return paths if nvm-windows is configured correctly
    echo "NVM_HOME: $env:NVM_HOME"
    echo "NVM_SYMLINK: $env:NVM_SYMLINK"
    
    # Verify the symlink points to a valid Node installation
    if ($env:NVM_SYMLINK) {
        Test-Path (Join-Path $env:NVM_SYMLINK 'node.exe')
    }
  4. The MCP server auto-detects these paths (in order of priority):

    • $env:NVM_SYMLINK (nvm-windows active version symlink)

    • $env:APPDATA\npm (standard npm global)

    • $env:NVM_HOME\vX.X.X (nvm-windows installed versions)

    • C:\Program Files\nodejs (standard Node.js installation)

  5. If auto-detection fails, install from source in PowerShell:

    git clone https://github.com/GlitterKill/gemini-mcp-ultimate.git
    cd gemini-mcp-ultimate
    npm install
    npm run build
    
    # Add with full path (adjust path as needed)
    $fullPath = (Resolve-Path .\dist\index.js).Path
    claude mcp add gemini-local -- node $fullPath
  6. Verify the MCP server can find Gemini by checking logs:

    # Run the MCP server directly to see debug output
    $env:DEBUG = "true"
    node .\dist\index.js
    # Look for "Resolved gemini to..." in the output

Windows Compatibility

This project includes critical fixes for Windows that are not present in the upstream gemini-mcp-tool.

The Problem

On Unix systems, npm global commands like gemini are executable scripts. On Windows, they're .cmd batch files (gemini.cmd). Node.js child_process.spawn() cannot execute .cmd files directly without shell: true, but using shell: true triggers Node.js deprecation warnings and security concerns.

The Solution

The commandExecutor.ts module (src/utils/commandExecutor.ts:82-116) implements platform-aware command execution:

On Windows:

// Uses cmd.exe /c to execute .cmd files
spawnCommand = 'C:\\Windows\\System32\\cmd.exe';
spawnArgs = ['/c', 'gemini.cmd', ...args];

On Linux/macOS:

// Direct execution
spawnCommand = 'gemini';
spawnArgs = args;

Additional Windows Fixes

  1. PATH Environment Injection: The server adds common Node.js/npm paths to the subprocess environment since MCP servers don't inherit user PATH.

  2. NVM-Windows Support: Automatically detects NVM_HOME and NVM_SYMLINK environment variables for users with nvm-windows.

  3. Full Path Resolution: Searches multiple locations to find gemini.cmd:

    • %NVM_SYMLINK%\gemini.cmd

    • %APPDATA%\npm\gemini.cmd

    • %NVM_HOME%\vX.X.X\gemini.cmd

    • C:\Program Files\nodejs\gemini.cmd


Development

Building from Source

git clone https://github.com/GlitterKill/gemini-mcp-ultimate.git
cd gemini-mcp-ultimate
npm install
npm run build

Running Locally

# Build and run
npm run dev

# Or just run after building
node dist/index.js

Adding to Claude Code (local development)

claude mcp add gemini-dev -- node /path/to/gemini-mcp-ultimate/dist/index.js

Project Structure

src/
├── index.ts                 # MCP server entry point
├── constants.ts             # Shared constants
├── tools/
│   ├── registry.ts          # Tool registration system
│   ├── ask-gemini.tool.ts   # Main Gemini interface
│   ├── brainstorm.tool.ts   # Brainstorming tool
│   └── ...
└── utils/
    ├── commandExecutor.ts   # Platform-aware process spawning
    ├── geminiExecutor.ts    # Gemini CLI command builder
    └── ...

Contributing

Contributions are welcome. Please:

  1. Fork the repository

  2. Create a feature branch

  3. Make your changes

  4. Run npm run lint to check for errors

  5. Submit a pull request


License

MIT License - see LICENSE for details.


Credits

Available Tools

8 tools
ask-geminiD

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

ParametersJSON Schema
NameRequiredDescriptionDefault
modelNoOptional model to use (e.g., 'gemini-3-flash-preview'). If not specified, uses the default model (gemini-3-pro-preview).
promptYesAnalysis request. Use @ syntax to include files (e.g., '@largefile.js explain what this does') or ask general questions
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)
session_idNoSession ID or index to resume a previous conversation context (maps to --resume)
allowed_toolsNoSpecific tools to allow without confirmation (overrides approval_mode)
approval_modeNoAutonomy control: 'default' (ask), 'auto_edit' (allow edits), 'yolo' (allow all)yolo
chunkCacheKeyNoOptional cache key for continuation
output_formatNoOutput format: 'text' (default), 'json', or 'stream-json'
experimental_acpNoEnable experimental ACP (Agentic Coding Protocol) mode
include_directoriesNoAdditional directories to include in the workspace context

TDQS

D1.9/5.0
Behavior2/5

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

With no annotations, the description carries the full behavioral burden, and it discloses almost nothing: not that this makes an external LLM call, nor latency, cost, permissions, or what the response looks like. The only hints ('sandbox', 'for providing edits') restate schema semantics rather than adding behavioral context. It does not contradict anything, but it leaves the agent uninformed.

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?

It is short, but shortness here is under-specification, not conciseness: it is a sentence fragment with no purpose statement to front-load. The listed modifiers (model, sandbox) are not the most important information an agent needs to invoke the tool.

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

Completeness1/5

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

A 12-parameter tool with no annotations and no output schema requires a substantive description, and this provides essentially none. Nothing about model defaults, session resumption, approval autonomy, or the external-call nature is explained at the description level.

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% and the schema itself documents all 12 parameters in detail, so the baseline is 3 even with no real param explanation in the description. The description adds only trivial flag aliases ('[-m]', '[-s]') and the type of changeMode, nothing 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 text never states what the tool actually does — it never says it sends a prompt to Gemini or returns analysis. It only enumerates a few parameters (model, sandbox, changeMode), which is a parameter summary rather than a purpose statement. An agent cannot tell from this how ask-gemini differs from siblings like brainstorm or manage-sessions.

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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives despite seven sibling tools. The fragments 'sandbox [-s]' and 'changeMode:boolean for providing edits' are labels, not conditions for choosing this tool.

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

brainstormB

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
modelNoOptional model to use (e.g., 'gemini-3-flash-preview'). If not specified, uses the default model (gemini-3-pro-preview).
domainNoDomain context for specialized brainstorming (e.g., 'software', 'business', 'creative', 'research', 'product', 'marketing')
promptYesPrimary brainstorming challenge or question to explore
ideaCountNoTarget number of ideas to generate (default: 12, max: 100)
constraintsNoKnown limitations, requirements, or boundaries (budget, time, technical, legal, etc.)
methodologyNoBrainstorming framework: 'divergent' (generate many ideas), 'convergent' (refine existing), 'scamper' (systematic triggers), 'design-thinking' (human-centered), 'lateral' (unexpected connections), 'auto' (AI selects best)auto
existingContextNoBackground information, previous attempts, or current state to build upon
includeAnalysisNoInclude feasibility, impact, and implementation analysis for generated ideas

TDQS

B3.4/5.0
Behavior3/5

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

No annotations exist, so the description carries the full behavioral burden. It does disclose that the tool performs dynamic context gathering, idea clustering, feasibility analysis, and iterative refinement, which is meaningful multi-step behavior beyond what the schema shows. However it says nothing about cost, latency, or how the iterative refinement cycle terminates.

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?

Two sentences, front-loaded with the core action and followed by a capability list. The '-->' arrow formatting is unconventional but compact and wastes no words.

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 an 8-parameter generative tool with no output schema and no annotations, the description covers capabilities but omits return format, output size relative to ideaCount, and how model/methodology interact. Adequate but leaves real gaps for an agent to fill.

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 every parameter is already documented in the schema. The description mentions SCAMPER and Design Thinking, loosely mapping to the methodology enum, but adds no syntax or format detail beyond what the schema provides. Baseline 3 applies.

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?

States a specific verb and resource ('Generate novel ideas') and enumerates the processing it performs (frameworks, domain context, clustering, feasibility analysis, iterative refinement). No sibling tool overlaps with brainstorming, so differentiation is implicit but the purpose is unmistakable.

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?

Implies a creative-ideation use case through words like 'novel ideas' and 'brainstorming challenge', but never states when to choose this over a sibling like ask-gemini or when it is inappropriate. Usage is inferable rather than stated.

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.

manage-extensionsC

Manage Gemini CLI extensions: list, install, uninstall, update, enable, disable.

ParametersJSON Schema
NameRequiredDescriptionDefault
allNoUpdate all extensions. Only valid with 'update' action.
scopeNoScope for enable/disable (e.g. 'project' or 'global'). Defaults to project if omitted.
actionYesThe action to perform on extensions.
targetNoThe name, path, or URL of the extension. Required for install, uninstall, enable, disable, update (single), and validate.

TDQS

C2.9/5.0
Behavior2/5

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

With no annotations, the description carries the full behavioral burden. It names destructive actions like uninstall and disable, but does not state permissions required, reversibility, side effects, or whether operations affect shared state. Only the action names hint at behavior.

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 a single front-loaded sentence with no wasted words. It is efficient, though the action list is incomplete because it omits 'validate'.

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?

The schema is fully documented, which carries most of the parameter burden. However, for a multi-action tool with no annotations, the description does not explain destructive implications, permissions, or scope behavior, and it omits one valid action.

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 schema already documents all four parameters, including enums and conditional rules. The description adds no parameter-level meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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 gives a clear verb ('Manage') and resource ('Gemini CLI extensions') and enumerates most supported operations. However, it omits 'validate', which is present in the action enum, so the scope is not fully aligned with the schema.

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 lists possible actions but gives no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. Sibling tools are unrelated, so the omission is less harmful, but the definition still provides no usage context.

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

manage-sessionsB

Manage conversation sessions: list active sessions or delete old ones.

ParametersJSON Schema
NameRequiredDescriptionDefault
actionNoAction to perform: 'list' active sessions or 'delete' a specific sessionlist
session_idNoSession ID or index to delete (required for 'delete' action)

TDQS

B3.2/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 the full burden of behavioral disclosure. It does flag that deletion is one of the operations, but says nothing about whether deletion is permanent or reversible, what permissions are required, whether 'old' is a threshold or user-chosen, or what happens to an active session if deleted.

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?

A single compact sentence, front-loaded with the resource and immediately followed by the two operations. No wasted clauses, though it is terse for a dual-mode tool with a destructive branch.

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 two-action tool with no annotations and no output schema, the description covers the operations but omits what a listing returns and what a deletion does to session data or callers. It is minimally adequate, with the schema filling the parameter gap but nothing covering behavior or returns.

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 enum for action and the role of session_id are already fully documented in the schema. The description adds only the slight nuance that deletion targets 'old' sessions; otherwise it does not extend parameter meaning beyond structured fields. Baseline 3 applies.

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 states a clear verb-plus-resource ('Manage conversation sessions') and enumerates the two concrete operations, list and delete. That is enough for an agent to distinguish it from siblings like ping, brainstorm, or manage-extensions, though 'manage' itself is a vague umbrella verb.

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?

It implicitly covers the two usage modes by naming 'list active sessions or delete old ones', but gives no guidance on which action to pick when, no exclusions, and no alternatives (no sibling tool overlaps here). Usage is implied rather than instructed.

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

pingD

Echo

ParametersJSON Schema
NameRequiredDescriptionDefault
promptNoMessage to echo back

TDQS

D1.8/5.0
Behavior1/5

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no return format, no latency/connectivity semantics, no indication of what happens with an empty prompt. 'Echo' alone leaves the agent guessing about the tool's actual behavior.

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?

One word is technically concise but reflects under-specification rather than efficiency; there is no front-loaded purpose, scope, or context to structure. It saves characters at the cost of usability.

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?

The tool is trivial (single optional string, no output schema), so a short description could suffice, but even a minimal definition should state the purpose, such as a connectivity test. As written, the description is inadequate to guide correct invocation relative to the ping name vs echo behavior.

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 single optional 'prompt' parameter documented as 'Message to echo back' with a default of ''. Per the baseline rule for high schema coverage, 3 is appropriate since the schema already does the work and the description adds nothing further.

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 restates the obvious behavior implied by the 'prompt' parameter without naming a resource or distinguishing it from siblings like 'Help' or 'timeout-test'. It conveys a vague notion of echoing input but gives no scope, format, or purpose beyond tautology.

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?

There is no indication of when to use this tool, when not to, or how it relates to alternatives such as 'Help' or 'timeout-test'. An agent cannot tell whether this is a health check, a connectivity probe, or a literal echo utility from the description alone.

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. 8 tool updatesv2.0.3
    • First observedask-gemini
    • First observedbrainstorm
    • First observedfetch-chunk
    • First observedHelp
    • First observedmanage-extensions
    • First observedmanage-sessions
    • First observedping
    • First observedtimeout-test

TDQS

B3/5.0

Scored across 8 tools

Disambiguation4/5

Most tools have distinct purposes: ask-gemini for queries, fetch-chunk for retrieving changeMode chunks, manage-sessions and manage-extensions for separate resources, and brainstorm for idea generation. ping, Help, and timeout-test are utility tools, but their specific intents are still distinguishable.

Naming Consistency3/5

The naming is mixed: Help is capitalized while most others use lowercase kebab-case, brainstorm is a single verb, and ask-gemini/fetch-chunk/timeout-test/manage-* follow different patterns. The names are readable, but there is no single predictable convention.

Tool Count5/5

Eight tools is well-scoped for a Gemini CLI MCP server, covering core querying, chunk retrieval, session and extension management, brainstorming, and basic diagnostics. No tool feels excessive or trivially redundant.

Completeness4/5

The surface covers the main lifecycle: ask-gemini for requests, fetch-chunk for streaming/changeMode responses, manage-sessions for conversation state, and manage-extensions for CLI extensions. A few areas like explicit session history retrieval or cancellation are missing, but core workflows are covered.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    F
    maintenance
    A lightweight server that connects Claude Code with Google's Gemini AI models, allowing developers to leverage Gemini's massive context window (1M+ tokens) for code analysis without leaving their coding environment.
    233
    MIT
  • F
    license
    Not graded
    quality
    D
    maintenance
    Enables comprehensive codebase analysis using Google's Gemini CLI and its massive context window. Supports file/directory analysis, security audits, architecture analysis, feature verification, and complete project overviews for large codebases that exceed other AI models' context limits.
    -