Tus agentes pagan de más por cada llamada a la API. Nosotros lo solucionamos.
Hebline dirige cada llamada a la API —incluyendo las llamadas a LLM— al mejor servicio al precio correcto. Gratis cuando es suficiente. De pago cuando importa. Sabe distinguir la diferencia.
Cualquier otro enrutador obtiene un margen de tus llamadas de pago. Dirigirte a alternativas gratuitas acaba con sus ingresos. Sin margen en tus llamadas a la API. Nunca.
Tus agentes están perdiendo dinero. Una tarea activa entre 5 y 10 llamadas a la API de pago a través de diferentes proveedores. Sin transparencia, sin control de costes. Hebline soluciona eso:
Prioriza lo gratuito — La mayoría de las llamadas no necesitan el mejor modelo. Hebline aprende con precisión cuándo es necesario, y sigue aprendiendo a medida que cambia el mercado.
Sin margen. Enrutamiento honesto. — No ganamos cuando tú pagas más. Por eso somos el único enrutador diseñado para ahorrarte dinero realmente.
Abstracción de proveedores — Tu agente dice qué necesita ("geocodifica esta dirección"), no qué servicio usar. Cambia de proveedor sin modificar el código del agente.
Transparencia de costes — Cada llamada se registra con el servicio utilizado, la latencia y el coste. Conoce exactamente lo que gastan tus agentes.
Aprende del uso — El aprendizaje hebbiano refuerza lo que funciona y debilita lo que no. Tu intermediario se vuelve más inteligente cada día.
BYOK (Trae tu propia clave) — Los servicios de pago utilizan tus claves de API a través de variables de entorno. ¿No tienes clave? El servicio se excluye automáticamente del enrutamiento.
Cumplimiento con el RGPD — Solo se registran metadatos anonimizados. No se almacena el contenido de las llamadas a la API. Opción de alojamiento propio para que ningún dato salga de tu red.
Código abierto — El servidor MCP principal tiene licencia MIT. Sistema de adaptadores impulsado por la comunidad.
Related MCP server: Clawy MCP Server
Your AI Agent ←→ Hebline MCP Server ←→ Best API (Nominatim, DeepL, Google Maps, ...)
│
Smart Routing
Cost Logging
Provider ScoringTu agente se conecta a Hebline como un servidor MCP. En lugar de llamar a las APIs directamente, utiliza las herramientas de Hebline: execute, compare o categories. Hebline puntúa todos los servicios disponibles, elige el mejor, realiza la llamada y devuelve el resultado con metadatos completos.
Herramienta | Descripción |
| Dirige al mejor servicio y realiza la llamada a la API. Devuelve el resultado + metadatos (servicio, coste, latencia). |
| Muestra todos los servicios disponibles para una capacidad con puntuaciones. Mira qué hay disponible antes de comprometerte. |
| Lista todas las capacidades compatibles y sus servicios. |
Añadir a claude_desktop_config.json:
{
"mcpServers": {
"hebline": {
"command": "npx",
"args": ["-y", "-p", "@hebline.ai/mcp-server", "hebline-mcp"]
}
}
}Añadir a .mcp.json:
{
"mcpServers": {
"hebline": {
"command": "hebline-mcp"
}
}
}Añadir a .cursor/mcp.json:
{
"mcpServers": {
"hebline": {
"command": "npx",
"args": ["-y", "-p", "@hebline.ai/mcp-server", "hebline-mcp"]
}
}
}Añadir a ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"hebline": {
"command": "npx",
"args": ["-y", "-p", "@hebline.ai/mcp-server", "hebline-mcp"]
}
}
}Añadir a .vscode/mcp.json:
{
"servers": {
"hebline": {
"type": "stdio",
"command": "npx",
"args": ["-y", "-p", "@hebline.ai/mcp-server", "hebline-mcp"]
}
}
}npm install -g @hebline.ai/mcp-serverEstablece variables de entorno para cualquier proveedor de pago que desees utilizar:
GOOGLE_MAPS_API_KEY=your-key-here
DEEPL_API_KEY=your-key-here
LIBRETRANSLATE_API_KEY=your-key-here¿Sin claves? No hay problema: Hebline dirige automáticamente a alternativas gratuitas.
Categoría | Gratis | De pago (BYOK) |
LLMs | Groq (Llama 3.3 70B), Google Gemini Flash | OpenAI GPT-4o-mini ( |
Geocodificación | Nominatim (OpenStreetMap) | Google Maps ( |
Traducción | MyMemory | DeepL ( |
Web Scraping | Fetch Scraper | Firecrawl ( |
Divisas | ExchangeRate-API | Fixer.io ( |
OCR | OCR.space | Google Vision ( |
Clima | Open-Meteo | OpenWeatherMap ( |
Búsqueda web | DuckDuckGo | Brave Search ( |
Noticias | HackerNews | NewsAPI.org ( |
9 categorías, 20 servicios. Los servicios gratuitos funcionan al instante, no se necesita clave de API. Los LLMs se dirigen a través del proxy de Hebline cuando no hay una clave local configurada (50 llamadas gratuitas/día).
Un agente pregunta: "Geocodifica la Puerta de Brandeburgo en Berlín"
Hebline recibe:
{
"capability": "geocoding",
"input": { "query": "Brandenburger Tor, Berlin" },
"constraint": "free"
}Hebline responde:
{
"success": true,
"data": {
"lat": 52.5163,
"lon": 13.3777,
"displayName": "Brandenburger Tor, Pariser Platz, Berlin, 10117, Deutschland"
},
"meta": {
"service": "Nominatim (OpenStreetMap)",
"costUsd": 0,
"latencyMs": 258,
"score": 0.702,
"free": true
}
}El agente obtuvo las coordenadas, sabe que fue gratuito y Hebline registró la llamada para análisis futuros.
mcp-server/
├── src/
│ ├── index.ts # MCP server entry point (stdio transport)
│ ├── types.ts # Shared TypeScript types
│ ├── registry.ts # Service definitions (capabilities, costs, scores)
│ ├── router.ts # Weighted scoring engine (Hopfield-ready)
│ ├── logger.ts # Append-only JSONL call log (~/.hebline/calls.jsonl)
│ ├── adapters/ # One adapter per service
│ │ ├── nominatim.ts # Free geocoding
│ │ ├── google-maps.ts # Paid geocoding (BYOK)
│ │ ├── mymemory.ts # Free translation
│ │ ├── libretranslate.ts # Paid translation (BYOK)
│ │ └── deepl.ts # Paid translation (BYOK)
│ └── tools/ # MCP tool definitions
│ ├── execute.ts # Route + call best service
│ ├── compare.ts # Score all services
│ └── categories.ts # List capabilitiesCada llamada a la API se registra en ~/.hebline/calls.jsonl:
{"timestamp":"2026-03-29T09:36:37Z","capability":"geocoding","serviceId":"nominatim","latencyMs":212,"success":true,"costUsd":0}No se registra contenido, solo metadatos. Estos datos impulsarán el aprendizaje hebbiano en futuras versiones.
[x] Servidor MCP principal con transporte stdio
[x] Enrutador de puntuación ponderada
[x] Adaptadores de geocodificación (Nominatim, Google Maps)
[x] Adaptadores de traducción (MyMemory, LibreTranslate, DeepL)
[x] Gestión de claves BYOK
[x] Registro de llamadas de solo adición
[x] CI/CD con GitHub Actions
[ ] Aprendizaje hebbiano: el enrutador aprende del historial de llamadas
[ ] Puntuación de red de Hopfield (reemplaza la puntuación ponderada)
[ ] Más categorías (web scraping, divisas, OCR, correo electrónico)
[ ] Sistema de adaptadores de la comunidad
[ ] Transporte SSE para despliegues remotos
[ ] Panel web para análisis de costes
[ ] Alertas de presupuesto y límites de gasto
[ ] Atribución de costes multi-agente
¡Las contribuciones son bienvenidas! Añadir un nuevo adaptador es sencillo: implementa la interfaz ServiceAdapter y regístralo.
git clone https://github.com/hebline/mcp-server.git
cd mcp-server
npm install
npm run build
npm testCreado por Hebline — Prioriza lo gratuito. Solo paga cuando sea necesario.
List all capabilities Hebline supports and which services are available for each.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only operation ('List'), but doesn't specify whether it requires authentication, has rate limits, returns structured data, or involves pagination. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without fluff. It's front-loaded with the core action ('List') and resource, making it easy to parse. Every word contributes to understanding, achieving ideal conciseness.
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 (0 parameters, no output schema), the description is adequate but not fully complete. It explains what the tool does but lacks details on return format, error handling, or behavioral constraints. With no annotations to fill gaps, it meets minimum viability but leaves room for improvement in guiding agent usage.
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 schema description coverage is 100%, so there are no parameters to document. The description doesn't need to compensate for missing param info. A baseline of 4 is appropriate as it avoids redundancy and focuses on the tool's purpose without unnecessary parameter details.
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: 'List all capabilities Hebline supports and which services are available for each.' It uses specific verbs ('List') and identifies the resource ('capabilities Hebline supports'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools (compare, execute), which prevents a perfect score.
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 no guidance on when to use this tool versus alternatives like 'compare' or 'execute'. It doesn't mention prerequisites, timing, or contextual triggers. While the purpose is clear, the lack of comparative or conditional guidance limits its utility for an agent deciding between tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compare all available services for a capability. Shows scores, costs, and Hebline's recommendation.
| Name | Required | Description | Default |
|---|---|---|---|
| capability | Yes | Capability to compare services for, e.g. 'geocoding', 'translation' | |
| constraint | No | Cost constraint filter | any |
| region | No | Region filter, e.g. 'eu', 'us' |
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 mentions outputs (scores, costs, recommendation) but lacks details on behavioral traits such as data freshness, rate limits, authentication needs, or error handling. This is inadequate for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the purpose. It could be slightly more structured by separating key points, but it avoids redundancy and wastes no 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 complexity (comparison with multiple outputs), lack of annotations, and no output schema, the description is incomplete. It hints at outputs but doesn't detail format or behavior, leaving gaps for the agent to handle mutations or errors.
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 fully documents all three parameters. The description adds no additional meaning beyond what the schema provides, such as examples or constraints not in the schema, meeting the baseline for high coverage.
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 'compare' and the resource 'all available services for a capability', with specific outputs mentioned ('scores, costs, and Hebline's recommendation'). It distinguishes from sibling tools 'categories' and 'execute' by focusing on comparison rather than listing or execution.
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 guidance is provided on when to use this tool versus alternatives like 'categories' or 'execute'. The description implies usage for comparing services but doesn't specify scenarios, prerequisites, or exclusions, leaving the agent to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Route to the best service and execute the API call. Returns result with metadata (service used, cost, latency).
| Name | Required | Description | Default |
|---|---|---|---|
| capability | Yes | What you need, e.g. 'geocoding', 'translation' | |
| input | Yes | Service-specific input (e.g. { query: 'Berlin' } for geocoding, { text: 'Hello', target: 'de' } for translation) | |
| constraint | No | Cost constraint: 'free' = only free services, 'cheapest' = prefer lowest cost, 'any' = best overall | any |
| region | No | Preferred region, e.g. 'eu', 'us'. Omit for global. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions that the tool returns 'result with metadata (service used, cost, latency)', which adds some behavioral context. However, it lacks details on permissions, rate limits, error handling, or side effects, which are important for a tool that executes API calls and routes services.
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 and front-loaded: it states the core purpose in the first clause and adds return details in parentheses. Every sentence earns its place with no wasted words, making it 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?
Given the tool's complexity (executes API calls with routing) and lack of annotations/output schema, the description is moderately complete. It covers the purpose and return metadata, but gaps remain in behavioral details and usage guidelines. It's adequate but has clear room for improvement in 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?
Schema description coverage is 100%, so the schema already documents all parameters. The description adds no additional meaning beyond what the schema provides (e.g., it doesn't explain parameter interactions or usage examples). Baseline is 3 when schema coverage is high and description doesn't compensate.
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: 'Route to the best service and execute the API call.' It specifies the action (route and execute) and resource (API call), but doesn't distinguish it from sibling tools like 'categories' or 'compare' which have different purposes. The description is specific but lacks sibling differentiation.
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 no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools or other contexts, and offers no explicit when/when-not scenarios. Usage is implied (e.g., for API calls with routing), but no clear alternatives or exclusions are stated.
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.9.1categoriescompareexecuteScored across 3 tools
Each tool has a clearly distinct purpose with no overlap: 'categories' lists capabilities and services, 'compare' analyzes service options with recommendations, and 'execute' routes and runs API calls. The separation between listing, comparing, and executing is unambiguous.
All tool names follow a consistent verb-only pattern in lowercase, with no mixing of conventions. The naming is straightforward and predictable across the set.
Three tools is well-scoped for the server's purpose of managing and executing API services through Hebline. Each tool earns its place by covering a distinct phase: discovery, comparison, and execution.
The tool set provides complete coverage for the domain: it allows agents to discover capabilities, compare service options, and execute calls with metadata. There are no obvious gaps in the workflow from start to finish.
AI model routing on your own vendor keys: pick the best model per prompt, or route and run it.
AI service marketplace — agents discover, call, and pay for API services automatically.
Stripe-native marketplace where AI agents discover and pay per call for API services.
AI routing, memory, guardrails, and governance. Routes across Claude, GPT, Gemini.
