Which integrations are available for this server?

Provides image generation capabilities using Google's Gemini AI models with customizable parameters like style and temperature

How do I use Gemini MCP Server for Claude Desktop?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Gemini MCP Server for Claude Desktop generate an image of a futuristic city at night with neon lights" 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.

en es ja ko zh

Gemini MCP Server for Claude Desktop

by Garblesnarff

Overview Schema Related Servers Score Discussions

JavaScript

Hybrid

Gemini MCP Server with Smart Tool Intelligence

Welcome to the Gemini MCP Server, the first MCP server with Smart Tool Intelligence - a revolutionary self-learning system that adapts to your preferences and improves over time. This comprehensive platform provides 7 AI-powered tools with automatic prompt enhancement and context awareness.

🚀 Features Overview

🤖 7 AI-Powered Tools

Image Generation - Create images from text prompts using Gemini 2.0 Flash
Image Editing - Edit existing images with natural language instructions
Chat - Interactive conversations with context-aware responses
Audio Transcription - Convert audio to text with optional verbatim mode
Code Execution - Run Python code in a secure sandbox environment
Video Analysis - Analyze video content for summaries, transcripts, and insights
Image Analysis - Extract objects, text, and detailed descriptions from images

🧠 Smart Tool Intelligence System (First in MCP Ecosystem)

Self-Learning - Automatically learns from successful interactions
Context Detection - Recognizes consciousness research, coding, debugging contexts
Pattern Recognition - Identifies usage patterns and user preferences
Prompt Enhancement - Refines prompts for better AI model performance
Persistent Memory - Stores learned preferences across sessions
Automatic Migration - Seamlessly upgrades preference storage

Related MCP server: MCP Server Gemini

📦 Quick Start

Installation

git clone https://github.com/Garblesnarff/gemini-mcp-server.git
cd gemini-mcp-server
npm install

Configuration

Get your Gemini API key from Google AI Studio
Copy the environment template:
```
cp .env.example .env
```

Edit .env and add your API key:

GEMINI_API_KEY=your_actual_api_key_here
OUTPUT_DIR=/path/to/your/output/directory  # Optional
DEBUG=false  # Optional

Running the Server

npm start
# or for development with debug logging:
npm run dev

Integration with Claude Desktop

Add to your Claude Desktop config (claude_desktop_config.json):

{
  \"mcpServers\": {
    \"gemini\": {
      \"command\": \"node\",
      \"args\": [\"/path/to/gemini-mcp-server/gemini-server.js\"],
      \"env\": {
        \"GEMINI_API_KEY\": \"your_api_key_here\"
      }
    }
  }
}

🛠️ Tool Reference

1. Image Generation (`generate_image`)

Generate images from text descriptions using Gemini 2.0 Flash.

Parameters:

prompt (string, required) - Description of the image to generate
context (string, optional) - Context for Smart Tool Intelligence enhancement

Example:

{
  \"prompt\": \"A serene mountain landscape at sunset with vibrant colors\",
  \"context\": \"artistic\"
}

Returns:

{
  \"content\": [{
    \"type\": \"text\",
    \"text\": \"Generated a beautiful mountain landscape image.\"
  }, {
    \"type\": \"image\", 
    \"data\": \"base64_image_data\",
    \"mimeType\": \"image/png\"
  }]
}

2. Image Editing (`gemini-edit-image`)

Edit existing images using natural language instructions.

Parameters:

image_path (string, required) - Path to the image file to edit
edit_instruction (string, required) - Description of desired changes
context (string, optional) - Context for enhancement

Example:

{
  \"image_path\": \"/path/to/image.jpg\",
  \"edit_instruction\": \"Add shooting stars to the night sky\",
  \"context\": \"artistic\"
}

3. Chat (`gemini-chat`)

Interactive conversations with Gemini AI that learns your preferences.

Parameters:

message (string, required) - Your message or question
context (string, optional) - Context for Smart Tool Intelligence

Example:

{
  \"message\": \"Explain quantum computing in simple terms\",
  \"context\": \"consciousness\"  // Will apply academic rigor enhancement
}

4. Audio Transcription (`gemini-transcribe-audio`)

Convert audio files to text with Smart Tool Intelligence enhancement.

Parameters:

file_path (string, required) - Path to audio file (MP3, WAV, FLAC, AAC, OGG, WEBM, M4A)
language (string, optional) - Language hint for better accuracy
context (string, optional) - Use "verbatim" for exact word-for-word transcription
preserve_spelled_acronyms (boolean, optional) - Keep U-R-L instead of URL

Example (Standard):

{
  \"file_path\": \"/path/to/audio.mp3\",
  \"language\": \"en\"
}

Example (Verbatim Mode):

{
  \"file_path\": \"/path/to/audio.mp3\",
  \"context\": \"verbatim\",  // Gets exact word-for-word transcription
  \"preserve_spelled_acronyms\": true
}

Verbatim Mode Features:

Captures all "um", "uh", "like", repeated words
Preserves emotional expressions: [laughs], [sighs], [clears throat]
Maintains original punctuation and sentence structure
No summarization or cleanup

5. Code Execution (`gemini-code-execute`)

Execute Python code in a secure sandbox environment.

Parameters:

code (string, required) - Python code to execute
context (string, optional) - Context for enhancement

Example:

