Dentro de mcp.llm4agents.com: 67 tools, un endpoint, dos formas de pago

Un endpoint Streamable HTTP. Sesenta y siete tools documentadas en doce familias. Dos formas de pagar cada llamada: una Bearer key contra un balance prepago, o un pago firmado x402 desde un agente que no tiene cuenta. Este es el tour guiado de mcp.llm4agents.com que la mayoría de nuestros usuarios del API nunca recibió.

El patrón que vemos en las conversaciones de soporte es consistente. Un operador conecta el MCP server para una sola cosa — casi siempre fetch_html — y meses después sigue sin saber que el mismo endpoint le habría resuelto otros cuatro problemas que terminó cableando con SaaS externos: una suscripción a un API de búsqueda, un pipeline de embeddings, una cuenta de email transaccional, un servicio de resolución de CAPTCHAs. Los docs del API traen los schemas completos y los precios vigentes; este post es el mapa que te dice qué existe y para qué sirve cada familia.

Un endpoint, dos modos de pago

Todo vive en una sola URL, hablando el transporte Streamable HTTP de MCP en modo JSON response: haces POST de un request JSON-RPC y recibes un objeto JSON de vuelta. Sin stream SSE que administrar, sin baile de sesión para llamadas simples.

MCP Endpoint: https://mcp.llm4agents.com/mcp
Method:       POST
Auth:         Authorization: Bearer YOUR_API_KEY   (o X-PAYMENT para x402 walk-up)
Protocol:     MCP Streamable HTTP (JSON response mode)

Una llamada a tool es el envelope MCP estándar:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "ai_classify",
    "arguments": { "text": "Refund my annual plan", "labels": ["billing", "support", "sales"] }
  }
}

El billing sigue el mismo patrón reserve-settle que las chat completions en el gateway: se reserva el peor caso por adelantado, el costo real se settlea después de la llamada, y el header X-Cost-Usd-Cents te dice exactamente cuánto pagaste. La autenticación es la misma API key que ya usas para /v1/chat/completions — una key, un balance, tokens y tools en el mismo medidor.

El catálogo de un vistazo

Contando lo que la documentación describe hoy, doce familias y 67 tools invocables:

Familia       Tools  Precios ancla (Bearer)
Scraper           6  fetch_html $0.0007 · screenshot $0.0010 · extract $0.0012
Sessions          4  reserva peor-caso, settle real (ver abajo)
Search            4  google_search / news / maps $0.0012 flat · batch ×100
Image             3  generate $0.01–0.02 · edit $0.02 · analyze $0.006
Workspace        10  upload $0.0001/MB · storage ~$0.03/GB-mes
AI                8  embed 0.1¢ · summarize 0.5¢ · classify 1¢ · STT 1.5¢/MB
Notify            6  telegram/discord/slack/webhook 1¢ · email 2¢ · sms 3¢
Data             11  dns/ip gratis · unfurl/rss/whois/crypto/fx/qr 1¢
Vector            3  upsert 0.5¢/100 items · query 1¢ · delete gratis
Web crawl         1  0.5¢/página (mín 2¢), balance-only
Memory            4  set 1¢ (≤64 KB JSON, TTL) · get/list/delete gratis
Web3              4  balance/tx/nft/ens 1¢ · eth, polygon, base, solana
Document          3  pdf_parse 0.5¢/página · doc_extract 0.5¢/unidad · article 1¢

Las operaciones gratuitas — dns_lookup, ip_geolocate, memory_get, vector_delete, los listados de workspace, el polling de resultados de CAPTCHA — están rate-limited a 60 requests por minuto por agente. Todo lo demás factura montos sub-centavo contra el mismo balance en el que corre tu inferencia. Los precios son los defaults documentados hoy y la plataforma se reserva el derecho de cambiarlos; toma los números de este post como anchors, no como contratos.

Scraping: one-shots, tiers de proxy, sesiones

La familia de scraper es la más vieja y la más usada. Seis tools one-shot — fetch_html, markdown, links, screenshot, pdf, extract — cada una abre un browser headless, hace una cosa y lo cierra. Todas aceptan un parámetro proxy_tier: none, datacenter o residential, con precio acorde ($0.0007 a $0.0042 por llamada según tool y tier). Con auto_fallback: true, un fetch fallido escala por la cadena none → datacenter → residential, y se te factura al tier que efectivamente devolvió la página — no al que pediste.

Cuando un solo shot no alcanza — muros de login, formularios multi-paso, cualquier cosa donde la página dos depende de lo que hiciste en la página uno — subes a una sesión. Cuatro tools manejan el ciclo de vida: session_create, session_exec, session_status, session_close. Una sesión mantiene el browser vivo hasta cinco minutos y cincuenta acciones, con dos sesiones concurrentes por agente. El costo se reserva al peor caso cuando la creas y se settlea al uso real al cerrarla:

