Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@imagefeatures-mcp check blurriness in photo.jpg"
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.
Give LLMs "mathematical eyes" for image analysis.
An MCP (Model Context Protocol) server that wraps the imagefeatures library, exposing classic computer vision features as tools that Claude and other LLMs can use.
LLM Vision | imagefeatures MCP |
"A sunset photo with warm colors" |
|
"Looks sharp to me" (often wrong) | Texture entropy: 1.2 β blur score: 0.78 |
Slow on 10,000 images | Extract once, query instantly |
LLMs see semantics ("a dog on a beach"). imagefeatures sees statistics (color histograms, texture patterns, edge orientations). Combine them for agents that reason about both content AND composition.
Related MCP server: llm-vision
Find images similar by color, texture, or combined features:
Same query image returns different results based on which feature you prioritize β CEDD finds structural matches, Color Histogram finds palette matches, LBP finds texture matches.
Sort images by dominant hue for color-organized galleries:
Images automatically sorted: grayscale β warm tones β greens β blues β reds
Filter by visual "mood" categories derived from mathematical features:
"Blue/Water" and "Green/Nature" tags computed from color + texture analysis, not AI labeling
# Install the MCP server
pip install imagefeatures-mcp
# Or install from source
pip install git+https://github.com/kelkalot/imagefeatures-mcp.gitDependencies:
imagefeatures β the underlying feature extraction library
mcp β Model Context Protocol SDK
numpy, pillow
Add to your Claude Desktop config:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"imagefeatures": {
"command": "python",
"args": ["-m", "imagefeatures_mcp"]
}
}
}Restart Claude Desktop. You can now ask:
"What are the dominant colors in this photo?"
"Find similar images in my ~/Photos folder"
"Sort these images by color"
"Which of these photos are blurry?"
# Run the server directly
python -m imagefeatures_mcp
# Test with MCP Inspector
npx @modelcontextprotocol/inspector python -m imagefeatures_mcpanalyze_imageAnalyze an image's visual composition using mathematical features.
analyze_image(image_path, preset="quick")Presets:
Preset | Features | Dimensions | Use Case |
| ColorHistogram, EdgeHistogram | 144 | Fast overview |
| ColorHistogram, ColorMoments, DominantColors, OpponentHistogram | 605 | Color analysis |
| LBP, Tamura, Haralick, Gabor | 328 | Texture analysis |
| EdgeHistogram, HOG, HuMoments | 231 | Shape/edge analysis |
| CEDD, FCTH, JCD | 504 | Best for similarity |
| All 22 features | 3,058 | Comprehensive |
compare_imagesCompare two images mathematically.
compare_images(image_a, image_b, feature="CEDD", metric="cosine")Features: Any of the 22 available (CEDD, JCD, ColorHistogram, PHOG, etc.)
Metrics: cosine, euclidean, l1, jsd, tanimoto
find_similar_in_folderFind visually similar images in a folder.
find_similar_in_folder(query_image, folder_path, top_k=5, feature="JCD")get_dominant_colorsExtract dominant colors with exact hex codes.
get_dominant_colors(image_path, num_colors=5)check_image_qualityDetect blur and quality issues using texture analysis.
check_image_quality(image_path)sort_by_colorSort all images in a folder by dominant hue.
sort_by_color(folder_path)filter_by_vibeFilter images by visual category.
filter_by_vibe(folder_path, vibe="blue_water")Vibes: blue_water, green_nature, warm_sunset, cool_moody, high_contrast, soft_minimal, grayscale, vibrant
extract_featuresGet raw feature vectors for ML pipelines.
extract_features(image_path, features="CEDD,PHOG,DominantColors")list_featuresList all 22 available features with descriptions.
The imagefeatures library provides 22 classic computer vision descriptors totaling 3,058 dimensions:
Feature | Dims | Description |
| 64 | RGB/HSV/Luminance histogram |
| 9 | Mean, std, skewness per channel |
| 512 | Opponent color space histogram |
| 72 | Fuzzy HSV quantization |
| 20 | K-means extracted dominant colors |
| 64 | MPEG-7 Haar-based color descriptor |
Feature | Dims | Description |
| 256 | Classic LBP histogram |
| 36 | Rotation-invariant LBP |
| 48 | Multi-scale Gabor wavelets |
| 18 | Coarseness, contrast, directionality |
| 6 | GLCM texture features |
| 256 | Census transform histogram |
Feature | Dims | Description |
| 80 | MPEG-7 edge directions |
| 630 | Pyramid histogram of oriented gradients |
| 144 | Histogram of oriented gradients |
| 7 | Shape-invariant Hu moments |
Feature | Dims | Description |
| 12 | MPEG-7 DCT color layout |
| 64 | DCT luminance descriptor |
Feature | Dims | Description |
| 144 | Color + edge directivity |
| 192 | Fuzzy color + texture |
| 168 | Joint CEDD + FCTH |
| 256 | Spatial color correlation |
Task | Recommended Feature |
General similarity search |
|
Color matching |
|
Texture analysis |
|
Shape matching |
|
Duplicate detection |
|
User: "Find marketing images that feel calm and professional"
Claude's strategy:
1. filter_by_vibe(folder, "blue_water") β narrows to ~200 images
2. get_dominant_colors() β filters for brand palette match
3. check_image_quality() β removes blurry images
4. Uses native vision on finalists to confirm contentUser: "Do these product photos match our brand colors?"
Claude's strategy:
1. get_dominant_colors() on each image
2. Compare hex codes to brand palette (#1a73e8, #ffffff)
3. Report images that deviate > 10%User: "Find duplicate or near-duplicate photos"
Claude's strategy:
1. extract_features() with JCD for all images
2. compare_images() pairwise
3. Group images with > 90% similarityTask | LLM Vision | imagefeatures | Winner |
"What's in this image?" | β Excellent | β Can't do | LLM |
Exact color hex codes | β Guesses | β Precise | imagefeatures |
Blur detection | β Often wrong | β ~90% accurate | imagefeatures |
Search 10,000 images | Slow, expensive | Fast, free | imagefeatures |
"What emotion does this convey?" | β Excellent | β Can't do | LLM |
Consistent, reproducible | β Variable | β Deterministic | imagefeatures |
Best approach: Use both. imagefeatures for precision/scale, LLM vision for understanding.
# Clone the repo
git clone https://github.com/kelkalot/imagefeatures-mcp.git
cd imagefeatures-mcp
# Install in development mode
pip install -e ".[dev]"
# Run tests
pytest
# Run the server locally
python -m imagefeatures_mcpimagefeatures β The underlying feature extraction library
MCP β Model Context Protocol specification
LIRE β Java library that inspired imagefeatures
MIT
If you use this in research, please cite:
@software{imagefeatures_mcp,
title = {imagefeatures-mcp: MCP Server for Classic Image Features},
author = {Michael A. Riegler},
url = {https://github.com/kelkalot/imagefeatures-mcp},
year = {2025}
}Analyze an image's visual composition using mathematical features.
This extracts statistical properties (color distribution, texture patterns, edge orientations) that describe HOW an image looks, not WHAT it contains.
Args: image_path: Path to the image file (jpg, png, webp, etc.) preset: Analysis depth - one of: - "quick": Color histogram + edges (144 dims, fast) - "color": Detailed color analysis (605 dims) - "color_advanced": Fuzzy, scalable, correlogram features - "texture": LBP, Tamura, Haralick, Gabor (328 dims) - "texture_advanced": Rotation-invariant LBP, Centrist - "shape": Edge histogram, HOG, Hu moments (231 dims) - "shape_advanced": PHOG pyramid (630 dims) - "layout": Spatial color/luminance layout (76 dims) - "combined": CEDD, FCTH, JCD - best for similarity (504 dims) - "full": All 22 features (3058 dims, comprehensive)
Returns: Human-readable analysis with feature interpretations.
| Name | Required | Description | Default |
|---|---|---|---|
| image_path | Yes | ||
| preset | No | quick |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses the tool's behavior: it extracts statistical properties, not semantic content. It explains the analysis depth options and the output format (human-readable analysis). While it doesn't cover side effects or permissions, for a read-only analysis tool, this is adequate.
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 well-structured with a clear intro, args section, and returns. It is front-loaded with the tool's purpose. Although it is lengthy due to the preset list, the details are necessary and well-organized, earning its space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of the tool and the presence of an output schema, the description is complete. It covers both parameters thoroughly, explains the output clearly, and distinguishes from sibling tools sufficiently. No gaps are apparent.
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 schema coverage is 0%, but the description compensates fully by explaining both parameters: image_path (path to image file) and preset (with all options and their dimensions). This adds considerable meaning beyond the schema's type and default.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: analyzing an image's visual composition using mathematical features, extracting statistical properties like color distribution and texture, explicitly distinguishing it from content recognition. It also differentiates from sibling tools like check_image_quality and filter_by_vibe by focusing on mathematical features rather than quality or vibe.
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 provides detailed preset options and their use cases (e.g., 'best for similarity' for 'combined'), but it lacks explicit guidance on when to use this tool versus alternatives like extract_features or filter_by_vibe. It does not state when not to use it or list exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Analyze image quality: blur, contrast, texture complexity.
Uses texture analysis to detect blur and quality issues. More reliable than asking an LLM to visually judge blur.
Args: image_path: Path to the image
Returns: Quality assessment with specific metrics.
| Name | Required | Description | Default |
|---|---|---|---|
| image_path | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It explains the method ('uses texture analysis') and mentions reliability, but does not disclose side effects, auth requirements, rate limits, or error behaviors.
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?
Extremely concise (three short paragraphs), front-loaded with purpose, and no redundant information. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, no nested objects, output schema exists), the description covers the core purpose and method. It lacks details on error handling or input validation, but the output schema likely supplements the return information.
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?
Only one parameter ('image_path') with 0% schema description coverage. The description adds 'Path to the image' but this is trivial and redundant with the schema title. No additional semantic value is provided.
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 explicitly states 'Analyze image quality: blur, contrast, texture complexity' which provides a clear verb and resource, and the listed aspects help distinguish it from sibling tools like 'analyze_image' or 'extract_features'.
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 includes a usage hint: 'More reliable than asking an LLM to visually judge blur', which implies when to use this tool over an alternative. However, it does not explicitly state when not to use it or directly compare to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compare two images mathematically to get a similarity score.
This measures visual similarity based on mathematical features, NOT semantic content. Different subjects can be "similar" if they share color palettes, textures, or compositions.
Args: image_a: Path to first image image_b: Path to second image feature: Feature for comparison. Recommended: - "CEDD": Color + edge (144 dims, good general purpose) - "JCD": Joint CEDD+FCTH (168 dims, best for similarity) - "ColorHistogram": Color only (64 dims) - "LocalBinaryPatterns": Texture only (256 dims) - "PHOG": Shape only (630 dims) metric: Distance metric - "cosine", "euclidean", "l1"
Returns: Similarity score (0-100%) and interpretation.
| Name | Required | Description | Default |
|---|---|---|---|
| image_a | Yes | ||
| image_b | Yes | ||
| feature | No | CEDD | |
| metric | No | cosine |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool returns a similarity score (0-100%) and interpretation, and explains that similarity is based on mathematical features like color, texture, shape. It does not mention potential side effects, but the operation appears read-only.
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?
Description is concise and well-structured with an introductory sentence followed by an Args list. Every sentence adds value, no fluff, and it is front-loaded with 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?
Given the tool has an output schema, the description does not need to explain return values in detail. It covers main aspects: purpose, parameters, and behavioral caveat. Minor gaps exist, such as not mentioning image format requirements or error handling for invalid paths.
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 0%, so the description must compensate. It explains all four parameters: image_a, image_b are paths; feature includes recommended options with dimensions and use cases; metric lists distance options. This adds significant meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it compares two images mathematically to get a similarity score, which is a specific verb+resource. It distinguishes from siblings like analyze_image and extract_features by emphasizing mathematical rather than semantic analysis.
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?
Provides explicit context that the tool measures visual similarity based on mathematical features, not semantic content. Recommends specific features for different purposes (e.g., 'CEDD' for general purpose, 'JCD' for best similarity). However, it does not explicitly state when not to use this tool or suggest alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract raw feature vectors from an image.
Returns numerical vectors for custom ML pipelines, database indexing, or advanced analysis.
Args: image_path: Path to the image features: Comma-separated feature names. Available (22 total): Color: ColorHistogram, ColorMoments, OpponentHistogram, FuzzyColorHistogram, DominantColors, ScalableColor Texture: LocalBinaryPatterns, RotationInvariantLBP, Gabor, Tamura, Haralick, Centrist Shape: EdgeHistogram, PHOG, HOG, HuMoments Layout: ColorLayout, LuminanceLayout Combined: CEDD, FCTH, JCD, AutoColorCorrelogram
Returns: JSON with feature vectors and statistics.
| Name | Required | Description | Default |
|---|---|---|---|
| image_path | Yes | ||
| features | No | CEDD,ColorHistogram |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully convey behavior. It states it 'extracts' and returns JSON but does not indicate whether it's read-only, requires specific permissions, or handles errors. Behavioral traits beyond the basic operation are missing.
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 well-structured with paragraphs for purpose, use cases, parameters, and returns. It is slightly verbose but every sentence adds value. No unnecessary 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?
With 2 parameters and an output schema present, the description explains the return format (JSON with vectors and statistics) and lists features. It does not mention prerequisites or edge cases, but is sufficient for typical 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?
Schema description coverage is 0%, but the description provides detailed parameter information. It explains 'image_path' as path, and 'features' lists 22 available feature names with categories, adding significant meaning beyond the schema's type and default.
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 'Extract raw feature vectors from an image' with a specific verb and resource. It lists use cases and available feature categories, distinguishing it from sibling tools like 'analyze_image' or 'get_dominant_colors'.
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 mentions use cases (custom ML pipelines, database indexing) but does not explicitly state when to use this tool versus alternatives or provide exclusions. Usage is implied but not clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Filter images by visual "vibe" categories.
Uses color and texture features to categorize images into semantic groups based on their mathematical properties.
Args: folder_path: Folder to search vibe: Category to filter by: - "blue_water": Blue dominant, water/sky scenes - "green_nature": Green dominant, nature scenes - "warm_sunset": Orange/red/yellow tones - "cool_moody": Blue/purple, low saturation - "high_contrast": Strong texture, high contrast - "soft_minimal": Low texture, smooth gradients - "grayscale": Black and white or desaturated - "vibrant": High saturation, colorful
Returns: List of matching images with confidence scores.
| Name | Required | Description | Default |
|---|---|---|---|
| folder_path | Yes | ||
| vibe | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It mentions that the tool uses color and texture features and returns a list with confidence scores, but it does not cover error handling, permissions, or whether it modifies data. The explanation is adequate but not comprehensive.
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 concise and well-structured: a clear first sentence, an organized Args section with bullet points for vibe values, and a Returns section. Every sentence serves a purpose, and no information is redundant or wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 parameters, no annotations, output schema present), the description covers the core functionality and output. However, it lacks details on edge cases like empty results or performance, which would make it more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains folder_path as 'Folder to search' and provides a detailed enumeration of valid vibe values with descriptions. This adds significant meaning beyond the bare schema, though folder_path could benefit from more context (e.g., path format).
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 filters images by visual 'vibe' categories using color and texture features. It provides a specific verb (filter) and resource (images), and the list of categories distinguishes it from sibling tools that analyze or compare images in other ways.
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 explains what the tool does but does not explicitly compare it to siblings like sort_by_color or get_dominant_colors. It implies usage (e.g., filtering by specific categories) but provides no guidance on when to choose this tool over alternatives, which is a gap given the numerous sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find visually similar images in a folder.
Scans all images and ranks them by visual similarity to the query. Similarity is based on mathematical features, not semantic content.
Args: query_image: Path to the reference image folder_path: Folder to search top_k: Number of results (1-20) feature: Feature for comparison - "JCD", "CEDD", "ColorHistogram", etc.
Returns: Ranked list of similar images with scores.
| Name | Required | Description | Default |
|---|---|---|---|
| query_image | Yes | ||
| folder_path | Yes | ||
| top_k | No | ||
| feature | No | JCD |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It explains that similarity is based on mathematical features not semantic content, and that it scans all images. However, it does not disclose potential side effects, error handling, or whether the operation is read-only. Adequate but not comprehensive.
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 concise and well-structured: purpose statement, brief explanation of method, list of parameters with descriptions, and a return summary. Every sentence adds value with no 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?
The description covers the tool's purpose, parameters, and return value briefly but adequately. Given that an output schema exists, the return description is acceptable. Missing details like error handling or prerequisites, but overall sufficient for a straightforward 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?
Schema description coverage is 0%, but the description compensates effectively with a clear Args section detailing each parameter's purpose, including examples for the 'feature' parameter and a range for 'top_k'. This adds significant meaning beyond the bare 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 finds visually similar images in a folder and ranks them. It is specific with verb and resource but does not explicitly distinguish from sibling tools like compare_images or filter_by_vibe, though the context implies a difference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The description only states what it does, leaving the agent to infer usage context. Given the presence of similar sibling tools, this is a gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract the dominant colors from an image.
Uses K-means clustering to find the most prominent colors. Returns exact hex codes and percentages.
Args: image_path: Path to the image num_colors: Number of colors to return (1-5)
Returns: List of hex codes with percentages.
| Name | Required | Description | Default |
|---|---|---|---|
| image_path | Yes | ||
| num_colors | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the method (K-means) and outputs (hex codes with percentages), but lacks details on potential limitations, error handling, or prerequisites like file existence. Without annotations, the description carries the full burden, and while functional, it misses behaviors like image size impact.
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 succinct with three sentences plus an Args/Returns block. Every sentence adds value, and the structure is front-loaded with the main action. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (2 parameters, 1 required) and the presence of an output schema, the description is adequate. It covers the core functionality and parameter semantics, though it could briefly mention relation to sibling tools for more 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?
With 0% schema description coverage, the description compensates by clearly explaining each parameter's purpose and adding a range constraint for num_colors (1-5) not present in the schema. This provides meaningful guidance beyond the raw schema types.
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 extracts dominant colors from an image using K-means clustering, specifying the output as hex codes and percentages. This is a specific verb-resource combination that distinguishes it from siblings like check_image_quality or compare_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?
The description implies usage for color extraction but does not provide explicit guidance on when to choose this tool over siblings, such as analyze_image or extract_features. No when-not-to-use or alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available features from the imagefeatures library.
Returns documentation for all 22 feature extractors with dimensions and recommended use cases.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It correctly indicates the tool is read-only (lists, returns documentation) and mentions it covers all 22 feature extractors. It does not explicitly state safety or lack of side effects, but the purpose implies no mutations.
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 two sentences, front-loaded with the purpose ('List all available features'), and every word earns its place. No unnecessary details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters, an output schema present, and the simple nature of listing, the description fully covers what the tool does. No gaps.
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 0 parameters and the schema coverage is 100% (empty schema). According to guidelines, baseline score for 0 parameters is 4. The description adds no parameter info because none 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 clearly states the tool lists all available features from the imagefeatures library and returns documentation with dimensions and use cases. This distinguishes it from siblings like extract_features (which extracts features) and analyze_image (which performs analysis).
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 discovering available features before extraction, but does not explicitly mention when to use or avoid this tool versus alternatives like extract_features or filter_by_vibe. Context with sibling tools helps but is not directly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Sort all images in a folder by their dominant hue.
Returns images ordered: grayscale β warm (red/orange/yellow) β green β cool (blue/cyan) β purple β back to red.
Useful for creating color-organized galleries.
Args: folder_path: Folder containing images
Returns: Ordered list of images with dominant hue values.
| Name | Required | Description | Default |
|---|---|---|---|
| folder_path | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the sorting order and output format but does not mention side effects, performance, or format requirements. Adequate but not rich.
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 concise with a clear structure: purpose, ordering details, use case, Args, Returns. No superfluous content, though could be slightly more terse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given one simple parameter and an output schema, the description covers the essential behavior. It does not address error cases or assumptions about image formats, but overall complete for its simplicity.
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 schema has no description for folder_path (0% coverage). The description adds an explanation of the parameter in the Args section, providing meaning beyond the schema's type-only definition.
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 specifies that the tool sorts images by dominant hue and details the ordering sequence. It is distinct from sibling tools like analyze_image or get_dominant_colors.
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 states it is useful for color-organized galleries, implying appropriate use. It does not explicitly contrast with alternatives or list exclusions, but sibling differentiation is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0analyze_imagecheck_image_qualitycompare_imagesextract_featuresfilter_by_vibefind_similar_in_folderget_dominant_colorslist_featuressort_by_colorScored across 9 tools
Each tool has a clearly distinct purpose: analysis, quality check, comparison, raw feature extraction, vibe filtering, similarity search, color extraction, feature listing, and color sorting. Even overlapping areas like comparison and similarity are differentiated by scope (two images vs. a folder).
All tool names follow a consistent snake_case verb_noun pattern (e.g., analyze_image, sort_by_color, get_dominant_colors). There are no mixed conventions or vague verbs like 'process' or 'do_thing'.
9 tools is appropriate for the domain of mathematical image feature extraction. Each tool provides a distinct operation without unnecessary duplication or missing essential functionality.
The tool set covers the full lifecycle of feature-based image analysis: single image analysis, quality assessment, pairwise comparison, raw feature extraction, vibe categorization, similarity search, color extraction, feature enumeration, and folder organization. No obvious gaps for the stated purpose.
MCP server for Qwen Image 3 AI image generation
MCP server providing access to the Scorecard API to evaluate and optimize LLM systems.
MCP server for NanoBanana AI image generation and editing
OCR, transcription, file extraction, and image generation for AI agents via MCP.