{
  \"code\": \"import pandas as pd\\ndata = {'x': [1,2,3], 'y': [4,5,6]}\\ndf = pd.DataFrame(data)\\nprint(df.describe())\",
  \"context\": \"code\"
}

6. Video Analysis (`gemini-analyze-video`)

Analyze video content for summaries, transcripts, and detailed insights.

Parameters:

file_path (string, required) - Path to video file (MP4, MOV, AVI, WEBM, MKV, FLV)
analysis_type (string, optional) - "summary", "transcript", "objects", "detailed", "custom"
context (string, optional) - Context for enhancement

Example:

{
  \"file_path\": \"/path/to/video.mp4\",
  \"analysis_type\": \"detailed\"
}

7. Image Analysis (`gemini-analyze-image`)

Extract detailed information from images including objects, text, and descriptions.

Parameters:

file_path (string, required) - Path to image file (JPEG, PNG, WebP, HEIC, HEIF, BMP, GIF)
analysis_type (string, optional) - "summary", "objects", "text", "detailed", "custom"
context (string, optional) - Context for enhancement

Example:

{
  \"file_path\": \"/path/to/image.jpg\",
  \"analysis_type\": \"objects\"
}

🧠 Smart Tool Intelligence System

How It Works

The Smart Tool Intelligence system is the first of its kind in the MCP ecosystem. It automatically:

Detects Context - Recognizes if you're doing consciousness research, coding, debugging, etc.
Enhances Prompts - Adds relevant instructions based on learned patterns
Learns Patterns - Stores successful interaction patterns for future use
Adapts Over Time - Gets better at helping you with each interaction

Context Types

The system recognizes these contexts and applies appropriate enhancements:

consciousness - Adds academic rigor, citations, detailed explanations
code - Includes practical examples, working code, best practices
debugging - Focuses on root cause analysis and specific fixes
general - Applies comprehensive, structured responses
verbatim - For audio transcription, provides exact word-for-word output

Storage Location

Preferences are stored internally at ./data/tool-preferences.json with automatic migration from external storage.

Implementing Smart Tool Intelligence in Your MCP Server

Want to add this revolutionary capability to your own MCP server? Here's how:

1. Core Architecture

// src/intelligence/context-detector.js
class ContextDetector {
  detectContext(prompt, toolName) {
    // Implement pattern matching for different contexts
    if (this.isConsciousnessContext(prompt)) return 'consciousness';
    if (this.isCodeContext(prompt)) return 'code';
    if (this.isDebuggingContext(prompt)) return 'debugging';
    return 'general';
  }
}

// src/intelligence/prompt-enhancer.js  
class PromptEnhancer {
  enhancePrompt(originalPrompt, context, toolName) {
    // Apply context-specific enhancements
    const enhancement = this.getEnhancementForContext(context);
    return `${originalPrompt}\\n\\n${enhancement}`;
  }
}

// src/intelligence/preference-store.js
class PreferencesManager {
  async storePattern(original, enhanced, context, toolName, success) {
    // Store successful patterns for future learning
  }
  
  async getPatterns(context) {
    // Retrieve learned patterns for context
  }
}

2. Integration Pattern

// In your tool's execute method:
async execute(args) {
  const intelligence = IntelligenceSystem.getInstance();
  
  // Detect context and enhance prompt
  const context = args.context || intelligence.contextDetector.detectContext(args.prompt, this.name);
  const enhancedPrompt = await intelligence.enhancePrompt(args.prompt, context, this.name);
  
  // Execute with enhanced prompt
  const result = await this.geminiService.generateContent(enhancedPrompt);
  
  // Store successful pattern
  await intelligence.storeSuccessfulPattern(args.prompt, enhancedPrompt, context, this.name);
  
  return result;
}

3. Key Implementation Files

Study these files from this repository:

src/intelligence/index.js - Main intelligence coordinator
src/intelligence/context-detector.js - Context recognition logic
src/intelligence/prompt-enhancer.js - Enhancement application
src/intelligence/preference-store.js - Pattern storage and retrieval
src/tools/base-tool.js - Integration with tool execution

🧪 Testing

Run Test Suite

# Test basic functionality
npm test

# Test Smart Tool Intelligence
node test-tool-intelligence-full.js

# Test internal storage
node test-internal-storage.js

# Test verbatim transcription
node test-verbatim-mode.js

Manual Testing Examples

# Test image generation
echo '{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{\"name\":\"generate_image\",\"arguments\":{\"prompt\":\"A cute robot reading a book\"}}}' | node gemini-server.js

# Test chat with consciousness context
echo '{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"tools/call\",\"params\":{\"name\":\"gemini-chat\",\"arguments\":{\"message\":\"What is consciousness?\",\"context\":\"consciousness\"}}}' | node gemini-server.js

📊 Performance & Limits

File Size Limits

Images: 20MB (JPEG, PNG, WebP, HEIC, HEIF, BMP, GIF)
Audio: 20MB (MP3, WAV, FLAC, AAC, OGG, WEBM, M4A)
Video: 100MB (MP4, MOV, AVI, WEBM, MKV, FLV)

API Rate Limits

Follows Google Gemini API rate limits
Built-in error handling and retry logic
Graceful degradation on quota exceeded

🏗️ Architecture Deep Dive

Modular Design