// session_close devuelve la realidad settleada
{ "duration_ms": 45000, "actions_count": 12, "cost_cents": 1.74 }

Los anchors documentados te dan una idea del rango: una sesión de 30 segundos con 3 acciones settlea alrededor de $0.009 sin proxy, mientras que una sesión al máximo — cinco minutos, 50 acciones, proxy residential — llega cerca de $0.099. Los otros límites que vale memorizar: timeout de 30 segundos por llamada a tool dentro de una sesión, payload máximo de 5 MB, y el tope de dos sesiones concurrentes, que además funciona como control de radio de daño si un agente se sale del guion.

La regla práctica: tres o más interacciones de página contra el mismo origen, usa una sesión. Por debajo de eso, los one-shots son más baratos y más simples.

Search, imágenes y las primitivas de Workers AI

Tres tools de búsqueda — google_search, google_news, google_maps — devuelven resultados estructurados a $0.0012 flat por llamada, sin browser de por medio. La joya escondida es google_batch_search: hasta 100 queries en una sola llamada a $0.0012 cada una, un round trip HTTP en lugar de cien. Un agente de research que despliega veinte variaciones de query paga 2.4 centavos y recibe todo en una sola respuesta.

Las tres comparten la misma superficie de parámetros: gl y hl para país e idioma, location como pista geográfica, paginación, y filtros de fecha tbs — qdr:h, qdr:d, qdr:w para última hora, día, semana. Ese último es el que convierte a google_news en una primitiva de monitoreo: un cron nocturno que batchea cincuenta queries qdr:d cuesta seis centavos y cubre un panorama competitivo entero.

La familia de imagen cubre el loop generativo: generate_image ($0.01 hasta 1.5 megapíxeles, $0.02 por encima), edit_image ($0.02 flat) y analyze_image ($0.006), esta última un Q&A con modelo de visión sobre cualquier URL o imagen en base64.

La familia AI son ocho primitivas de inferencia respaldadas por Cloudflare Workers AI: ai_summarize y ai_translate a 0.5¢, ai_embed a 0.1¢ para vectores de 768 dimensiones, ai_classify, ai_moderate y ai_rerank a 1¢, image_to_text a 2¢, y speech_to_text — Whisper, medido a 1.5¢ por MB de audio. El punto de estas tools es económico, y es el mismo que hicimos en el post de economía de flotas: un agente no debería gastar tokens de modelo frontier en transformaciones mecánicas. Clasificar un ticket de soporte con ai_classify cuesta un centavo fijo; hacerlo dentro de un contexto de Claude cuesta lo que cueste la conversación circundante, cada vez.

Los límites de batch son lo bastante generosos como para importar: ai_embed acepta hasta 100 strings por llamada, ai_rerank puntúa hasta 100 documentos candidatos contra una query, y ai_classify toma hasta 20 labels candidatos. Un pipeline de retrieval que embebe cien chunks paga 0.1¢ — una vez — por el lote entero.

La columna vertebral RAG: workspace, documentos, vector, memoria

Cuatro familias componen un pipeline de retrieval completo sin vendor externo.

El workspace es un almacén de archivos privado por agente respaldado por Cloudflare R2: diez tools que cubren upload (inline hasta 10 MB, o un flujo init/finalize con presigned PUT de un solo uso para todo lo más grande), download, copy, extend y ciclo de vida. El storage sale alrededor de $0.03 por GB-mes. Una decisión de diseño que conviene conocer antes de construir encima: las URLs directas de R2 nunca se exponen. Las descargas pasan por el worker de la plataforma como tokens de un solo uso — el segundo hit a la misma URL devuelve 410. Eso hace que una URL de workspace sea segura para entregarle a un usuario final como link de citación sin crear un artefacto público permanente.

Los docs publican ejemplos trabajados que vale la pena internalizar, porque las tarifas por MB son tan chicas que confunden: subir 1 MB por un día pega contra el mínimo de 1¢ que aplica a todas las operaciones pagas de workspace; 100 MB almacenados 30 días salen alrededor de $0.03; un GB completo por un mes ronda los $0.14, y descargar ese GB de vuelta cuesta cerca de $0.05. Para artefactos de agente — salidas de scraping, reportes generados, screenshots — el workspace es efectivamente gratis; el mínimo es el precio que realmente pagas.

