Gemini MCP Ultimate
Allows Claude to offload large file analysis and queries to Google's Gemini models, leveraging massive context windows and persistent sessions to reduce token usage.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Gemini MCP Ultimateanalyze this 10,000-line codebase for bugs and suggest fixes"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Gemini MCP Ultimate
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.
Installation • Usage • Tools • Troubleshooting
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) | |
Gemini CLI | Latest |
|
Google Account | - | Required for Gemini authentication |
Quick Install
For Claude Code (CLI):
claude mcp add gemini-mcp-ultimate -- npx -y gemini-mcp-ultimateFor Claude Desktop:
Add to your MCP configuration file:
Platform | Configuration File Location |
Windows |
|
macOS |
|
Linux |
|
{
"mcpServers": {
"gemini-mcp-ultimate": {
"command": "npx",
"args": ["-y", "gemini-mcp-ultimate"]
}
}
}Platform-Specific Instructions
Linux / macOS
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 20Install Gemini CLI globally:
npm install -g @google/gemini-cliAuthenticate with Gemini:
gemini # Follow the browser prompts to sign in with your Google accountAdd the MCP server:
claude mcp add gemini-mcp-ultimate -- npx -y gemini-mcp-ultimateRestart 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.
Open PowerShell (not Command Prompt):
Press
Win + Xand select "Windows PowerShell" or "Terminal"Or search for "PowerShell" in the Start menu
Do not use
cmd.exeas it may not have the correct PATH
Install Node.js:
Download from nodejs.org (LTS recommended)
Or use nvm-windows:
# After installing nvm-windows nvm install 20 nvm use 20
Install Gemini CLI globally (in PowerShell):
npm install -g @google/gemini-cliAuthenticate with Gemini (in PowerShell):
gemini # Follow the browser prompts to sign in with your Google accountVerify 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 geminiVerify 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_SYMLINKAdd the MCP server (in PowerShell):
claude mcp add gemini-mcp-ultimate -- npx -y gemini-mcp-ultimateRestart Claude Code to load the new MCP server.
If the MCP server cannot find Gemini, see Windows Troubleshooting below.
Verify Installation
After installation, verify the MCP server is working:
Open Claude Code or Claude Desktop
Type
/mcpto see connected serversYou should see
gemini-mcp-ultimatelistedTest 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 questionWith 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-upToken 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 filesTools Reference
ask-gemini
The primary tool for interacting with Gemini CLI.
Parameter | Type | Default | Description |
| string | required | Your query. Use |
| string |
| Model to use. Falls back to |
| string/number | - | Resume a previous session by ID or index. |
| string |
|
|
| boolean |
| Run in isolated sandbox environment. |
| string[] | - | Additional directories to include in context. |
| string[] | - | Whitelist specific tools Gemini can use. |
| string |
|
|
| boolean |
| 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 |
| string | required | The challenge or topic to brainstorm. |
| number | 12 | Number of ideas to generate. |
| string |
| Framework: |
| string | - | Domain context (e.g., |
| string | - | Limitations or requirements to consider. |
| boolean |
| Include feasibility/impact ratings. |
Example:
prompt: "Ways to reduce API response times"
domain: "software"
methodology: "scamper"
ideaCount: 5manage-sessions
List or delete Gemini conversation sessions.
Parameter | Type | Default | Description |
| string |
|
|
| 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 |
| string | required |
|
| string | - | Extension name or URL. |
| string |
|
|
| boolean | - | Update all extensions (with |
Example:
# List installed extensions
action: "list"
# Install an extension
action: "install"
target: "conductor"
# Update all extensions
action: "update"
all: trueping
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 textUsage Examples
1. Basic File Analysis
User prompt:
"Use Gemini to explain what @src/utils/commandExecutor.ts does"
What happens:
Claude calls
ask-geminiwith the file referenceGemini reads the file and analyzes it
Returns explanation to Claude
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:
Restart Claude Code/Desktop completely
Check that Node.js is installed:
node --versionVerify npx works:
npx --version
"Gemini command not found" errors:
Install Gemini CLI:
npm install -g @google/gemini-cliVerify installation:
gemini --versionRe-authenticate:
gemini(follow prompts)
Quota exceeded errors:
The server automatically falls back from
gemini-3-pro-previewtogemini-3-flash-previewYou 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:
npm global commands are
.cmdbatch files, not executablesMCP servers run in isolated environments without user PATH
Node.js may be installed via nvm-windows with non-standard paths
If Gemini cannot be found:
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.cmdVerify 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" }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') }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)
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 $fullPathVerify 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
PATH Environment Injection: The server adds common Node.js/npm paths to the subprocess environment since MCP servers don't inherit user PATH.
NVM-Windows Support: Automatically detects
NVM_HOMEandNVM_SYMLINKenvironment variables for users with nvm-windows.Full Path Resolution: Searches multiple locations to find
gemini.cmd:%NVM_SYMLINK%\gemini.cmd%APPDATA%\npm\gemini.cmd%NVM_HOME%\vX.X.X\gemini.cmdC:\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 buildRunning Locally
# Build and run
npm run dev
# Or just run after building
node dist/index.jsAdding to Claude Code (local development)
claude mcp add gemini-dev -- node /path/to/gemini-mcp-ultimate/dist/index.jsProject 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:
Fork the repository
Create a feature branch
Make your changes
Run
npm run lintto check for errorsSubmit a pull request
License
MIT License - see LICENSE for details.
Credits
Original project: jamubc/gemini-mcp-tool
Windows compatibility fixes and enhancements by GlitterKill
Available Tools
8 toolsask-geminiD
model selection [-m], sandbox [-s], and changeMode:boolean for providing edits
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | Optional model to use (e.g., 'gemini-3-flash-preview'). If not specified, uses the default model (gemini-3-pro-preview). | |
| prompt | Yes | Analysis request. Use @ syntax to include files (e.g., '@largefile.js explain what this does') or ask general questions | |
| sandbox | No | Use sandbox mode (-s flag) to safely test code changes, execute scripts, or run potentially risky operations in an isolated environment | |
| changeMode | No | Enable structured change mode - formats prompts to prevent tool errors and returns structured edit suggestions that Claude can apply directly | |
| chunkIndex | No | Which chunk to return (1-based) | |
| session_id | No | Session ID or index to resume a previous conversation context (maps to --resume) | |
| allowed_tools | No | Specific tools to allow without confirmation (overrides approval_mode) | |
| approval_mode | No | Autonomy control: 'default' (ask), 'auto_edit' (allow edits), 'yolo' (allow all) | yolo |
| chunkCacheKey | No | Optional cache key for continuation | |
| output_format | No | Output format: 'text' (default), 'json', or 'stream-json' | |
| experimental_acp | No | Enable experimental ACP (Agentic Coding Protocol) mode | |
| include_directories | No | Additional directories to include in the workspace context |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | Optional model to use (e.g., 'gemini-3-flash-preview'). If not specified, uses the default model (gemini-3-pro-preview). | |
| domain | No | Domain context for specialized brainstorming (e.g., 'software', 'business', 'creative', 'research', 'product', 'marketing') | |
| prompt | Yes | Primary brainstorming challenge or question to explore | |
| ideaCount | No | Target number of ideas to generate (default: 12, max: 100) | |
| constraints | No | Known limitations, requirements, or boundaries (budget, time, technical, legal, etc.) | |
| methodology | No | Brainstorming framework: 'divergent' (generate many ideas), 'convergent' (refine existing), 'scamper' (systematic triggers), 'design-thinking' (human-centered), 'lateral' (unexpected connections), 'auto' (AI selects best) | auto |
| existingContext | No | Background information, previous attempts, or current state to build upon | |
| includeAnalysis | No | Include feasibility, impact, and implementation analysis for generated ideas |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| cacheKey | Yes | The cache key provided in the initial changeMode response | |
| chunkIndex | Yes | Which chunk to retrieve (1-based index) |
TDQS
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.
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.
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.
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.
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.
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
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| all | No | Update all extensions. Only valid with 'update' action. | |
| scope | No | Scope for enable/disable (e.g. 'project' or 'global'). Defaults to project if omitted. | |
| action | Yes | The action to perform on extensions. | |
| target | No | The name, path, or URL of the extension. Required for install, uninstall, enable, disable, update (single), and validate. |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| action | No | Action to perform: 'list' active sessions or 'delete' a specific session | list |
| session_id | No | Session ID or index to delete (required for 'delete' action) |
TDQS
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.
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.
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.
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.
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.
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
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | No | Message to echo back |
TDQS
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.
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.
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.
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.
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.
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
| Name | Required | Description | Default |
|---|---|---|---|
| duration | Yes | Duration in milliseconds (minimum 10ms) |
TDQS
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.
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.
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.
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.
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.
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.
8 tool updates
v2.0.3- First observed
ask-gemini - First observed
brainstorm - First observed
fetch-chunk - First observed
Help - First observed
manage-extensions - First observed
manage-sessions - First observed
ping - First observed
timeout-test
TDQS
Scored across 8 tools
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.
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.
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.
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
Related MCP Connectors
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Persistent context for Claude. Your AI always knows your projects and next actions across sessions.
Shared memory for coding agents. Stop re-explaining your codebase every session.
Persistent cross-session memory shared by Codex, Claude Code, ChatGPT, and other AI agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceLeverages Google's Gemini AI with a 1M token context window for comprehensive codebase analysis, enabling intelligent code search, architecture analysis, and targeted improvement suggestions.MIT
- AlicenseNot gradedqualityFmaintenanceA 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.233MIT
- FlicenseNot gradedqualityDmaintenanceEnables 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.-
- AlicenseNot gradedqualityDmaintenanceEnables Claude Code to consult Gemini for complex coding problems with session management, file attachments, and conversation persistence.105MIT