src/
├── server.js              # MCP protocol handler
├── config.js              # Configuration management
├── tools/                 # Tool implementations
│   ├── index.js           # Tool registry & dispatcher
│   ├── base-tool.js       # Abstract base class
│   ├── chat.js            # Chat tool
│   ├── image-generation.js # Image generation tool
│   ├── image-editing.js   # Image editing tool
│   ├── audio-transcription.js # Audio transcription tool
│   ├── code-execution.js  # Code execution tool
│   ├── video-analysis.js  # Video analysis tool
│   └── image-analysis.js  # Image analysis tool
├── intelligence/          # Smart Tool Intelligence
│   ├── index.js           # Intelligence coordinator
│   ├── context-detector.js # Context recognition
│   ├── prompt-enhancer.js # Prompt enhancement
│   └── preference-store.js # Pattern storage
├── gemini/               # Gemini API integration
│   ├── gemini-service.js # API service layer
│   └── request-handler.js # Request formatting
└── utils/                # Utilities
    ├── logger.js         # Logging system
    └── file-utils.js     # File operations

Intelligence System Flow

Request Received → Tool's execute method called
Context Detection → Analyze prompt for context clues
Pattern Retrieval → Get relevant learned patterns
Prompt Enhancement → Apply context-specific improvements
API Execution → Send enhanced prompt to Gemini
Pattern Storage → Store successful interaction pattern
Response Return → Return enhanced result to user

🔧 Customization

Adding New Contexts

// In src/intelligence/context-detector.js
isMyCustomContext(prompt) {
  const patterns = [
    /custom pattern 1/i,
    /custom pattern 2/i
  ];
  return patterns.some(pattern => pattern.test(prompt));
}

// In src/intelligence/prompt-enhancer.js
getEnhancementForContext(context) {
  const enhancements = {
    'my_custom_context': 'Apply my custom enhancement instructions here.',
    // ... other contexts
  };
  return enhancements[context] || enhancements.general;
}

Adding New Tools

Create tool file in src/tools/my-new-tool.js
Extend BaseTool class
Implement execute method with intelligence integration
Register in src/tools/index.js

// src/tools/my-new-tool.js
class MyNewTool extends BaseTool {
  constructor(geminiService, intelligenceSystem) {
    super('my-new-tool', 'Description of my tool', geminiService, intelligenceSystem);
  }
  
  async execute(args) {
    // Use intelligence system for enhancement
    const context = args.context || this.detectContext(args.input);
    const enhancedPrompt = await this.enhancePrompt(args.input, context);
    
    // Your tool logic here
    const result = await this.geminiService.someMethod(enhancedPrompt);
    
    // Store successful pattern  
    await this.storeSuccessfulPattern(args.input, enhancedPrompt, context);
    
    return result;
  }
}

🐛 Troubleshooting

Common Issues

"Missing GEMINI_API_KEY" Error

# Ensure .env file exists and contains your API key
cp .env.example .env
# Edit .env and add: GEMINI_API_KEY=your_key_here

"File not found" Errors

# Ensure file paths are absolute and files exist
# Check file permissions and formats

Intelligence System Not Learning

# Check data directory permissions
ls -la data/
# Verify tool-preferences.json is writable

Debug Mode

DEBUG=true npm start
# or
npm run dev

Logs Location

Application logs: Console output
Intelligence patterns: ./data/tool-preferences.json
Generated images: $OUTPUT_DIR (default: ~/Claude/gemini-images)

🤝 Contributing

We welcome contributions! This project represents a new paradigm in MCP server development.

Development Setup

git clone https://github.com/Garblesnarff/gemini-mcp-server.git
cd gemini-mcp-server
npm install
npm run dev

Areas for Contribution

New Contexts - Add support for specialized domains
Enhanced Patterns - Improve learning algorithms
New Tools - Expand Gemini AI capabilities
Performance - Optimize intelligence system performance
Documentation - Improve guides and examples

📈 Roadmap

Multi-language Support - Context detection in multiple languages
Advanced Analytics - Usage patterns and performance metrics
Tool Chaining - Intelligent coordination between multiple tools
Custom Models - Support for fine-tuned Gemini models
Collaborative Learning - Share anonymized patterns across instances
Visual Interface - Web-based configuration and monitoring

🌟 Why This Matters

This is the first MCP server that truly learns and adapts. Traditional MCP servers are static - they do the same thing every time. Our Smart Tool Intelligence system represents a paradigm shift toward AI tools that become more helpful over time.

For Users: Better results with less effort as the system learns your preferences.
For Developers: A blueprint for building truly intelligent, adaptive AI tools.
For the MCP Ecosystem: A new standard for what MCP servers can become.

📄 License

This project is licensed under the MIT License - feel free to use, modify, and distribute.

🙏 Acknowledgments

Built with:

Google Gemini AI - Powering the core AI capabilities
Model Context Protocol - Enabling seamless integration
Node.js & NPM - Runtime and package management
Claude & Rob - Human-AI collaboration at its finest

Ready to experience the future of MCP servers? Get started now and watch your AI tools become smarter with every interaction! 🚀"

Available Tools

10 tools

gemini-advanced-imageC

Generate advanced images with Gemini 2.5 Flash Image: multi-image fusion, character consistency, targeted editing, and template adherence

ParametersJSON Schema