Las tools de document convierten archivos en texto: pdf_parse (0.5¢ por página, leyendo desde un archivo de workspace o una URL), doc_extract para docx/xlsx/csv, y article_extract para markdown modo-lector de cualquier artículo web. El vector store es Cloudflare Vectorize por debajo, con embeddings bge de 768 dimensiones: vector_upsert auto-embebe texto a 0.5¢ por 100 items, vector_query corre una búsqueda de similitud con filtros de metadata a 1¢. Y memory es un store key-value para estado durable del agente: memory_set guarda hasta 64 KB de JSON con TTL opcional a 1¢ por escritura; las lecturas son gratis.

Los filtros de metadata en vector_query son la historia multi-tenant: una estructura de corpus, un agente, con cada query scopeada a { tenant: customer_id } al momento del retrieval. En plataformas que sueldan storage y retrieval juntos, ese aislamiento lo construyes tú; acá es un argumento de filtro.

El camino completo de ingesta, de punta a punta:

await mcp.workspace_upload({ filename: 'handbook.pdf', content_base64, days_to_store: 90 });
const parsed = await mcp.pdf_parse({ workspace_file: 'handbook.pdf' });
await mcp.vector_upsert({ items: chunk(parsed.text).map((text, i) => ({ id: `hb-${i}`, text })) });

// al momento de responder, el modelo llama esto solo si está en la allowlist
await mcp.vector_query({ query: 'refund policy on annual plans', top_k: 5 });

También existe web_crawl, un crawler de sitios breadth-first con límites de páginas y profundidad que puede renderizar JavaScript y guardar su salida — markdown concatenado o un mapa de links — directo en el workspace, a 0.5¢ por página crawleada. Ingestar un sitio de documentación a un corpus RAG es una sola llamada.

Notify, utilidades de datos y lecturas web3

La familia notify cierra el loop con humanos: send_telegram, send_discord, send_slack y webhook_post a 1¢ (tú aportas el bot token o la webhook URL), send_email a 2¢ y send_sms a 3¢ a través de los proveedores propios de la plataforma. Un detalle que importa para cualquiera que corra prompts no confiables: webhook_post está protegido contra SSRF — los requests a rangos de direcciones privadas, loopback y link-local se rechazan antes de cualquier llamada saliente. Un agente comprometido por prompt injection no puede usarlo para sondear tu red interna.

La familia data son once utilidades chicas que los agentes de otro modo reimplementan mal: dns_lookup e ip_geolocate gratis, más url_unfurl, rss_parse, youtube_transcript, whois, crypto_price, fx_convert y qr_generate a 1¢ cada una, y un par asíncrono de CAPTCHA — captcha_solve_create a 2¢ envía una tarea para reCAPTCHA v2, hCaptcha o Turnstile, y captcha_solve_result la pollea gratis.

La familia web3 es deliberadamente aburrida, y esa es su feature: token_balance, tx_status, nft_metadata y ens_resolve son lookups read-only en Ethereum, Polygon, Base y Solana a 1¢ cada uno. Estas tools nunca firman ni envían transacciones. Un agente que necesita verificar que un pago on-chain llegó puede consultar tx_status sin que nadie tenga que entregarle una key.

Bearer vs x402: el diez por ciento, y las excepciones

Casi todas las tools pagas aceptan dos modos de pago. El modo Bearer debita tu balance prepago — la experiencia de developer clásica. El modo x402 walk-up deja que un agente sin cuenta pague por llamada con una autorización de stablecoin firmada, y cada precio walk-up está 10 por ciento por debajo del precio Bearer: 1¢ se vuelve 0.9¢, el 0.1¢ de ai_embed se vuelve 0.09¢, el 1.5¢/MB de Whisper se vuelve 1.35¢/MB. Tres tools son balance-only y no aceptan x402: web_crawl, pdf_parse y doc_extract.

El flujo walk-up es fácil de ver en vivo, porque el server se lo cotiza a cualquiera. Envía un request sin autenticación al endpoint y recibes HTTP 402 con un header payment-required; decodifícalo de base64 y esto es lo que volvió cuando hicimos exactamente eso mientras escribíamos este post:

$ curl -i -X POST https://mcp.llm4agents.com/mcp -d '{"jsonrpc":"2.0", ...}'
HTTP/2 402

// header payment-required, decodificado:
{
  "x402Version": 2,
  "accepts": [{
    "scheme": "exact",
    "network": "eip155:8453",                                  // Base mainnet
    "amount": "10000",                                          // $0.01 en unidades USDC de 6 decimales
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",      // USDC en Base
    "payTo": "0x0D741Ab0968906f8338C60f79b81B49c23258C12",
    "maxTimeoutSeconds": 300,
    "extra": { "name": "USD Coin", "version": "2" }         // dominio EIP-712
  }]
}

