llm-vision-mcp
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., "@llm-vision-mcpdiagnose this error screenshot"
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.
llm-vision-mcp
A TypeScript MCP server that gives text-only LLMs image understanding through StepFun vision models.
This is useful when the primary model, such as GLM5.2 or DeepSeek V4, does not support image input. The model can call these MCP tools, receive text or structured visual analysis, then continue reasoning with the result.
Tools
analyze_image: general image understandingextract_text_from_image: OCR for screenshots, logs, documents, code, and UI textdiagnose_error_screenshot: error screenshot and stack trace diagnosisunderstand_technical_diagram: architecture, flowchart, UML, ER, sequence, and network diagramsanalyze_data_visualization: charts, tables, dashboards, and metrics screenshotsui_to_artifact: UI screenshot to implementation notes or design specsui_diff_check: expected vs actual UI screenshot comparison
Related MCP server: llm-vision-mcp
Setup
npm install
cp .env.example .envSet STEPFUN_API_KEY in the MCP client environment. Injecting env vars through the MCP client config is usually the most explicit and reliable setup.
Required:
STEPFUN_API_KEY=your_stepfun_api_keyOptional:
# standard | step_plan
STEPFUN_API_MODE=standard
STEPFUN_BASE_URL=https://api.stepfun.com/v1
STEPFUN_VISION_MODEL=step-1o-turbo-vision
STEPFUN_DEFAULT_DETAIL=high
STEPFUN_TIMEOUT_MS=120000Step Plan
Step Plan uses the same API key style but a different Base URL:
STEPFUN_API_MODE=step_planWhen STEPFUN_API_MODE=step_plan is set, defaults change to:
STEPFUN_BASE_URL=https://api.stepfun.com/step_plan/v1
STEPFUN_VISION_MODEL=step-3.7-flashYou can still override either value explicitly:
STEPFUN_API_MODE=step_plan
STEPFUN_BASE_URL=https://api.stepfun.com/step_plan/v1
STEPFUN_VISION_MODEL=step-3.7-flashFor backward compatibility, STEPFUN_USE_STEP_PLAN=true also enables Step Plan mode when STEPFUN_API_MODE is not set.
Run
npm run build
npm run startRun With npx
After this package is published to npm:
npx -y llm-vision-mcpThe published package runs on Node.js and does not require Bun on the user's machine.
MCP Client Config
Example:
{
"mcpServers": {
"llm-vision-mcp": {
"command": "node",
"args": ["/Users/shaoyun/workdir/llm-vision-mcp/dist/index.js"],
"env": {
"STEPFUN_API_KEY": "your_stepfun_api_key",
"STEPFUN_API_MODE": "step_plan",
"STEPFUN_DEFAULT_DETAIL": "high"
}
}
}
}npm package example after publishing:
{
"mcpServers": {
"llm-vision-mcp": {
"command": "npx",
"args": ["-y", "llm-vision-mcp"],
"env": {
"STEPFUN_API_KEY": "your_stepfun_api_key",
"STEPFUN_API_MODE": "step_plan",
"STEPFUN_DEFAULT_DETAIL": "high"
}
}
}
}Image Inputs
Every single-image tool accepts:
{
"image": "/absolute/path/to/screenshot.png",
"question": "What does this error mean?",
"detail": "high"
}The image field supports:
local file path
file://pathhttp://orhttps://URLdata:image/...;base64,...Data URL
ui_diff_check accepts two images:
{
"expected_image": "/absolute/path/to/expected.png",
"actual_image": "/absolute/path/to/actual.png",
"question": "Focus on layout and missing buttons.",
"detail": "high"
}Notes
Use
detail: "high"for OCR, UI, diagrams, charts, and screenshots.Use
detail: "low"for faster, cheaper coarse image understanding.StepFun supports JPG/JPEG, PNG, WebP, and static GIF image inputs.
Available Tools
7 toolsanalyze_data_visualizationAnalyze Data VisualizationB
Interpret charts, graphs, tables, dashboards, metrics screenshots, and data visualizations.
| Name | Required | Description | Default |
|---|---|---|---|
| image | Yes | Image source. Supports local file path, http(s) URL, or data:image/...;base64,... Data URL. | |
| model | No | Optional StepFun vision model override. | |
| detail | No | StepFun vision detail level. Use high for OCR, screenshots, UI, diagrams, and charts. | |
| question | No | Optional user question or task for this image. If omitted, the tool uses its scenario-specific default task. | |
| max_tokens | No | Optional maximum output tokens. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, yet it only states the interpretative purpose. It does not disclose what the output looks like, what happens when 'question' is omitted, or how detail level affects results, leaving agents without key operational knowledge.
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 efficiently states the core purpose. It earns its place but is so brief that it leaves out important usage and transparency details, though it avoids any verbosity or redundancy.
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?
With no output schema and no annotations, the description should explain return values and default behavior, but it doesn't. It also fails to mention how the optional 'question' or 'detail' parameters influence interpretation, making it incomplete for a tool with five parameters.
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%, with each parameter having a description, so the baseline is 3. The tool description adds no additional parameter semantics beyond what the schema already provides; it does not compensate for or enhance schema info.
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 the specific verb 'interpret' and clearly enumerates resource types (charts, graphs, tables, dashboards, metrics screenshots), distinguishing it from sibling tools like extract_text_from_image or diagnose_error_screenshot. The scope is well-defined and oriented to data visualizations.
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 data visualization images but provides no explicit when-to-use vs alternatives, prerequisites, or exclusions. The context is clear enough from the resource list, but there is no direct guidance on choosing this tool over analyze_image or understand_technical_diagram.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
analyze_imageAnalyze ImageB
General-purpose image understanding for photos, screenshots, documents, objects, scenes, and visual questions.
| Name | Required | Description | Default |
|---|---|---|---|
| image | Yes | Image source. Supports local file path, http(s) URL, or data:image/...;base64,... Data URL. | |
| model | No | Optional StepFun vision model override. | |
| detail | No | StepFun vision detail level. Use high for OCR, screenshots, UI, diagrams, and charts. | |
| question | No | Optional user question or task for this image. If omitted, the tool uses its scenario-specific default task. | |
| max_tokens | No | Optional maximum output tokens. |
TDQS
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 lists input categories and says 'understanding' but fails to mention what the tool returns, whether it answers questions, or any limitations. This leaves the agent without critical context about the tool's behavior or outputs.
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 sentence that front-loads the 'General-purpose' qualifier and lists supported image categories without redundancy or fluff. Every word contributes to defining the scope, 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.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This tool has five parameters and no output schema, yet the description only provides a high-level scope and omits expected output format, any behavioral caveats, or edge cases. For a general-purpose tool of this complexity, the description is too thin to be fully complete without relying on external context.
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 input schema covers all five parameters with thorough descriptions (100% coverage), and the tool description adds no additional parameter context or usage nuances. Since the schema already does the heavy lifting, 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 uses the specific verb phrase 'image understanding' and enumerates concrete image categories (photos, screenshots, documents, objects, scenes, visual questions), clearly establishing what the tool does. The explicit 'General-purpose' label distinguishes it from the specialized sibling tools, making its scope 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 'General-purpose' label implies usage for broad image understanding tasks, but the description neither explicitly states when to prefer this tool over siblings nor includes exclusions or alternatives. An agent would have to infer from sibling names, so usage guidance is only implied, not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
diagnose_error_screenshotDiagnose Error ScreenshotB
Analyze error screenshots, stack traces, console output, IDE errors, terminal failures, and crash dialogs.
| Name | Required | Description | Default |
|---|---|---|---|
| image | Yes | Image source. Supports local file path, http(s) URL, or data:image/...;base64,... Data URL. | |
| model | No | Optional StepFun vision model override. | |
| detail | No | StepFun vision detail level. Use high for OCR, screenshots, UI, diagrams, and charts. | |
| question | No | Optional user question or task for this image. If omitted, the tool uses its scenario-specific default task. | |
| max_tokens | No | Optional maximum output tokens. |
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 only says 'Analyze' without explaining what output to expect (e.g., a diagnosis, suggested fixes, or extracted text details). It also does not mention whether the tool performs OCR, reasons about the error, or provides step-by-step solutions. This is a significant gap for a tool with no annotations and 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that front-loads the core action and enumerates all relevant input types. It contains no filler words, repetitions, or extraneous details, earning its place efficiently.
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?
Despite high schema coverage and a clear purpose, the description lacks essential context for an AI agent: it does not specify what the tool returns (no output schema), whether it generates fixes or explanations, or how to handle optional parameters like question and detail. Given the tool's specialized diagnostic function, more behavioral detail is needed for complete invocation guidance.
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 parameter descriptions in the schema already document all five parameters (image, model, detail, question, max_tokens). The tool description adds no extra meaning beyond the schema, but the high coverage means the baseline score 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 uses a specific verb ('Analyze') and resource ('error screenshots, stack traces, console output, IDE errors, terminal failures, and crash dialogs'), clearly distinguishing it from general image tools like analyze_image and extract_text_from_image. It enumerates exactly what input types it handles, leaving no ambiguity about its scope.
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 the tool is intended for error-related imagery but does not explicitly state when to prefer it over siblings (e.g., extract_text_from_image for pure OCR or analyze_image for generic images). No alternative tools are mentioned or excluded, so guidance is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
extract_text_from_imageExtract Text From ImageB
OCR for screenshots, documents, terminal output, logs, code snippets, forms, and UI text.
| Name | Required | Description | Default |
|---|---|---|---|
| image | Yes | Image source. Supports local file path, http(s) URL, or data:image/...;base64,... Data URL. | |
| model | No | Optional StepFun vision model override. | |
| detail | No | StepFun vision detail level. Use high for OCR, screenshots, UI, diagrams, and charts. | |
| question | No | Optional user question or task for this image. If omitted, the tool uses its scenario-specific default task. | |
| max_tokens | No | Optional maximum output tokens. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only states that the tool performs OCR. It does not disclose return format, limitations (e.g., handling of low-quality images), or any side effects. This is a significant gap for a tool with no structured annotation support.
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, compact sentence that is immediately clear and front-loaded with the main purpose. There is zero wasted text, making it highly efficient.
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?
Despite a well-documented schema, the description is too minimal to be fully contextual. It lacks explanation of output behavior, usage alternatives, or edge cases, and there is no output schema to compensate. Given the tool's moderate complexity (5 params, no annotations), more descriptive context is needed.
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 input schema provides 100% parameter coverage with detailed descriptions, so the baseline is 3. The tool description adds no extra meaning beyond the schema; the only slight addition is the context of OCR use cases, but it does not elaborate on any parameters.
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 identifies the tool as OCR for images, specifying a range of relevant content types (screenshots, documents, terminal output, etc.). It uses a specific verb ('OCR') and resource (image), which distinguishes it from general image analysis tools, though it does not explicitly name sibling alternatives.
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 the tool (when text needs to be extracted from images) but provides no explicit guidance on when not to use it or how it compares to alternatives like analyze_image. The parameter description for 'detail' adds some usage guidance ('Use high for OCR'), but this is not 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.
ui_diff_checkUI Diff CheckA
Compare expected and actual UI screenshots for visual regression, missing elements, layout differences, typography, color, spacing, and priority.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | Optional StepFun vision model override. | |
| detail | No | StepFun vision detail level. high is recommended for visual regression checks. | |
| question | No | Optional focus area, acceptance criteria, or bug report context. | |
| max_tokens | No | Optional maximum output tokens. | |
| actual_image | Yes | Actual/current image source. Supports local file path, http(s) URL, or data:image/...;base64,... Data URL. | |
| expected_image | Yes | Expected/reference image source. Supports local file path, http(s) URL, or data:image/...;base64,... Data URL. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the transparency burden. It does disclose the scope of analysis (layout, typography, color, spacing) but stops short of describing output format, return structure, or limitations about how the comparison is performed.
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?
Single sentence, front-loaded with the verb and resource, and every clause adds meaningful detail. There is no filler or duplication of schema information.
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 covers the core purpose but lacks any information about the return value or output structure, which is especially relevant since no output schema is provided. Combined with the absence of annotations, an agent must infer what the tool will produce. Still, the purpose and parameter contract are clear enough for minimum viable use.
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?
All six parameters have schema descriptions covering 100% of parameters, including accepted image source formats and optional model/detail/question/token settings. The tool description adds no parameter-specific detail, but the schema already provides thorough semantics, so 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 uses a specific verb ('Compare') with a clear resource ('expected and actual UI screenshots') and enumerates concrete check dimensions: visual regression, missing elements, layout differences, typography, color, spacing, and priority. This clearly distinguishes it from generic siblings like analyze_image.
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 clearly sets the context: use this tool when comparing expected vs actual UI screenshots for visual regression. It does not explicitly name alternatives or exclusion criteria, but the intended use case is unambiguous from the phrasing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ui_to_artifactUI To ArtifactA
Convert UI screenshots into implementation notes, layout structure, design specs, or recreation prompts.
| Name | Required | Description | Default |
|---|---|---|---|
| image | Yes | Image source. Supports local file path, http(s) URL, or data:image/...;base64,... Data URL. | |
| model | No | Optional StepFun vision model override. | |
| detail | No | StepFun vision detail level. Use high for OCR, screenshots, UI, diagrams, and charts. | |
| question | No | Optional user question or task for this image. If omitted, the tool uses its scenario-specific default task. | |
| max_tokens | No | Optional maximum output tokens. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses the main behavior (conversion) and enumerates output types, which gives a good sense of what will happen and what will be returned. It does not mention any restrictions, model behavior, or whether the input is uploaded/stored, but for a non-mutating conversion tool this is a moderate gap.
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?
Single-sentence description with a precise verb and a list of outputs; no filler or repetition of the tool name. It earns its place.
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 is terse and does not reference its sibling tools or the 'question' parameter's role in selecting output style, and with no output schema the agent may not know the exact return format. However, the schema covers parameters and the output types are named, making it minimally complete for a moderately complex tool.
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?
All five parameters have schema descriptions (100% coverage), so the schema already explains the fields. The description adds context about the desired outputs ('implementation notes, layout structure, design specs, recreation prompts') but does not elaborate on parameter-specific semantics such as how 'question' interacts with the default task or how 'detail' affects conversion.
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 verb 'Convert' and the target input 'UI screenshots', and enumerates four concrete output artifact types (implementation notes, layout structure, design specs, recreation prompts). This distinguishes it from sibling tools like analyze_image or extract_text_from_image by defining UI-to-artifact conversion as its specific niche.
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 conveys clear context: it should be used when you have a UI screenshot and need a derived artifact. It does not explicitly name alternatives or state when not to use it, though the 'UI screenshots' scoping implicitly separates it from general image analysis tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
understand_technical_diagramUnderstand Technical DiagramB
Explain architecture diagrams, flowcharts, UML, sequence diagrams, ER diagrams, network diagrams, and system maps.
| Name | Required | Description | Default |
|---|---|---|---|
| image | Yes | Image source. Supports local file path, http(s) URL, or data:image/...;base64,... Data URL. | |
| model | No | Optional StepFun vision model override. | |
| detail | No | StepFun vision detail level. Use high for OCR, screenshots, UI, diagrams, and charts. | |
| question | No | Optional user question or task for this image. If omitted, the tool uses its scenario-specific default task. | |
| max_tokens | No | Optional maximum output tokens. |
TDQS
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 only states the purpose and does not describe how the tool processes images, whether it supports questions, what the default task does, or what the output looks like. This is a significant gap.
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 sentence that lists supported diagram types without any fluff. It is perfectly sized and immediately front-loads the core purpose.
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 has 5 parameters and no output schema or annotations. The description only covers the general purpose and leaves out behavior, return format, and guidance on parameter usage. It is not complete enough for an agent to invoke it correctly without additional inference.
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 baseline is 3. The description adds no parameter-specific meaning beyond the schema; it does not even mention parameters. Thus it neither enhances nor detracts from the schema's clarity.
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 ('Explain') and names concrete resource types (architecture diagrams, flowcharts, UML, etc.). This clearly distinguishes it from sibling tools like analyze_image or extract_text_from_image, which target generic or OCR-specific use cases.
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 context by listing diagram types, but it does not explicitly state when to prefer this tool over alternatives like analyze_image or analyze_data_visualization. There are no exclusions or comparisons provided.
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.
7 tool updates
v0.1.0- First observed
analyze_data_visualization - First observed
analyze_image - First observed
diagnose_error_screenshot - First observed
extract_text_from_image - First observed
ui_diff_check - First observed
ui_to_artifact - First observed
understand_technical_diagram
TDQS
Scored across 7 tools
Each tool targets a distinct image understanding task: general analysis, OCR, error diagnosis, diagram explanation, data visualization, UI-to-code conversion, and UI diffing. The specialized scopes prevent confusion, even though analyze_image is broad, it serves as a catch-all rather than overlapping with specific tools.
Most tools follow a verb-first naming pattern (analyze_image, extract_text_from_image, diagnose_error_screenshot, understand_technical_diagram, analyze_data_visualization), but two tools (ui_to_artifact, ui_diff_check) are noun-first. Despite this minor deviation, all names are readable and use consistent snake_case.
With 7 tools, the server is well-scoped for image understanding. Each tool covers a distinct sub-domain (general analysis, OCR, errors, diagrams, data viz, UI artifacts, UI comparison), and no tool feels redundant or unnecessary.
The tool surface is comprehensive for an image understanding server, covering general understanding, text extraction, error diagnosis, diagram interpretation, data visualization analysis, UI-to-code conversion, and UI regression checking. There are no obvious missing operations within the stated domain.
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
MCP server for AI dialogue using various LLM models via AceDataCloud
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
MCP server for Qwen Image 3 AI image generation
MCP server for Flux AI image generation
Related MCP Servers
- AlicenseBqualityDmaintenanceA TypeScript-based MCP server that enables text-to-image generation using Cloudflare's Flux Schnell model API.15MIT
- AlicenseNot gradedqualityCmaintenanceAn MCP server that enables any LLM to describe images from file paths, URLs, or base64 data by forwarding them to a supported vision provider such as OpenAI, Anthropic, or local Ollama models.62410MIT
- AlicenseNot gradedqualityCmaintenanceA local MCP server that gives LLMs eyes for images by performing object detection (YOLOv8) and text recognition (EasyOCR), outputting descriptive statements about objects and text positions without any API key or cloud dependency.MIT
- AlicenseAqualityBmaintenanceA local MCP server that gives vision to vision-less LLMs by describing images and extracting text via Alibaba DashScope vision models.2MIT