Name	Required	Description
`prompt`	Yes	Text description of the desired image or editing instruction
`mode`	No	Generation mode: fusion (blend multiple images), consistency (maintain character/style), targeted_edit (precise edits), template (follow layout), standard (basic generation)
`reference_images`	No	Optional array of file paths to reference images for fusion, consistency, or template modes
`context`	No	Optional context for intelligent enhancement (e.g., "fusion", "consistency", "artistic")

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions advanced features like fusion and consistency but doesn't explain operational details: whether it requires authentication, has rate limits, what happens with invalid inputs, or the format/quality of outputs. For a complex image generation tool with multiple modes, this leaves significant gaps in understanding how it behaves.

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

Conciseness5/5

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

The description is a single, efficient sentence that front-loads the core purpose ('Generate advanced images') and lists key capabilities without unnecessary words. Every phrase earns its place by highlighting distinct features, making it easy to scan and understand quickly.

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

Completeness2/5

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

For a complex tool with 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address critical context like output format (e.g., image file, URL), error handling, or usage constraints. The lack of behavioral details and guidelines leaves the agent under-informed about how to effectively invoke this tool.

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%, providing good documentation for all parameters. The description adds marginal value by hinting at parameter usage through mode names (e.g., 'multi-image fusion' relates to 'fusion' mode and 'reference_images'), but doesn't explain semantics beyond what the schema already covers. Baseline 3 is appropriate since the schema does the heavy lifting.

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

Purpose4/5

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

The description clearly states the tool's purpose: 'Generate advanced images with Gemini 2.5 Flash Image' followed by specific capabilities like multi-image fusion, character consistency, targeted editing, and template adherence. It distinguishes itself from basic image generation tools by emphasizing 'advanced' features, though it doesn't explicitly differentiate from sibling tools like 'generate_image' or 'gemini-edit-image'.

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 capabilities but provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'generate_image' for basic needs or 'gemini-edit-image' for simpler edits, nor does it specify prerequisites like needing reference images for certain modes. Usage is implied through mode descriptions but not explicitly stated.

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

gemini-analyze-imageC

Analyze images using Gemini's multimodal vision capabilities (with learned user preferences)

ParametersJSON Schema

Name	Required	Description
`file_path`	Yes	Path to the image file to analyze (supports JPEG, PNG, WebP, HEIC, HEIF, BMP, GIF)
`analysis_type`	No	Type of analysis to perform: "summary", "objects", "text", "detailed", or "custom"
`context`	No	Optional context for intelligent enhancement (e.g., "medical", "architectural", "nature")

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'multimodal vision capabilities' and 'learned user preferences' but doesn't explain what these mean operationally. It doesn't disclose whether this is a read-only operation, what permissions are needed, rate limits, error conditions, or what the output format looks like. For a tool with no annotation coverage, this leaves significant behavioral gaps.

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

Conciseness4/5

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

The description is a single, efficient sentence that states the core functionality. The parenthetical about 'learned user preferences' adds some context without being verbose. However, the phrase 'learned user preferences' is somewhat vague and could be more precisely explained to earn full marks.

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

Completeness2/5

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

Given the complexity of image analysis with multiple parameter options and no output schema, the description is insufficiently complete. It doesn't explain what different analysis types produce, how 'learned user preferences' affect results, or what format the analysis returns. For a tool with 3 parameters (including an enum with 5 options) and no annotations, more contextual information is needed.

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

Parameters3/5

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

The description adds no parameter-specific information beyond what's already in the schema. Since schema description coverage is 100%, the baseline score is 3. The description doesn't explain the meaning of 'learned user preferences' in relation to parameters, nor does it provide additional context about parameter interactions or usage examples.

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

Purpose4/5

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

The description clearly states the tool's purpose as 'Analyze images using Gemini's multimodal vision capabilities' with the specific verb 'analyze' and resource 'images'. It distinguishes from siblings like 'gemini-edit-image' (editing) and 'gemini-analyze-video' (video analysis) by focusing on image analysis. However, it doesn't explicitly differentiate from 'gemini-advanced-image' which might have overlapping functionality.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'learned user preferences' but doesn't explain how this affects tool selection. There's no mention of when to choose this over 'gemini-advanced-image', 'gemini-analyze-video', or other sibling tools, nor any prerequisites or exclusions for usage.

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

gemini-analyze-videoB

Analyze video files using Gemini's multimodal video understanding capabilities (with learned user preferences)

ParametersJSON Schema

Name	Required	Description
`file_path`	No	Path to the video file to analyze (supports MP4, MOV, AVI, WEBM, MKV, FLV) - for files under 100MB
`file_uri`	No	URI of pre-uploaded file (use gemini-upload-file first for files over 100MB)
`mime_type`	No	MIME type when using file_uri (e.g., "video/mp4")
`analysis_type`	No	Type of analysis to perform: "summary", "transcript", "objects", "detailed", or "custom"
`context`	No	Optional context for intelligent enhancement (e.g., "security", "educational", "entertainment")

TDQS

B3.1/5.0

Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'learned user preferences' which hints at personalization, but doesn't explain what this means operationally. It doesn't disclose rate limits, authentication requirements, whether analysis is synchronous or asynchronous, what happens with large files, or what the output format will be. The description is too vague about behavioral traits.

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, reasonably concise sentence that states the core functionality. It's front-loaded with the main purpose. However, the parenthetical about 'learned user preferences' feels tacked on and could be integrated more smoothly, and the description could benefit from slightly more structure for clarity.

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

Completeness2/5

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