Cada campo está haciendo trabajo. El asset es el contrato canónico de USDC en Base. El bloque extra es el dominio de firma EIP-712 que el cliente necesita para construir un transferWithAuthorization de ERC-3009 válido: un mensaje firmado con un nonce aleatorio de 32 bytes y una ventana validAfter/validBefore, que es la razón por la que la cotización lleva un timeout de 300 segundos. El agente firma, reintenta el request con la autorización en el header X-PAYMENT, y la llamada se ejecuta — sin cuenta, sin balance, sin relación previa. La mecánica es el estándar x402, hoy un proyecto de la Linux Foundation, y el walkthrough completo está en nuestro deep dive de x402.

Sesenta y siete tools son una superficie de ataque

Un modelo que puede ver 67 tools puede ser convencido de llamar 67 tools. La amenaza no es teórica — la prompt injection indirecta vía páginas scrapeadas es exactamente el input que este server procesa todo el día. La disciplina, sin cambios desde nuestro post de threat model, es minimización de scope: pasa una allowlist para que cada agente vea solo lo que su trabajo requiere.

const conv = client.chat.conversation({
  model: 'anthropic/claude-sonnet-4.6',
  system: '...',
  tools: {
    mcp: {
      url: 'https://mcp.llm4agents.com/mcp',
      // agente de research: leer la web, armar el corpus — nada más
      allow: ['google_search', 'google_batch_search', 'markdown',
              'article_extract', 'vector_upsert', 'vector_query'],
    },
  },
});

Un agente de triage recibe memory_set, memory_get, ai_classify, send_email y nada más. Nada de tools de notify en nada que lea input no confiable, salvo que el destino de la notificación esté fijado. Los límites del lado de la plataforma ayudan — guardas SSRF en webhook_post, web3 read-only, dos sesiones concurrentes, llamadas gratuitas rate-limited — pero la allowlist es el control que te pertenece.

Qué hay en el roadmap

Tres tools están planificadas pero no en vivo: code_exec (ejecución de código sandboxeada), schedule_task (corridas diferidas y recurrentes) y semantic_memory (memoria basada en retrieval más allá del store key-value). Junto a ellas, el flujo visual de Agent Builder y Agent Cron siguen en desarrollo, como anotamos en el runbook de migración. Hasta que salgan, los sustitutos funcionales son los que los operadores ya usan: schedulers externos para cron, memory_set más vector_query para memoria. No construyas contra items de roadmap; construye contra las 67 que responden hoy.

Qué significa para LLM4Agents

El MCP server es la segunda pierna de la plataforma, y estructuralmente es la más interesante. El gateway vende tokens; el MCP server vende acciones. Ambos corren sobre la misma key, el mismo balance, el mismo billing reserve-settle, los mismos headers de costo. Esa composición es lo que separa una plataforma de agentes de un revendedor de modelos: el agente que razona en el gateway y actúa a través del MCP server nunca sale del perímetro de billing, y por eso la contabilidad de costo por tarea — el número que el operador realmente administra — se mantiene coherente.

El carril x402 es la apuesta estratégica. Cada tool de este server es individualmente pagable por máquina por cualquier agente de internet que tenga una wallet — sin signup, sin emisión de API key, sin relación de facturación. Cuando argumentamos que los pagos machine-to-machine son el sustrato de la economía agéntica, este catálogo es el argumento desplegado: más de 60 endpoints con precio donde la relación comercial entera es un HTTP 402 y una firma.

Cómo mantenerse en la frontera

Lo que este catálogo necesita a continuación, en orden:

1. Shipear las tres tools del roadmap. code_exec, schedule_task y semantic_memory son los huecos que los operadores hoy salen de la plataforma a llenar, y cada salida arrastra parte del workload a infraestructura que no medimos.
2. Hacer el catálogo descubrible sin pagar. Hoy un tools/list sin autenticación devuelve 402. Un catálogo gratuito y machine-readable con precios — y un llms.txt en el dominio MCP — dejaría que los agentes walk-up presupuesten una tarea antes de gastar un centavo, que es exactamente el comportamiento que deberíamos premiar.
3. Mover las allowlists al lado del server. Scopear tools en la config del cliente es disciplina; scopearlas a nivel de API key es enforcement. Keys que solo pueden llamar su allowlist achican el radio de daño tanto de la prompt injection como de las credenciales filtradas.
4. Adoptar la extensión Tasks de MCP cuando aterrice. El release candidate 2026-07-28 formaliza las operaciones de larga duración — un fit natural para web_crawl, los solves de CAPTCHA y las futuras corridas de code_exec que sobreviven al ciclo de un request.
5. Caps de gasto por tool y alertas de anomalía. Reserve-settle hace que cada llamada sea individualmente contabilizable; la capa que falta es el presupuesto de cara al operador que frena a un agente en loop en el generate_image número 50, no en el 5,000.