Servidor MCP para investigación web, artículos académicos, Twitter/X, YouTube e ingesta de archivos. Ocho herramientas para asistentes de IA, todo a través del protocolo stdio de MCP. Incluye un almacén de credenciales para acceso institucional, detección de CAPTCHA y salida eficiente en tokens.
Herramienta | Descripción |
| Cascada de búsqueda de 3 niveles: Brave API → DuckDuckGo → HTML scraper |
| Obtener cualquier URL → markdown limpio, con protección SSRF y caché de 24h |
| Canal compuesto: reescritura de consulta → búsqueda → obtención paralela → resumen → síntesis |
| Vídeo de YouTube → transcripción, resumen, puntos clave, capítulos, citas |
| Extraer texto de archivos: PDF, DOCX, XLSX, PPTX, audio, vídeo, imágenes |
| Resolver DOI / ArXiv / PubMed → metadatos + texto completo mediante acceso institucional |
| Extraer tweets e hilos de X.com/Twitter |
| Mostrar perfiles de credenciales cargados y estado de dependencias (nunca expone secretos) |
Todas las herramientas son de solo lectura: obtienen y transforman contenido, nunca modifican nada.
Related MCP server: The Web MCP
pip install mcp-researchO ejecútalo directamente con uvx (sin instalación):
uvx mcp-researchExtras opcionales:
pip install 'mcp-research[twitter]' # yt-dlp for Twitter extraction
pip install 'mcp-research[youtube]' # yt-dlp + faster-whisper for YouTube
pip install 'mcp-research[academic]' # PyPDF2 for academic PDFs
pip install 'mcp-research[ingest]' # PDF, DOCX, XLSX, PPTX, audio support
pip install 'mcp-research[all]' # everythingComprueba tu configuración:
mcp-research doctorAñádelo a tu configuración de MCP de Claude Code (~/.claude/settings.json o .mcp.json del proyecto):
{
"mcpServers": {
"research": {
"command": "uvx",
"args": ["mcp-research"],
"env": {
"BRAVE_API_KEY": "BSA...",
"OLLAMA_URL": "http://localhost:11434"
}
}
}
}Añádelo a claude_desktop_config.json:
{
"mcpServers": {
"research": {
"command": "uvx",
"args": ["mcp-research"],
"env": {
"BRAVE_API_KEY": "BSA..."
}
}
}
}Toda la configuración se realiza mediante variables de entorno; no se necesitan archivos de configuración (excepto el almacén opcional).
Variable | Predeterminado | Descripción |
| (vacío) | Clave de API de Brave Search. Si no se establece, recurre a DuckDuckGo. |
|
| Endpoint de Ollama para resumen/síntesis. Déjalo vacío para desactivar. |
|
| Modelo a utilizar para resumen y síntesis. |
|
| Directorio de caché de obtención de URL. |
|
| TTL de caché en horas. |
|
| Directorio de registros de búsqueda (NDJSON). |
|
| Máximo de resultados de búsqueda predeterminado. |
|
| Ruta del archivo del almacén de credenciales. |
|
| Recarga automática del almacén cuando cambia el archivo. |
|
| Tiempo de espera de inactividad de la sesión en segundos. |
web_searchweb_search(query, max_results=5, summarize=False, auto_fetch_top=False)Busca en la web utilizando una cascada de 3 niveles para una máxima fiabilidad:
Brave Search API — rápido, alta calidad (requiere BRAVE_API_KEY)
Biblioteca DuckDuckGo — no requiere clave de API, reintenta ante límites de tasa
HTML scraper de DuckDuckGo — alternativa de último recurso
Opciones:
summarize: Usar Ollama para resumir resultados (requiere tener Ollama en ejecución)
auto_fetch_top: También obtener y devolver el contenido completo del resultado principal
fetch_urlfetch_url(url, summarize=False, max_chars=15000)Obtiene una URL y la convierte a markdown limpio:
Protección SSRF: Bloquea localhost, IPs privadas, esquemas no HTTP
Reintento inteligente: Retroceso exponencial en 429/5xx, validación de redirección por salto
Caché de 24h: Clave SHA-256, TTL configurable
Soporte de contenido: HTML → markdown, JSON → bloque de código, binario → rechazado
Truncamiento inteligente: Corta en límites de encabezado/párrafo, no a mitad del texto
Detección de CAPTCHA: Marca muros de Cloudflare, hCaptcha, reCAPTCHA, Akamai
Eficiente en tokens: 15K caracteres predeterminados (~4K tokens), ajustable mediante max_chars
researchresearch(query, depth="standard", context="")Canal de investigación compuesto:
Reescritura de consulta — Ollama optimiza tu pregunta en palabras clave de búsqueda
Búsqueda web — encuentra páginas relevantes (con expansión de reintento si hay cero resultados)
Obtención paralela — obtiene las N páginas principales simultáneamente
Resumir — Ollama resume cada página
Sintetizar — Ollama produce una respuesta final citada
Niveles de profundidad:
Profundidad | Páginas | Síntesis |
| 2 | No |
| 5 | Sí |
| 10 | Sí |
Todos los pasos se degradan correctamente sin Ollama: sigues obteniendo resultados de búsqueda y contenido de la página.
youtube_essenceyoutube_essence(url, mode="standard")Extrae contenido estructurado de vídeos de YouTube:
Transcripción: Subtítulos automáticos o transcripción Whisper (local, privada)
Resumen: Resumen de IA mediante Ollama
Puntos clave: Conclusiones en viñetas
Capítulos: Segmentos con marca de tiempo
Citas: Citas notables (modo profundo)
Modos: quick (TL;DR), standard (+ capítulos), deep (+ citas)
Requiere yt-dlp. Opcional: faster-whisper para vídeos solo de audio, ffmpeg para extracción de medios.
deep_ingestdeep_ingest(path, include_types="", max_files=200, summarize=False)Extrae texto de archivos en un directorio o un solo archivo:
Archivos de texto: .txt, .md, .json, .csv, código fuente, etc.
PDF: Vía PyPDF2 (dependencia opcional)
Office: .docx, .xlsx, .pptx (dependencias opcionales)
Audio/Vídeo: Transcripción Whisper (opcional)
Imágenes: OCR mediante modelo de visión de Ollama (opcional)
Filtro de tipo: text, pdf, audio, video, image, office
academic_lookupacademic_lookup(identifier, fetch_fulltext=True)Resuelve artículos académicos de múltiples tipos de identificadores:
DOI: 10.xxxx/... → metadatos de Crossref + redirección del editor
ArXiv: 2301.12345 → resumen + PDF
PubMed: PMID → metadatos de E-utilities → cadena DOI
URL: Detección de página del editor
Acceso a texto completo mediante almacén de credenciales:
Reescritura EZproxy (modos prefijo y sufijo)
Token de portador (bearer), clave de API, autenticación básica, tarro de cookies
Detección automática de editor (IEEE, Springer, Elsevier, ACM, Wiley, Nature, JSTOR, etc.)
twitter_extracttwitter_extract(url, include_thread=False)Extrae tweets e hilos de X.com/Twitter usando una cascada de estrategias:
yt-dlp (principal) — funciona con tarro de cookies para acceso autenticado
Twitter API v2 — si el token de portador está configurado en el almacén
Obtención HTML — último recurso basado en cookies
Devuelve: texto, autor, marca de tiempo, métricas (me gusta, retweets, respuestas), URLs de medios.
vault_statusvault_status()Muestra perfiles de credenciales cargados, patrones de coincidencia y tipos de autenticación — nunca expone secretos. También comprueba la disponibilidad de dependencias opcionales.
Crea ~/.mcp-research/vault.yaml para configurar la autenticación para fuentes protegidas:
version: 1
profiles:
# University EZproxy for IEEE
ieee-university:
match: "*.ieee.org/**"
ezproxy:
base_url: "https://ezproxy.myuniversity.edu/login?url="
mode: prefix
# Springer via API key
springer:
match: "*.springer.com/**"
auth:
type: api_key
header: "X-ApiKey"
value: "${SPRINGER_API_KEY}"
# X.com via browser cookies
twitter:
match: "*.x.com/**"
auth:
type: cookie_jar
path: "${HOME}/.mcp-research/cookies/twitter.txt"${VAR} resuelto a partir de variables de entorno — los secretos nunca se almacenan en texto plano
Gana el primer perfil coincidente (el orden importa)
Tipos de autenticación: bearer, basic, api_key, cookie_jar, headers
Modos EZproxy: prefix (anteponer URL base) o suffix (reescritura de dominio)
Recarga en caliente: los cambios en el archivo del almacén se detectan automáticamente
Todas las herramientas producen una salida compacta de forma predeterminada para evitar desperdiciar tokens de la ventana de contexto de la IA:
Herramienta | Salida predeterminada | Anulación |
| ~15K caracteres (~4K tokens) | parámetro |
| ~500 tokens por fuente | Prefiere resúmenes sobre contenido sin procesar |
| ~10K caracteres texto completo | Trunca con aviso |
| 15 archivos, extractos de 300 caracteres | parámetro |
| Extracto de transcripción de 3K caracteres | Transcripción completa en el objeto de resultado |
Protección SSRF: Bloquea localhost, IPs privadas, link-local, esquemas no HTTP en cada salto
Detección de CAPTCHA: Identifica muros de Cloudflare, hCaptcha, reCAPTCHA, Akamai, DDoS-Guard
Validación de entrada: Límites de tamaño, validación de URL, seguimiento seguro de redirecciones
Sin eval/exec: Sin ejecución de código dinámico
Seguridad del almacén: Secretos resueltos desde variables de entorno, repr() redacta todos los valores de autenticación
Aislamiento de caché: Permisos de directorio solo para el propietario (0o700)
Degradación elegante: Las dependencias opcionales faltantes no bloquean el sistema — las funciones se degradan con mensajes claros
mcp-research serve # Run MCP stdio server (default)
mcp-research search "query" # Search the web
mcp-research fetch https://example.com # Fetch URL to markdown
mcp-research youtube https://youtu.be/... # Extract YouTube video
mcp-research ingest ./docs/ # Extract text from files
mcp-research academic "10.1109/..." # Resolve academic paper
mcp-research tweet https://x.com/.../123 # Extract tweet
mcp-research vault # Show vault profiles
mcp-research doctor # Check dependenciesgit clone https://github.com/MABAAM/Maibaamcrawler.git
cd Maibaamcrawler
pip install -e ".[all]"
pytest tests/ -v
python -m mcp_researchAlmacén de credenciales: Configuración YAML en ~/.mcp-research/vault.yaml con interpolación de variables de entorno, coincidencia de URL con glob, reescritura EZproxy, recarga en caliente
Agrupación de sesiones: Sesiones por dominio con inyección de autenticación del almacén, soporte para tarro de cookies, desalojo por inactividad
Detección de CAPTCHA: Identifica muros de Cloudflare, hCaptcha, reCAPTCHA, Akamai, DDoS-Guard, muros de bots genéricos
Búsqueda académica: Resolución DOI/ArXiv/PubMed, metadatos Crossref, acceso institucional a texto completo mediante almacén
Extracción de Twitter/X: yt-dlp, API v2 y acceso basado en cookies con soporte para hilos
Eficiencia de tokens: Límites de salida predeterminados (~4K tokens para fetch, ~500 por fuente de investigación) para preservar el contexto de la IA
Comando doctor: mcp-research doctor comprueba todas las dependencias y la configuración
Corrección de codificación en Windows: El envoltorio UTF-8 stdout/stderr evita bloqueos cp1252
Esencia de YouTube: Extracción de transcripción, resumen de IA, puntos clave, capítulos, citas
Ingesta profunda: Extracción de texto de PDF, DOCX, XLSX, PPTX, audio, vídeo, imagen
Integración con Ollama: Reescritura de consultas, resumen, síntesis, OCR de visión
Registro de búsqueda: Registro de eventos NDJSON para todas las operaciones
Brave Search: Nivel de búsqueda principal con soporte para clave de API
Lanzamiento inicial: 3 herramientas (web_search, fetch_url, research), protección SSRF, almacenamiento en caché
MIT
Resolve a DOI, ArXiv ID, or PubMed ID. Fetch paper via institutional access if configured in vault.
Args: identifier: DOI (10.xxxx/...), ArXiv ID (2301.12345), PubMed ID (12345678), or publisher URL. fetch_fulltext: Attempt to fetch the full paper text via vault credentials / EZproxy.
| Name | Required | Description | Default |
|---|---|---|---|
| identifier | Yes | ||
| fetch_fulltext | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral context beyond annotations: it mentions attempting to fetch full text via vault credentials/EZproxy, which is a key side effect. Annotations already declare readOnlyHint=true and idempotentHint=true, so there is no contradiction. The description supplements annotations well.
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 front-loaded with the primary purpose, followed by parameter details. It contains no extraneous text. Slightly more structure (e.g., separating args clearly) could improve scannability, but it is already 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?
Given the presence of an output schema, the description appropriately focuses on input behavior. It covers the main use cases and mentions the vault configuration requirement. Minor gaps exist (e.g., what happens if fetch_fulltext fails), but overall it is sufficiently complete for a well-annotated 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?
The input schema has 0% description coverage, so the description must compensate. It explains that 'identifier' can be a DOI, ArXiv ID, PubMed ID, or publisher URL, and that 'fetch_fulltext' defaults to true. This provides necessary semantics that the schema alone lacks.
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 resolves specific academic identifiers (DOI, ArXiv ID, PubMed ID) and optionally fetches full text via institutional access. The verb 'Resolve' and listing of identifier types provide a specific purpose that distinguishes it from siblings like web_search and fetch_url.
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?
It explicitly states when to use the tool (for resolving academic identifiers and fetching papers with vault access). While it does not provide explicit 'when not to use' guidance, the sibling tools offer natural alternatives, and the context is clear enough for an AI agent to infer appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract text from files in a directory or single file. Supports text, PDF, DOCX, XLSX, PPTX, audio, video, images.
Args: path: Directory or file path to process. include_types: Comma-separated type filter (text,pdf,audio,video,image,office). Empty = all. max_files: Maximum files to process (1-5000). summarize: If true, generate an AI summary of the combined content.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | ||
| max_files | No | ||
| summarize | No | ||
| include_types | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations confirm read-only, idempotent, non-destructive behavior. The description adds value by detailing the extraction process (text from various formats) and the optional AI summarization feature, which annotations do not cover.
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: a one-line overview followed by a clean bullet-style Args section. Each sentence serves a purpose, and the essential information is front-loaded.
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 complexity (many file types, 4 parameters, optional summarize), the description sufficiently covers purpose, parameters, and behavior. An output schema exists, so return values need not be detailed.
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 docs (path, include_types, max_files, summarize) with defaults and examples (e.g., 'Comma-separated type filter... Empty = all'). This fully compensates for the schema gap.
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 that the tool extracts text from files (directories or single files), listing supported formats (text, PDF, DOCX, etc.). This distinguishes it from sibling tools like fetch_url (URLs), web_search (web queries), and youtube_essence (YouTube).
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 the tool's scope (local file processing) and supported types, providing clear context. However, it does not explicitly state when not to use it or mention alternatives beyond implied differences from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch a URL, convert to markdown. SSRF-protected and cached.
Args: url: The URL to fetch. summarize: If true and Ollama is available, include a summary. max_chars: Maximum content chars (default ~15K/4K tokens). Set higher for full pages.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| max_chars | No | ||
| summarize | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description adds SSRF protection, caching, and conditional summarization beyond annotations' readOnly/idempotent hints. No contradictions. More details on error handling would improve, but current info is solid.
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: single opening sentence plus a three-line bullet list. No fluff, every sentence adds value. Perfect structure for quick scanning.
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 output schema exists, description doesn't need return details. It covers security (SSRF), caching, and parameter nuances. Missing authentication or error info, but overall adequate for a fetch 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?
With 0% schema description coverage, the description fully explains each parameter: url is the URL, summarize has Ollama condition, max_chars includes default and advice to increase for full pages. Adds significant value beyond 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 'Fetch a URL, convert to markdown' with specific verb and resource. It distinguishes from siblings like web_search and academic_lookup by focusing on fetching a single URL rather than searching or academic data.
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: fetch a specific URL for markdown conversion. It doesn't explicitly compare to siblings but provides enough context (e.g., Ollama availability for summarization) to guide appropriate use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compound research: search → fetch top pages → summarize → synthesize.
Args: query: The research question. depth: Research depth — "quick" (2 pages), "standard" (5 pages), or "deep" (10 pages). context: Optional context from prior research to inform synthesis.
| Name | Required | Description | Default |
|---|---|---|---|
| depth | No | standard | |
| query | Yes | ||
| context | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context: the multi-step process (search, fetch, summarize, synthesize) and the meaning of depth, which goes beyond the annotations.
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 very concise with a front-loaded pipeline overview and bullet points for arguments. Every sentence adds value; 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 that there is an output schema (not shown) and annotations cover safety, the description explains the tool's composite nature, parameter meanings, and pipeline stages. It is complete for an agent to understand and invoke the tool 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 description coverage is 0%, so the description carries full burden. It explains all three parameters: query is the research question, depth with three options, and context as optional prior research. This fully compensates for missing schema descriptions.
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 does 'Compound research: search → fetch top pages → summarize → synthesize', which is a specific verb+resource and distinguishes it from sibling tools like web_search, fetch_url, or academic_lookup that perform only individual steps.
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 the research pipeline and explains the depth parameter with clear options. It implies use for comprehensive research combining multiple steps, but does not explicitly state when not to use or compare directly with siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract tweet or thread from X.com/Twitter. Supports yt-dlp, API, and cookie-based access.
Args: url: Tweet URL (x.com/user/status/id or twitter.com/user/status/id). include_thread: If true, fetch the full conversation thread.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| include_thread | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey read-only, idempotent, and non-destructive behavior. The description adds that it supports multiple access methods, which is useful context beyond annotations, but doesn't detail error handling or rate limits.
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 very concise: two sentences for purpose and two bullet-point args. No wasted words, front-loaded with main 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 only 2 simple params and an output schema (not shown), the description covers the essential behavior and parameter semantics. It's mostly complete, though could mention output format briefly, but output schema covers that.
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 fully compensates by explaining the url format (x.com/user/status/id) and the purpose of include_thread (fetch full thread). Both parameters are clearly described.
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 'Extract' and the resource 'tweet or thread from X.com/Twitter', distinguishing it from siblings like fetch_url by being Twitter-specific.
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 technical details (yt-dlp, API, cookie-based access) but lacks explicit guidance on when to use this tool versus alternatives like fetch_url. No when-not-to-use or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Show credential vault status, loaded profiles, and optional dependency availability. Never exposes secrets.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true. Description adds security assurance 'Never exposes secrets', which is valuable beyond annotations. No contradiction.
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?
Two sentences, front-loaded with purpose, second adds critical security note. Efficient 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?
Zero parameters, good annotations, output schema exists. Description fully covers the tool's behavior and safety. 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?
No parameters, schema coverage 100%. Description adds meaning by specifying what the tool shows (status, profiles, dependencies) beyond the empty 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?
Description uses specific verb 'Show' and resource 'credential vault status', with clear scope including loaded profiles and dependency availability. Distinguishes from siblings by being the only vault-related tool.
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?
Usage context is clear: a status tool to check vault state. No explicit alternatives or exclusions, but the purpose implies when to use. Slight lack of 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 the web using a 3-tier cascade (Brave → DuckDuckGo → scraper).
Args: query: Search query string. max_results: Maximum number of results to return (1-20). summarize: If true and Ollama is available, summarize the results. auto_fetch_top: If true, also fetch the full content of the top result.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| summarize | No | ||
| max_results | No | ||
| auto_fetch_top | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds valuable transparency by revealing the 3-tier cascade (Brave, DuckDuckGo, scraper) and optional Ollama summarization, which are beyond what annotations provide.
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, uses a bullet list for arguments, and front-loads the cascade mechanism. Every sentence provides value without 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 presence of an output schema (not shown but indicated), the description adequately covers input parameters and behavior. It is complete for an AI agent to invoke the tool 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 description coverage is 0%, so the description must explain parameters. It does so effectively: query as search string, max_results (1-20), summarize (if Ollama available), and auto_fetch_top (fetch top result content). This adds substantial meaning beyond the JSON 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 searches the web using a 3-tier cascade, differentiating it from siblings like academic_lookup, fetch_url, and research. The verb 'Search' and resource 'web' are specific, and the cascade detail adds precision.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
While the purpose is clear, the description does not provide explicit guidance on when to use this tool versus alternatives like fetch_url or research. It lacks when-not conditions or comparative context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract essence from a YouTube video: transcript, summary, key points, chapters, quotes.
Args: url: YouTube URL (youtube.com/watch?v=, youtu.be/, youtube.com/shorts/). mode: Extraction depth — "quick" (TL;DR), "standard" (+ chapters), or "deep" (+ quotes).
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| mode | No | standard |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds no behavioral traits beyond these, such as external API dependency or rate limits. Despite annotations covering safety, the description misses contextual details like needing internet access.
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 very concise: a single sentence defining purpose followed by a well-structured Args list. Every sentence is meaningful, and the structure is front-loaded with the core action.
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 nested objects), the description covers purpose, parameters, and output types. It lacks information on error handling or return format, but the existence of an output schema mitigates this. Overall, it is adequately 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?
With 0% schema description coverage, the description fully compensates by explaining the 'url' parameter with allowed formats and the 'mode' parameter with three depth levels and their effects. This adds significant meaning beyond the raw 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 action ('Extract essence') and the resource ('YouTube video'), followed by a list of outputs (transcript, summary, key points, chapters, quotes). This distinguishes it from siblings like twitter_extract or fetch_url which target different sources or actions.
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 clear usage context via parameter explanations (allowed URL formats and mode options). However, it does not explicitly mention when to use this tool over alternatives or exclude scenarios, though the specificity to YouTube serves as implicit guidance.
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. Dates show when Glama detected each change.
v0.1.1academic_lookupdeep_ingestfetch_urlresearchtwitter_extractvault_statusweb_searchyoutube_essencev0.3.0academic_lookupdeep_ingestfetch_url1 field changedInput schema / properties / max_chars / defaultPrevious value: -50000New value: +0twitter_extractvault_statusyoutube_essencev0.1.0fetch_urlresearchweb_searchEach tool targets a distinct source or operation: academic references, local files, URLs, compound research, Twitter, vault status, web search, and YouTube. There is no ambiguity between tools.
Tool names use mixed conventions: verb_noun (fetch_url, web_search), noun_noun (vault_status, youtube_essence), platform_verb (twitter_extract), and single word (research). No consistent pattern.
8 tools is an appropriate scope for a research assistant, covering key sources (web, academic, social media, local files) without being overwhelming.
The toolset covers major research workflows: search, fetch, extract, and synthesize. Minor gaps like result organization or citation management are not critical for core functionality.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Web search, fetch, extract, and research for AI agents. Markdown output + AI-synthesized answers.
Web research for agents: quality-scored Google search, webpage extraction, and deep research.
LLM-ready web search + instant answers + URL-to-clean-text fetch for agents and RAG.
Agent-native search engine with live web research optimized for AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/MABAAM/Maibaamcrawler'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