For a video analysis tool with 5 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the different analysis_types actually do (summary vs detailed vs objects), what format the results will be in, whether there are file size or duration limits beyond the 100MB mentioned in the schema, or how 'learned user preferences' actually affect the analysis. The description leaves too many operational questions unanswered.

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?

With 100% schema description coverage, the baseline is 3. The description doesn't add any meaningful parameter semantics beyond what's already in the schema. It mentions 'learned user preferences' and 'intelligent enhancement' in relation to the context parameter, but this is vague and doesn't provide concrete guidance on how parameters interact or what 'custom' analysis_type entails.

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

Purpose4/5

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

The description clearly states the tool's purpose: 'Analyze video files using Gemini's multimodal video understanding capabilities'. It specifies the resource (video files) and the action (analyze with multimodal understanding). However, it doesn't explicitly distinguish this tool from sibling tools like gemini-analyze-image or gemini-transcribe-audio beyond mentioning 'video' specifically.

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 provides some implicit usage guidance through the mention of 'learned user preferences' and the context parameter for 'intelligent enhancement', but it doesn't explicitly state when to use this tool versus alternatives like gemini-transcribe-audio for audio-only analysis or gemini-analyze-image for static images. The input schema descriptions provide some practical guidance (e.g., use gemini-upload-file first for large files), but this isn't in the main description.

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

gemini-chatC

Chat with Gemini AI for conversations, questions, and general assistance (with learned user preferences)

ParametersJSON Schema

Name	Required	Description	Default
`message`	Yes	Your message or question to chat with Gemini AI
`context`	No	Optional additional context for the conversation (e.g., "aurora", "debugging", "code")

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'learned user preferences,' which hints at personalization, but doesn't clarify what this entails (e.g., how preferences are applied, if they affect responses). It lacks details on rate limits, authentication needs, response format, or conversational state management, which are critical for a chat tool with no output schema.

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, efficient sentence that front-loads the core purpose. However, the parenthetical '(with learned user preferences)' could be integrated more smoothly, and it lacks structural elements like bullet points or examples that might enhance clarity without adding unnecessary length.

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

Completeness2/5

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

Given the complexity of a chat tool with no annotations and no output schema, the description is incomplete. It doesn't address key aspects like response format, error handling, or how 'learned user preferences' function. For a tool that likely involves nuanced interactions, more context is needed to guide the agent effectively.

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 both parameters thoroughly. The description adds no additional meaning beyond what the schema provides—it doesn't explain how 'context' interacts with 'message' or provide examples of effective usage. The baseline score of 3 reflects adequate but minimal value added over the schema.

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

Purpose4/5

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

The description clearly states the tool's purpose: 'Chat with Gemini AI for conversations, questions, and general assistance.' It specifies the verb ('Chat'), resource ('Gemini AI'), and scope ('conversations, questions, and general assistance'). However, it doesn't explicitly differentiate from siblings like gemini-nano-banana-pro or gemini-advanced-image, which might also involve conversational interactions.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'learned user preferences' but doesn't explain how this affects usage or when to choose other tools like gemini-analyze-image or gemini-code-execute. There are no explicit when/when-not statements or named alternatives, leaving the agent to infer usage from context alone.

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

gemini-code-executeC

Execute Python code using Gemini's built-in code execution sandbox (with learned user preferences)

ParametersJSON Schema

