Explain Image MCP Server
Allows AI agents to analyze images using Google's Gemini vision models, providing tools to describe images, extract text, or return structured data based on prompts.
Click on "Install 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., "@Explain Image MCP ServerDescribe what's in this image: /screenshots/bug.png"
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.
Explain Image MCP Server
A zero-dependency MCP (Model Context Protocol) server that lets any AI agent — including text-only models — "see" images.
The agent passes an image (local path, URL, or data URL) plus a prompt to the describe_image tool. The server forwards both to a Gemini vision model through the OpenAI-compatible REST endpoint and returns the model's text interpretation. Because the agent supplies the prompt, it controls exactly what the model returns: a description, OCR of visible text, an object list, structured JSON, and so on.
No external libraries are used — the MCP JSON-RPC protocol is implemented by hand over stdio, and the Gemini request is a plain fetch().
AI agent ── describe_image(image, prompt) ──► MCP server (stdio, JSON-RPC 2.0)
│
▼
POST /chat/completions (OpenAI-compatible)
│
▼
Gemini vision modelRequirements
Node.js >= 18.17 (global
fetchrequired)
Related MCP server: mcp-see
Configuration
Env var | Default | Description |
| (required) | Google AI Studio API key |
|
| Default model id; override per call with the |
|
| OpenAI-compatible base URL (swap to add another provider later) |
Install with an MCP client
san:
san mcp add -e GEMINI_API_KEY=your-key explain-image -- node /path/to/explain-image-mcp-server/src/index.jsClaude Desktop (claude_desktop_config.json):
{
"mcpServers": {
"explain-image": {
"command": "node",
"args": ["/path/to/explain-image-mcp-server/src/index.js"],
"env": { "GEMINI_API_KEY": "your-key" }
}
}
}Tools
describe_image
Analyze one or more images with a Gemini vision model. The agent supplies the prompt.
Argument | Type | Required | Description |
| string | string[] | yes | Local file path, |
| string | no | What the model should return. Defaults to a detailed description |
| string | no | Gemini model id, overrides |
| integer | no | Maximum response length |
Example agent call:
describe_image(
image: "/screenshots/bug.png",
prompt: "Describe this UI bug precisely: what is shown, and what looks wrong?"
)list_models
List the model ids available on the configured OpenAI-compatible endpoint.
Default model & cost
The default is gemini-2.5-flash — a cost-efficient GA Flash model with image
input (Google pricing, July 2026): $0.30 / 1M input tokens, $2.50 / 1M output
tokens (vs $1.50 / $7.50 for gemini-3.6-flash). For 2.5 Flash/Flash-Lite
models the server sends reasoning_effort: "none", disabling thinking so no
output tokens are spent on reasoning. Set GEMINI_MODEL (or pass model per
call) to use a different model, e.g. gemini-3.6-flash for higher quality at a
higher price.
Development
npm test # end-to-end smoke test (protocol handshake + request formatting, no real key needed)The smoke test runs the full MCP handshake against a fake OpenAI-compatible upstream and validates the request shape (auth header, message body, base64 data URL) plus error paths.
Security note
The API key is stored in plaintext wherever the MCP client saves env vars. Keep it out of version control — .san/ is git-ignored in this repo for that reason.
Available Tools
2 toolsdescribe_imageA
Look at an image and return a text interpretation from the Gemini vision model. The calling agent supplies the prompt, so it controls exactly what the model should return (a description, OCR of visible text, a list of objects, structured JSON, etc.). Pass image as a local file path, an http(s) URL, or a data: URL (or an array of these for multiple images). This is how a text-only model can 'see' an image.
| Name | Required | Description | Default |
|---|---|---|---|
| image | Yes | Image(s) to analyze: local file path, http(s) URL, or data: URL. May also be an array of these. | |
| model | No | Gemini model id to use (overrides GEMINI_MODEL). | |
| prompt | No | What the vision model should return about the image(s). Defaults to a detailed description. | |
| max_tokens | No | Maximum number of tokens in the response. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully bears the burden. It discloses that the tool delegates to Gemini vision, that the prompt controls output, and that image can be a local path, URL, or data URI. It does not cover edge cases like errors or rate limits, but the core behavior is clearly conveyed.
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?
Three sentences, each earning its place: purpose, prompt control, and input formats. It is front-loaded with the primary action and contains no redundancy or fluff.
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 a solid overview for a 4-parameter tool without an output schema. It explains the flexible output behavior via the prompt and the multiple image input options. It could mention the exact return format (e.g., raw text from Gemini) but the prompt-driven nature makes this less critical.
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 coverage is 100%, so baseline is 3. The description repeats the image parameter format already in the schema ('local file path, an http(s) URL, or a data: URL') and adds a bit of nuance about the prompt controlling output, but does not significantly enhance parameter understanding 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 clearly states the tool's function: 'Look at an image and return a text interpretation from the Gemini vision model.' It uses a specific verb (look at) and resource (image), and explains the calling agent controls the prompt, distinguishing it from the sibling list_models.
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 when to use: 'This is how a text-only model can see an image.' It also lists various use cases (description, OCR, list of objects, structured JSON) which gives context for usage. However, it does not provide explicit exclusions or alternatives beyond the implicit sibling distinction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_modelsA
List the Gemini model ids available on the configured OpenAI-compatible endpoint.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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. The word 'List' implies a read-only operation, but it does not explicitly confirm non-mutating behavior or mention configuration requirements or error conditions, which is a minor shortfall.
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 that conveys the purpose and scope without any filler. Every word earns its place, and no redundant information is present.
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 zero-parameter tool, the description adequately covers the expected output (model IDs) and the endpoint context. However, it does not specify the exact return format or behavior in case of configuration or connectivity issues, leaving a slight gap.
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?
The tool has zero parameters, so the input schema is empty. The baseline of 4 applies because there is nothing to add beyond the schema; the description correctly avoids mentioning parameters that don't exist.
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 uses a specific verb ('List') and clearly identifies the resource ('Gemini model ids on the configured OpenAI-compatible endpoint'). This unambiguously distinguishes it from the sibling describe_image, which deals with images.
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?
While there is no explicit when-to-use or alternative guidance, the context is clear: this tool should be used to enumerate available model IDs. Given the only sibling is describe_image, there is no ambiguity about when to select this tool.
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 updates
v0.1.0- First observed
describe_image - First observed
list_models
TDQS
The two tools have completely distinct purposes: describe_image processes images, while list_models enumerates available models. There is no overlap or ambiguity in their roles.
Both tools follow the identical verb_noun naming pattern (describe_image and list_models), creating a clear and predictable convention. This consistency makes the tool set easy to navigate.
With only 2 tools, the server is lean but appropriately scoped for its narrow purpose of explaining images. The core describe_image tool is supported by list_models, giving just enough functionality without bloat.
For the stated purpose of image explanation, the server fully covers the domain. describe_image is flexible via custom prompts, supporting descriptions, OCR, object listing, and more, with no obvious gaps for a single-purpose MCP server.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Analyze images and videos with Gemini to get fast, reliable visual insights. Handle content from U…
Generate images, GIFs, and PDFs from HTML, URLs, or templates — from your AI agent.
OCR, transcription, file extraction, and image generation for AI agents via MCP.
Image processing for AI agents: resize, convert, compress, crop, and web-ready AI-generated images.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables image analysis and understanding using Vision Language Models through OpenAI-compatible APIs. Supports analyzing images from URLs or local files with custom prompts.12MIT
- FlicenseAqualityNot gradedmaintenanceEnables AI agents to analyze images through vision AI providers (Gemini, OpenAI, Claude), performing tasks like image description, object detection with bounding boxes, region-specific analysis, and precise color extraction without consuming context window with raw pixels.4-
- AlicenseAqualityCmaintenanceEnables image analysis using any OpenAI-compatible vision API, supporting URLs, local files, or base64 input with custom prompts.1MIT
- AlicenseAqualityDmaintenanceEnables AI agents to analyze images, extract text, compare images, and analyze video through any OpenAI-compatible vision model.411920MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/hsain9357/explain-image-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server