Promas
Promas (Rascador de imágenes de producto)
Promas es un rascador automatizado de imágenes de producto y un servidor de Model Context Protocol (MCP) para agentes de IA.
En lugar de escribir rascadores frágiles específicos para cada sitio que se rompen cuando cambian las estructuras HTML, Promas combina Descubrimiento enchufable basado en búsqueda con un canal universal de extracción semántica y ampliación extensible compatible con CDN. Extrae de forma fiable fotografía de producto en resolución maestra en cualquier sitio de marcas o minoristas (Apple, Nike, Sony, Amazon, Target, B&H, Best Buy, eBay, tiendas Shopify y URLs de producto arbitrarias).
1. Inicio rápido
Opción A: Instalar desde PyPI (Recomendado)
pip install promas
playwright install chromiumEjecútalo al instante desde cualquier lugar:
promas "iPhone 16 Pro"Opción B: Ejecutar con Docker (Sin configuración local de Python / Playwright)
# Build the Docker image
docker build -t promas .
# Run the FastMCP Server for your AI Agent
docker run -i --rm promas
# Or run the standalone CLI scraper
docker run --rm promas promas "Sony FX3"Related MCP server: Commerce MCP Server
2. Arquitectura y pipeline
graph TD
User([AI Agent / CLI Request]) --> Cache{TTL Disk Cache}
Cache -- "Cache Hit (<0.1s)" --> Return([Return Verified Master Assets])
Cache -- "Cache Miss" --> SearchRouter{Pluggable Discovery}
SearchRouter -->|BRAVE_API_KEY| BraveAPI[Brave Search API]
SearchRouter -->|SERPAPI_API_KEY| SerpAPI[SerpAPI Google]
SearchRouter -->|Default: Free / Zero Keys| BrowserSearch[Stealth Browser Discovery]
BraveAPI --> Scorer[E-Commerce Candidate Scorer]
SerpAPI --> Scorer
BrowserSearch --> Scorer
Scorer --> ParallelScraper[Parallel Multi-Page Scraper]
subgraph Scraping Pipeline
ParallelScraper --> RateLimiter[Domain Rate Limiter]
RateLimiter --> Parser[Universal Extractor: Schema.org, OG, Microdata, DOM]
Parser --> CDNUpscaler[CDN Master Upscalers: Scene7, Nike, Shopify, Amazon...]
end
CDNUpscaler --> Verifier[Async HTTP Verification & pHash Dedup]
Verifier --> CacheStore[(Save to Disk Cache)]
CacheStore --> Return3. ¿Por qué Promas? (Comparativa)
Característica | Scripts simples ( | APIs de pago ( | Promas |
Coste | Gratuito | $50–$500+/mes recurrentes | 100 % gratuito y de código abierto (MIT) |
Configuración y mantenimiento | Selectores frágiles por sitio; se rompen con rediseños | Respuestas HTML genéricas; requiere analizadores personalizados | Basado en búsqueda + esquemas semánticos + ampliadores CDN |
Anti-bot y límites de velocidad | Bloqueado rápidamente por Cloudflare/Akamai | Gestionado en la nube | Limitador de tasa por dominio + Stealth + reintentos de Tenacity |
Verificación de imágenes | Ninguna; devuelve enlaces rotos y píxeles 1x1 | Comprobación de estado básica | Validación HTTP asíncrona + deduplicación perceptiva pHash |
Motores de búsqueda | Scrapers codificados | Scrapers de API personalizados | Enchufable (Brave API / SerpAPI / navegador de respaldo) |
Caché | Ninguna | Coste adicional | Caché de disco TTL integrada (consultas repetidas en menos de un segundo) |
Calidad de imagen | Normalmente captura miniaturas de interfaz de baja resolución | Solo imágenes sin procesar de la página | Desbloqueo de CDN maestro (hasta 2500px+) |
Nativo para agentes de IA | Se necesita envoltorio manual | Solo API REST | Protocolo de herramientas FastMCP nativo + soporte Docker |
4. Motores de búsqueda y configuración
Promas funciona 100 % listo para usar sin necesidad de configuración ni claves de API.
Cómo funciona el descubrimiento de búsqueda:
Gratis / predeterminado (sin configuración): Promas utiliza su motor de navegador Playwright Stealth integrado para descubrir candidatos de comercio electrónico mediante Bing y DuckDuckGo de forma gratuita.
Brave Search API (recomendado para producción): si se establece
BRAVE_API_KEY, Promas cambia al descubrimiento oficial por API, conforme a los Términos de servicio y en menos de un segundo.Obtén una clave gratuita (2,000 consultas gratuitas/mes): Brave Search API
SerpAPI (alternativa): si se establece
SERPAPI_API_KEY, Promas consulta Google Search a través de SerpAPI.Obtén una clave gratuita (100 consultas gratuitas/mes): SerpAPI
Referencia de variables de entorno:
Variable | Valor predeterminado | Descripción |
| Ninguna | Clave API opcional para Brave Search |
| Ninguna | Clave API opcional para la búsqueda de Google en SerpAPI |
|
| Máximo de contextos de navegador simultáneos |
|
| Máximo de solicitudes simultáneas por tienda objetivo |
|
| Retraso prudente entre solicitudes al mismo dominio |
|
| Activar o desactivar la caché de disco ( |
|
| Tiempo de caducidad de la caché en segundos |
|
| Verificación asíncrona HTTP MIME y de dimensiones en píxeles |
|
| Eliminación de recortes casi duplicados mediante pHash |
|
| Umbral de sensibilidad para la deduplicación con pHash |
5. Uso
A. CLI independiente
Buscar por nombre de producto:
promas "iPhone 16 Pro"Extraer desde una URL directa:
promas "https://www.apple.com/iphone-16-pro/"Filtrar por dominio específico y limitar el número de resultados:
promas "Sony FX3" --max-images 5 --site bhphotovideo.comOmitir la caché o desactivar la verificación:
promas "Nike Air Jordan 1" --no-cache --no-verifyB. Servidor FastMCP
Ejecuta el servidor MCP independiente:
promas-mcpC. Integración con agentes (mcp_config.json)
Instalación nativa de Python:
{
"mcpServers": {
"promas": {
"command": "promas-mcp",
"env": {
"BRAVE_API_KEY": "optional-key-here"
}
}
}
}Contenedor Docker (configuración sin dependencias):
{
"mcpServers": {
"promas": {
"command": "docker",
"args": ["run", "-i", "--rm", "promas"]
}
}
}6. Suite MCP de múltiples herramientas
Promas expone herramientas granulares y dedicadas a los agentes de IA:
Herramienta | Propósito | Descripción |
| Proceso completo | Cadena de consulta o URL -> Descubrimiento automático -> Extracción paralela -> Validación HTTP -> Deduplicación pHash -> Enlaces de fotos maestras. |
| Solo descubrimiento | Cadena de consulta -> Clasificación rápida de páginas de producto de comercio electrónico candidatas (devuelve URLs sin extraer imágenes). |
| Solo extracción | URL directa específica -> Extrae el título y los recursos de imagen maestra estrictamente de esa página. |
7. Directrices para el prompt del sistema del agente
Añade las siguientes instrucciones al prompt del sistema de tu agente de IA:
You have access to the `fetch_product_images` tool (Promas), which universally retrieves high-resolution product imagery and official product links from across the web.
GUIDELINES FOR USING PROMAS:
1. When asked for product images, photos, or visual references, call `fetch_product_images(query=<specific product name or direct URL>)`.
2. Do not invent or hallucinate image URLs; strictly return the verified URLs returned by Promas.
3. Render primary high-res images as markdown (e.g. ``) and provide source product links for reference.
4. If a specific store is desired by the user, you can supply `site_filter` (e.g. `site_filter="apple.com"`).8. Esquema de salida
{
"status": "success",
"query": "iPhone 16 Pro",
"title": "Apple iPhone 16 Pro",
"sources_scraped": [
"https://www.target.com/p/apple-iphone-16-pro/-/A-93597960",
"https://www.amazon.com/Apple-iPhone-Version-256GB-Titanium/dp/B0DHJDPYYR",
"https://www.apple.com/shop/buy-iphone/iphone-16"
],
"images": [
"https://target.scene7.com/is/image/Target/GUEST_7c0750b4-ee18-41d4-9309-d08e41619229",
"https://target.scene7.com/is/image/Target/GUEST_4e1ce623-313f-4193-93a4-61dc0fc9da14"
],
"error_message": null
}9. Contribuciones
¡Las contribuciones son muy bienvenidas! Añadir soporte de ampliación maestra para una nueva plataforma de comercio electrónico o CDN requiere menos de 10 líneas de código con nuestro registro de complementos por decorador.
👉 Consulta CONTRIBUTING.md para obtener instrucciones paso a paso sobre cómo añadir una nueva regla de CDN.
10. Pruebas y aseguramiento de la calidad
Promas incluye pruebas unitarias para funciones de análisis puro, comprobaciones de tipos y pruebas de integración canary:
# Run unit tests
pytest -v
# Run linting
ruff check .
# Run type checker
mypy promas/ tests/
# Run live golden canary integration tests (hits live sites)
pytest -v --run-integration11. Uso legal y ético
Solo acceso público: Promas accede exclusivamente a páginas web disponibles públicamente; no elude la autenticación, los muros de pago ni los inicios de sesión privados.
Términos de servicio: El acceso automatizado puede estar sujeto a los Términos de servicio de cada sitio. Revisa siempre los ToS y las políticas de robots de los dominios objetivo antes de hacer scraping a gran escala, o proporciona claves oficiales de API de búsqueda (
BRAVE_API_KEY/SERPAPI_API_KEY) para un descubrimiento conforme a los términos.Derechos de autor y atribución de las imágenes: Promas resuelve y devuelve URLs directas de imágenes; no almacena, realoja ni copia archivos multimedia. La visualización, el almacenamiento o el uso comercial posterior de las imágenes obtenidas son responsabilidad del usuario.
12. Licencia
Este proyecto está licenciado bajo la Licencia MIT.
Available Tools
4 toolsfetch_product_imagesA
Universally extracts verified, high-resolution product photography and official sources across the web.
USE THIS TOOL WHEN:
You need product photos, packshots, visual references, or master CDN assets for any physical item.
You want Promas to automatically discover authoritative stores, scrape candidate pages, verify images via HTTP, and deduplicate near-identical photo crops.
EXAMPLE QUERIES:
fetch_product_images(query="Sony FX3 Cinema Camera", max_images=5)
fetch_product_images(query="Nike Air Jordan 1", site_filter="nike.com")
fetch_product_images(query="https://www.target.com/p/apple-iphone-16-pro/-/A-93597960")
RETURNS:
ProductImageResult containing:
status: 'success' or 'error'
title: Cleaned product title
sources_scraped: List of retail & brand URLs visited
images: List of verified master-resolution image URLs (up to 2500px+)
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The product name, model identifier, or direct e-commerce product URL to extract images for. Examples: 'iPhone 16 Pro', 'Nike Air Jordan 1 Low', 'Sony FX3 Cinema Camera', 'https://www.apple.com/iphone-16-pro/' | |
| no_cache | No | If True, bypasses the TTL disk cache and forces a live scrape. | |
| max_images | No | Maximum number of verified, high-resolution master product images to return (1-20). Default is 10. | |
| site_filter | No | Optional domain to restrict the product search to (e.g. 'apple.com', 'nike.com', 'bhphotovideo.com', 'amazon.com'). |
Output Schema
| Name | Required | Description |
|---|---|---|
| query | Yes | Search query or URL requested |
| title | No | Title of the matched product or primary page |
| images | No | Array of high-resolution image URLs |
| status | Yes | 'success' or 'error' |
| error_message | No | Error message if scraping failed |
| sources_scraped | No | URLs or domains scraped |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does it well. It discloses that the tool scrapes candidate pages, verifies images via HTTP, deduplicates near-identical crops, maintains a TTL disk cache, and returns a status field. It does not cover rate limits or failure modes, but the core behavior is clearly described.
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 bold section headers: summary, usage conditions, example queries, and return fields. It is appropriately sized and front-loaded; every section adds meaningful guidance without verbose filler.
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 web-extraction tool with four parameters and an output schema, the description covers the workflow, return format, and example invocations. It could better disambiguate from the sibling tool get_product_images_tool, but the provided detail is sufficient for an agent to call it correctly.
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 the baseline is 3. The description adds value with concrete example queries showing how to pass product names, URLs, max_images, and site_filter, which reinforces the schema's documentation without being redundant.
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?
Description clearly states a specific verb and resource: 'Universally extracts verified, high-resolution product photography and official sources across the web.' It also conveys a distinct approach (automatic discovery, HTTP verification, deduplication) that differentiates it from generic scrapers, though it doesn't explicitly name or contrast sibling tools.
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 'USE THIS TOOL WHEN' section explicitly lists the scenarios for using this tool: needing product photos, packshots, visual references, or master CDN assets. It also describes the automatic discovery and verification behavior. It does not state exclusions or alternatives, but the context is clear enough for an agent to select it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_product_images_toolD
Backward-compatible alias for fetch_product_images.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| max_images | No | ||
| site_filter | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| query | Yes | Search query or URL requested |
| title | No | Title of the matched product or primary page |
| images | No | Array of high-resolution image URLs |
| status | Yes | 'success' or 'error' |
| error_message | No | Error message if scraping failed |
| sources_scraped | No | URLs or domains scraped |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description bears the full burden of behavioral disclosure — and it says nothing about behavior. An alias claim implies identical behavior to fetch_product_images, but the description never states what that behavior is: no filtering semantics, no read-only guarantee, no output format, no side effects.
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 text is a single, well-front-loaded sentence with no waste. However, its brevity is achieved at the expense of substantive content — it conveys a single fact (alias target) and nothing else, so conciseness is not paired with information density.
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 having an output schema (which excuses return-value explanation), the tool still needs to explain its behavior and parameters. With 3 undocumented parameters, no annotations, and zero behavioral description, an agent cannot reliably decide to call it or construct valid arguments. The alias reference defers all meaningful context to an unseen sibling.
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% and the description mentions none of the three parameters (query, max_images, site_filter). The schema itself contains no descriptions and no enums, so the agent is left with bare type information and defaults, with zero guidance on semantics — including what query expects or how site_filter behaves.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states only that it is an alias for fetch_product_images, never that it retrieves product images. The actual function must be inferred from the tool name and the sibling's identity. This is a meta-description referencing another tool rather than a description of the tool's own purpose — close to a tautology of the name.
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 identifies fetch_product_images as the canonical target but gives no guidance on when to call this alias versus the canonical tool, nor any information on how it relates to search_product_urls or scrape_single_url. No context is given on preferred use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scrape_single_urlA
Extracts high-resolution product imagery from a single direct product URL (Extraction only).
USE THIS TOOL WHEN:
You already have an exact product URL (from search_product_urls or user input) and want to extract master photos strictly from that page.
Uses universal Schema.org JSON-LD, OpenGraph, dynamic JS datasets, DOM selectors, and CDN upscalers.
EXAMPLE CALL:
scrape_single_url(url="https://www.apple.com/iphone-16-pro/")
RETURNS:
ProductImageResult containing extracted images and metadata from the specified URL.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Direct web URL of the product detail page to extract images from. Example: 'https://www.apple.com/iphone-16-pro/' or 'https://www.bhphotovideo.com/c/product/1624226-REG/sony_ilme_fx3_fx3_cinema_line_camera.html' | |
| no_cache | No | If True, bypasses disk cache and scrapes live. | |
| max_images | No | Maximum images to extract from this specific page. Default is 10. |
Output Schema
| Name | Required | Description |
|---|---|---|
| query | Yes | Search query or URL requested |
| title | No | Title of the matched product or primary page |
| images | No | Array of high-resolution image URLs |
| status | Yes | 'success' or 'error' |
| error_message | No | Error message if scraping failed |
| sources_scraped | No | URLs or domains scraped |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It adds context by stating 'Extraction only' (read-only behavior) and listing the technical methods (JSON-LD, OpenGraph, dynamic JS datasets, DOM selectors, CDN upscalers), which implies JavaScript execution and network requests. It does not mention rate limits or auth, but for a scraping tool with a clear read-only hint, this is meaningful.
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 and front-loaded with the core purpose, followed by brevity in 'when to use', a concrete example, and expected return. Every section earns its place, with no filler 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?
Given the output schema exists, return values are covered. The description provides usage context, source of URLs, and technical methods. It lacks error handling details or edge-case behavior, but for a simple scraping tool, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema; the example call illustrates a valid URL but does not clarify parameter semantics further. The schema already documents each parameter adequately.
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 specific verb 'Extracts' and the resource 'high-resolution product imagery from a single direct product URL', which distinguishes it from sibling tools like search_product_urls that search for URLs. The 'Extraction only' parenthetical further clarifies 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 'USE THIS TOOL WHEN' section explicitly states the condition: when the user already has an exact product URL. It references search_product_urls as a source, providing context, but does not explicitly name alternatives to use instead when the condition is not met. It is clear but lacks explicit when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_product_urlsA
Discovers and ranks candidate e-commerce product pages for a given query (Discovery only).
USE THIS TOOL WHEN:
You want to find authoritative product detail pages (PDPs) across retailers without downloading or scraping images yet.
You want to preview which stores/URLs exist for a product before selecting one to scrape.
EXAMPLE CALL:
search_product_urls(query="Sony FX3 Cinema Camera", max_urls=3)
search_product_urls(query="MacBook Pro M3", site_filter="apple.com")
RETURNS:
A list of ranked, direct product destination URLs.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Product name or keywords to search for. Example: 'Sony FX3 camera', 'Nike Air Jordan 1' | |
| max_urls | No | Maximum candidate product URLs to return (1-10). Default is 5. | |
| site_filter | No | Optional specific domain to restrict search results to (e.g. 'bhphotovideo.com', 'apple.com') |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavior. It clearly states 'Discovery only,' explains that it does not download or scrape images, and notes that it returns 'ranked' URLs — this goes beyond the mere title and gives the agent expectations about side effects and output ordering. It doesn't cover rate limits or auth, but these are less critical for a discovery-only read operation.
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 clear headings and short bullet sections. It front-loads the core purpose in one sentence, and every section (why, examples, returns) earns its place without redundant wording or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple three-parameter discovery tool with complete schema documentation and an output schema, the description is sufficient for an agent to select and invoke it correctly. It gives purpose, usage context, concrete examples, and a clear statement of the return type, so no critical information is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents each parameter's meaning and example values. The description adds example calls showing how query, max_urls, and site_filter are combined, but this does not materially extend the parameter semantics beyond what the schema provides. 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 first sentence states a specific action and target: 'Discovers and ranks candidate e-commerce product pages for a given query (Discovery only).' It clearly identifies this as a discovery/preview tool rather than a scraping tool, and distinguishes it from siblings like fetch_product_images and scrape_single_url by explicitly noting it does not download or scrape 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 'USE THIS TOOL WHEN' section provides clear use cases: finding authoritative PDPs and previewing URLs before scraping. This effectively implies when not to use it (when you need images or actual page content), though it never names sibling alternatives directly or states explicit exclusions. The example calls further clarify how to invoke it.
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.
4 tool updates
v1.0.0- First observed
fetch_product_images - First observed
get_product_images_tool - First observed
scrape_single_url - First observed
search_product_urls
TDQS
Scored across 4 tools
The three primary tools have clearly distinct purposes: fetch_product_images performs full discovery and scraping, search_product_urls only finds URLs, and scrape_single_url extracts images from a provided URL. The fourth tool is explicitly marked as a backward-compatible alias, so no genuine ambiguity exists.
The main tools follow a verb_noun pattern (fetch_product_images, search_product_urls, scrape_single_url), but the alias get_product_images_tool breaks the pattern by using 'get' and a '_tool' suffix. This is a minor deviation, as the alias is clearly labeled and does not detract from the overall predictability.
With only 4 tools, the server is well-scoped. Each core tool serves a distinct stage in the product image retrieval workflow (discovery, extraction, combined pipeline), and the alias is a harmless addition. The count fits comfortably within the ideal range.
The tool surface completely covers the domain: it offers discovery-only (search_product_urls), extraction-only (scrape_single_url), and a comprehensive pipeline (fetch_product_images). There are no obvious dead ends or missing operations for the stated purpose of retrieving product images.
Maintenance
Related MCP Connectors
Live product discovery for AI shopping agents, with shopper-approved retailer handoff.
Live product search for AI agents across Shopify merchants and major retailers.
The E-commerce Marketplace For Every AI Agent. A Governed Catalog Of 600M+ US Products, Plus Four Agent Ready Capabilities Search, Price Comparison, Product-Vs-Product, And Detailed Q&A.
AI-agent product catalog: search, lookup & purchase routing over verified merchant data.
Related MCP Servers
- AlicenseAqualityDmaintenanceKlarna-style product discovery for AI shopping agents. Makes product catalogs machine-readable so AI agents can search, compare, and purchase products programmatically.620 PyPIMIT
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to browse product catalogs, search products with filters, and initiate checkouts, generating order summaries and checkout URLs.-

Periskop MCP Serverofficial
AlicenseNot gradedqualityDmaintenanceEnables AI agents to perform product discovery from natural language shopping intents, returning ranked products with merchant links without completing checkout.MIT- AlicenseNot gradedqualityBmaintenanceEnables agents to perform structured shopping actions and retrieve targeted product images for visual comparison, matching, and aesthetic recommendations.MIT