Name	Required	Description	Default
`code`	Yes	Python code to execute in the sandbox
`context`	No	Optional context for intelligent enhancement (e.g., "data-science", "automation", "testing")

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'code execution sandbox' and 'learned user preferences', hinting at a safe, isolated environment and personalized behavior, but fails to detail critical aspects like execution timeouts, memory limits, supported Python versions, error handling, or security restrictions. For a code execution tool with zero annotation coverage, this leaves significant gaps in understanding its operational 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, efficient sentence that front-loads the core functionality ('Execute Python code') and adds relevant context ('using Gemini's built-in code execution sandbox' and 'with learned user preferences'). There's no wasted verbiage, and it effectively communicates the tool's essence without unnecessary elaboration.

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

Completeness2/5

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

Given the complexity of a code execution tool, the absence of annotations, and no output schema, the description is insufficiently complete. It doesn't explain what happens during execution (e.g., sandbox isolation, result formats, error outputs) or how 'learned user preferences' manifest. For a tool that could have significant behavioral nuances and safety implications, more detail is needed to guide the agent effectively.

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

Parameters3/5

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

The schema description coverage is 100%, with clear descriptions for both parameters ('code' and 'context') in the input schema. The description adds minimal value beyond this, only implying that 'context' might influence enhancements based on user preferences. Since the schema already documents parameters thoroughly, the baseline score of 3 is appropriate, as the description doesn't significantly enhance parameter understanding.

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

Purpose4/5

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

The description clearly states the action ('Execute Python code') and the resource ('Gemini's built-in code execution sandbox'), which is specific and unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'gemini-chat' or 'gemini-nano-banana-pro', which might also involve code execution or processing. The mention of 'learned user preferences' adds nuance but doesn't fully establish uniqueness among siblings.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, limitations, or scenarios where other tools (e.g., 'gemini-chat' for conversational code help or 'gemini-analyze-image' for image-related tasks) might be more appropriate. The lack of explicit usage context leaves the agent without direction on tool selection.

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

gemini-edit-imageC

Edit existing images using Gemini's AI image editing capabilities (with learned user preferences)

ParametersJSON Schema

Name	Required	Description
`image_path`	Yes	Path to the image file to edit (JPEG, PNG, WebP, GIF, BMP)
`edit_instruction`	Yes	Detailed instruction for how to edit the image
`context`	No	Optional context for intelligent enhancement (e.g., "subtle", "dramatic", "professional")

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations provided, the description carries full burden but offers minimal behavioral disclosure. It mentions 'AI image editing capabilities' and 'learned user preferences', hinting at intelligent processing and personalization, but lacks details on permissions, rate limits, output format, or mutation effects (e.g., whether edits are destructive or reversible). This is inadequate for a tool with implied mutation.

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, efficient sentence that front-loads the core purpose. It avoids redundancy and wastes no words, though it could be slightly more structured (e.g., separating functionality from context). It earns its place but isn't perfectly optimized.

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

Completeness2/5

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

Given no annotations and no output schema, the description is incomplete for an AI editing tool. It lacks critical context: output format (e.g., returns edited image or path), error handling, mutation behavior, and how 'learned user preferences' apply. This leaves significant gaps for agent understanding.

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 fully documents parameters. The description adds no additional meaning beyond what's in the schema (e.g., no examples or deeper context for 'edit_instruction' or 'context'). Baseline 3 is appropriate as the schema handles parameter semantics effectively.

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

Purpose4/5

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

The description clearly states the verb ('Edit') and resource ('existing images'), specifying it uses 'Gemini's AI image editing capabilities'. It distinguishes from siblings like 'generate_image' (creation) and 'gemini-analyze-image' (analysis), though not explicitly. However, it doesn't fully differentiate from 'gemini-advanced-image' (purpose unclear), making it a 4 rather than a 5.

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

Usage Guidelines2/5

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

The description provides no explicit guidance on when to use this tool versus alternatives. It mentions 'learned user preferences' but doesn't clarify if this is for personalization or how it affects tool selection. No exclusions, prerequisites, or named alternatives are provided, leaving usage context implied at best.

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

gemini-nano-banana-proB

Generate professional images with Nano Banana Pro (Gemini 3 Pro Image): 4K resolution, up to 14 reference images, advanced text rendering, character consistency, and studio-grade controls

ParametersJSON Schema

Name	Required	Description
`prompt`	Yes	Text description of the desired image or editing instruction
`mode`	No	Generation mode: fusion (blend up to 14 images), consistency (maintain character/style for up to 5 characters), targeted_edit (precise localized edits), template (follow layout), standard (basic generation)
`resolution`	No	Output resolution: 1k (1024px), 2k (2048px), or 4k (4096px). Higher resolutions cost more.
`aspect_ratio`	No	Aspect ratio for the generated image
`reference_images`	No	Optional array of file paths to reference images (up to 14 for Nano Banana Pro)
`context`	No	Optional context for intelligent enhancement (e.g., "professional", "artistic", "infographic")

TDQS

B3.2/5.0

Behavior3/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions key features like resolution options, reference image limits, and 'studio-grade controls', which adds useful context beyond basic generation. However, it doesn't cover important behavioral aspects like rate limits, authentication needs, cost implications (implied by 'Higher resolutions cost more' in schema but not in description), or what happens with invalid inputs.

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 efficiently structured as a single sentence listing key features. It's appropriately sized for a complex tool with 6 parameters, though it could be more front-loaded by starting with the core purpose more clearly. Every phrase adds value by highlighting distinctive capabilities of this specific implementation.

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 complex image generation tool with 6 parameters and no annotations or output schema, the description provides adequate but incomplete context. It covers the tool's high-level capabilities and some key features, but doesn't address important aspects like output format, error conditions, or how it differs from sibling tools. The absence of an output schema means the description should ideally mention what gets returned, but it doesn't.

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 6 parameters thoroughly. The description adds minimal parameter semantics beyond what's in the schema - it mentions '4K resolution' and 'up to 14 reference images' which align with schema fields, but doesn't provide additional context about parameter interactions or usage patterns. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

Purpose4/5

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

The description clearly states the tool's purpose: 'Generate professional images with Nano Banana Pro (Gemini 3 Pro Image)'. It specifies the verb ('Generate'), resource ('professional images'), and technology ('Nano Banana Pro/Gemini 3 Pro Image'). However, it doesn't explicitly differentiate from sibling tools like 'gemini-advanced-image' or 'generate_image', which likely serve similar image generation purposes.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives. It lists features like '4K resolution' and 'up to 14 reference images', but doesn't mention sibling tools such as 'gemini-advanced-image' or 'gemini-edit-image' for comparison. There's no explicit when/when-not usage advice or prerequisites stated.

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

gemini-transcribe-audioB

Transcribe audio files to text using Gemini's multimodal capabilities (with learned user preferences)

ParametersJSON Schema

Name	Required	Description
`file_path`	Yes	Path to the audio file to transcribe (supports MP3, WAV, FLAC, AAC, OGG, WEBM)
`language`	No	Optional language hint for better transcription accuracy (e.g., "en", "es", "fr")
`context`	No	Optional context for intelligent enhancement (e.g., "medical", "legal", "technical")
`preserve_spelled_acronyms`	No	Keep spelled-out letters (U-R-L) instead of converting to acronyms (URL)

TDQS

B3.1/5.0

Behavior2/5

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

With no annotations provided, the description carries full burden but offers minimal behavioral disclosure. It mentions 'learned user preferences' but doesn't explain what this entails (e.g., customization, history). It lacks details on rate limits, authentication needs, output format, error handling, or processing time. For a tool with 4 parameters and no annotations, this is insufficient.

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, efficient sentence that front-loads the core purpose. However, it could be more structured by separating functional description from behavioral context. It avoids redundancy but misses opportunities to add crucial usage details.

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 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain the return value (e.g., transcription text format), error cases, or how 'learned user preferences' affect behavior. For a tool with moderate complexity and no structured safety hints, more context is needed.

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 fully documents all parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't clarify 'context' usage or 'learned preferences' interaction with parameters). Baseline 3 is appropriate when schema does the heavy lifting.

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 specific action ('Transcribe audio files to text'), identifies the resource ('audio files'), and mentions the unique capability ('using Gemini's multimodal capabilities with learned user preferences'). It distinguishes itself from sibling tools by focusing on audio transcription rather than image/video analysis, code execution, or file uploads.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., file accessibility), exclusions (e.g., unsupported formats beyond those in schema), or comparisons with other transcription tools. The context is implied but not explicit.

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

gemini-upload-fileA

Upload files to Gemini File API (up to 2GB) for use in subsequent operations. Files persist for 48 hours.

ParametersJSON Schema

Name	Required	Description
`file_path`	No	Path to the file to upload
`display_name`	No	Optional display name for the file (defaults to filename)
`operation`	Yes	Operation to perform: "upload", "list", "get", or "delete"
`file_name`	No	File name (for get/delete operations)
`page_size`	No	Number of files to list (for list operation, max 100)

TDQS

A3.5/5.0

Behavior3/5

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: file size limit (2GB) and persistence (48 hours), which are valuable beyond the schema. However, it lacks details on error handling, rate limits, authentication requirements, or what 'subsequent operations' entail, leaving gaps for a mutation tool.

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

Conciseness5/5

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

The description is two concise sentences with zero waste: the first states the core function and constraints, the second adds persistence info. It's front-loaded with the main purpose, and every sentence adds essential context without redundancy.

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

Completeness3/5

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

Given no annotations and no output schema, the description is moderately complete for a 5-parameter mutation tool. It covers purpose and key constraints but lacks details on permissions, error cases, return values, or how parameters interact. For a tool that handles file operations with multiple 'operation' types, more context on behavioral outcomes would improve completeness.

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 fully documents all 5 parameters. The description adds no specific parameter semantics beyond implying that uploaded files are used in later steps. It doesn't clarify parameter interactions (e.g., how 'operation' affects other params) or provide examples, so it meets the baseline for high schema coverage.

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

Purpose4/5

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

The description clearly states the tool uploads files to the Gemini File API with a size limit (up to 2GB) and mentions persistence duration (48 hours). It distinguishes from siblings by focusing on file upload rather than analysis, chat, or image generation. However, it doesn't explicitly differentiate from potential file management siblings beyond the upload focus.

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 preparing files for subsequent operations, providing some context. However, it doesn't specify when to use this tool versus alternatives (e.g., direct API calls or other upload methods), nor does it mention prerequisites like authentication or file format restrictions. The guidance is limited to the tool's role in a workflow.

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

generate_imageC

Generate an image using Google's Gemini 2.0 Flash Experimental model (with learned user preferences)

ParametersJSON Schema

Name	Required	Description	Default
`prompt`	Yes	Text description of the desired image
`context`	No	Optional context for intelligent enhancement (e.g., "artistic", "photorealistic", "technical")

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the model and 'learned user preferences', but fails to detail critical aspects such as rate limits, authentication requirements, output format (e.g., image type, size), or potential costs/limitations. This leaves significant gaps for an AI agent to understand the tool's behavior.

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

Conciseness5/5

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary details. It is front-loaded with the core action and model specification, making it highly concise and well-structured.

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

Completeness2/5

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

Given the complexity of image generation (involving models, preferences, and output handling), the description is insufficient. With no annotations and no output schema, it lacks details on behavioral traits, return values, or error handling. This makes it incomplete for effective tool invocation by an AI agent.

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

Parameters3/5

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

Schema description coverage is 100%, so the input schema already documents both parameters ('prompt' and 'context') adequately. The description adds no additional parameter semantics beyond what the schema provides, such as examples or constraints, resulting in the baseline score of 3.

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

Purpose4/5

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

The description clearly states the action ('generate an image') and specifies the model used ('Google's Gemini 2.0 Flash Experimental model'), which distinguishes it from siblings like 'gemini-edit-image' or 'gemini-analyze-image'. However, it doesn't explicitly contrast with all siblings (e.g., 'gemini-advanced-image'), keeping it from a perfect score.

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

Usage Guidelines2/5

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

No explicit guidance on when to use this tool versus alternatives is provided. The description mentions 'learned user preferences' but doesn't clarify how this affects tool selection or when to choose it over other image-related tools like 'gemini-advanced-image' or 'gemini-edit-image'.

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

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

2 tool updatesv1.0.0Jan 3, 2026
- Addedgemini-advanced-image
- Addedgemini-nano-banana-pro
8 tool updatesAug 15, 2025
- First observedgemini-analyze-image
- First observedgemini-analyze-video
- First observedgemini-chat
- First observedgemini-code-execute
- First observedgemini-edit-image
- First observedgemini-transcribe-audio
- First observedgemini-upload-file
- First observedgenerate_image

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.3/5.0

Disambiguation3/5

Most tools have distinct purposes (e.g., analyze vs. generate vs. transcribe), but there is notable overlap between gemini-advanced-image, gemini-nano-banana-pro, and generate_image—all focused on image generation with varying model specifications. This could cause confusion for an agent trying to select the right image generation tool.

Naming Consistency4/5

Nine of the ten tools follow a consistent gemini-verb-noun pattern (e.g., gemini-analyze-image), which is clear and predictable. However, generate_image deviates from this pattern by omitting the gemini prefix, creating a minor inconsistency in the naming scheme.

Tool Count5/5

With 10 tools, the count is well-scoped for a Gemini AI server, covering key multimodal capabilities like image analysis, video analysis, chat, code execution, and file handling. Each tool appears to serve a specific function without unnecessary duplication, making the set appropriately sized.

Completeness4/5

The toolset provides broad coverage for interacting with Gemini's multimodal features, including image generation/editing, audio/video analysis, chat, and file uploads. A minor gap is the lack of a dedicated tool for text-based document analysis or summarization, but core workflows are well-supported.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

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

Related MCP Connectors

mcp-qwen-imageOAuth
io.github.AceDataCloud
MCP server for Qwen Image 3 AI image generation
AI & Machine Learning Image & Video Processing
1
mcp-veoOAuth
io.github.AceDataCloud
MCP server for Google Veo AI video generation
Multimedia Processing Image & Video Processing Entertainment & Media
23
Artificial Wit AIOAuth
com.artificialwit
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
ERP Systems CRM Knowledge & Memory
2
mcp-flux-proOAuth
io.github.AceDataCloud
MCP server for Flux AI image generation
Image & Video Processing Multimedia Processing
23

Related MCP Servers

Together AI Image Server
Image & Video Processing App Automation
zym9863
A
license
B
quality
D
maintenance
A MCP server that enables Claude and other MCP-compatible assistants to generate images from text prompts using Together AI's image generation models.
Updated 6 months ago (2026-03-19 13:19 UTC)
1
4
MIT
MCP Server Gemini
Agent Orchestration RAG Systems
gurveeer
A
license
B
quality
D
maintenance
A Model Context Protocol server that enables Claude Desktop and other MCP-compatible clients to leverage Google's Gemini AI models with features like thinking models, Google Search grounding, JSON mode, and vision support.
Updated a year ago (2025-07-31 05:30 UTC)
6
81
14
MIT
NanoBanana MCP
Image & Video Processing Multimedia Processing
pistachiomatt
A
license
A
quality
D
maintenance
An MCP server that brings Google Gemini's image generation and editing capabilities to Claude Desktop, Claude Code, and Cursor. It supports 2K image creation, natural language image transformations, and session consistency to maintain styles across generations.
Updated 5 months ago (2026-04-17 04:16 UTC)
7
1,171
MIT
NanoBanana MCP
Image & Video Processing AI & Machine Learning
YCSE
A
license
A
quality
C
maintenance
MCP server that brings Gemini's image generation and editing capabilities to Claude Desktop, Claude Code, and Cursor. Supports Nano Banana 2 (Flash) and Nano Banana Pro models.
Updated 6 months ago (2026-03-03 18:11 UTC)
7
1,171
32
MIT

Appeared in Searches

MCP servers for generating images, videos and audio with GLM models and Claude Code CLI

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Garblesnarff/gemini-mcp-server'

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

Gemini MCP Server with Smart Tool Intelligence

🚀 Features Overview

🤖 7 AI-Powered Tools

🧠 Smart Tool Intelligence System (First in MCP Ecosystem)

📦 Quick Start

Installation

Configuration

Running the Server

Integration with Claude Desktop

🛠️ Tool Reference

1. Image Generation (generate_image)

2. Image Editing (gemini-edit-image)

3. Chat (gemini-chat)

4. Audio Transcription (gemini-transcribe-audio)

5. Code Execution (gemini-code-execute)

6. Video Analysis (gemini-analyze-video)

7. Image Analysis (gemini-analyze-image)

🧠 Smart Tool Intelligence System

How It Works

Context Types

Storage Location

Implementing Smart Tool Intelligence in Your MCP Server

1. Core Architecture

2. Integration Pattern

3. Key Implementation Files

🧪 Testing

Run Test Suite

Manual Testing Examples

📊 Performance & Limits

File Size Limits

API Rate Limits

🏗️ Architecture Deep Dive

Modular Design

Intelligence System Flow

🔧 Customization

Adding New Contexts

Adding New Tools

🐛 Troubleshooting

Common Issues

Debug Mode

Logs Location

🤝 Contributing

Development Setup

Areas for Contribution

📈 Roadmap

🌟 Why This Matters

📄 License

🙏 Acknowledgments

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Appeared in Searches

Latest Blog Posts

MCP directory API

1. Image Generation (`generate_image`)

2. Image Editing (`gemini-edit-image`)

3. Chat (`gemini-chat`)

4. Audio Transcription (`gemini-transcribe-audio`)

5. Code Execution (`gemini-code-execute`)

6. Video Analysis (`gemini-analyze-video`)

7. Image Analysis (`gemini-analyze-image`)