Deine Agenten zahlen bei jedem API-Aufruf zu viel. Wir ändern das.
Hebline leitet jeden API-Aufruf – einschließlich LLM-Aufrufen – an den besten Dienst zum richtigen Preis weiter. Kostenlos, wenn es ausreicht. Kostenpflichtig, wenn es darauf ankommt. Er kennt den Unterschied.
Jeder andere Router verdient an deinen kostenpflichtigen Aufrufen mit. Dich zu kostenlosen Alternativen zu leiten, würde deren Umsatz schmälern. Keine Marge auf deine API-Aufrufe. Niemals.
Deine Agenten verschwenden Geld. Eine Aufgabe löst 5–10 kostenpflichtige API-Aufrufe bei verschiedenen Anbietern aus. Keine Transparenz, keine Kostenkontrolle. Hebline behebt das:
Zuerst kostenlos routen — Die meisten Aufrufe benötigen nicht das beste Modell. Hebline lernt genau, wann es darauf ankommt – und lernt weiter, während sich der Markt verändert.
Keine Marge. Ehrliches Routing. — Wir verdienen nichts, wenn du mehr bezahlst. Deshalb sind wir der einzige Router, der wirklich darauf ausgelegt ist, dir Geld zu sparen.
Anbieter-Abstraktion — Dein Agent sagt, was er braucht („Geokodiere diese Adresse“), nicht welchen Dienst er nutzen soll. Wechsle die Anbieter, ohne den Agenten-Code zu ändern.
Kostentransparenz — Jeder Aufruf wird mit dem verwendeten Dienst, der Latenz und den Kosten protokolliert. Wisse genau, was deine Agenten ausgeben.
Lernt aus der Nutzung — Hebbian Learning stärkt, was funktioniert, und schwächt, was nicht funktioniert. Dein Broker wird jeden Tag intelligenter.
BYOK (Bring Your Own Key) — Kostenpflichtige Dienste nutzen deine API-Schlüssel über Umgebungsvariablen. Kein Schlüssel? Der Dienst wird automatisch vom Routing ausgeschlossen.
DSGVO-konform — Nur anonymisierte Metadaten werden protokolliert. Kein Inhalt der API-Aufrufe wird gespeichert. Selbst gehostete Option, damit keine Daten dein Netzwerk verlassen.
Open Source — Der Kern-MCP-Server ist MIT-lizenziert. Community-gesteuertes Adaptersystem.
Related MCP server: Clawy MCP Server
Your AI Agent ←→ Hebline MCP Server ←→ Best API (Nominatim, DeepL, Google Maps, ...)
│
Smart Routing
Cost Logging
Provider ScoringDein Agent verbindet sich mit Hebline als MCP-Server. Anstatt APIs direkt aufzurufen, nutzt er die Tools von Hebline – execute, compare oder categories. Hebline bewertet alle verfügbaren Dienste, wählt den besten aus, führt den Aufruf durch und gibt das Ergebnis mit vollständigen Metadaten zurück.
Tool | Beschreibung |
| Zum besten Dienst routen und den API-Aufruf tätigen. Gibt Ergebnis + Metadaten (Dienst, Kosten, Latenz) zurück. |
| Alle verfügbaren Dienste für eine Funktion mit Bewertungen anzeigen. Siehe, was verfügbar ist, bevor du dich entscheidest. |
| Alle unterstützten Funktionen und deren Dienste auflisten. |
Zu claude_desktop_config.json hinzufügen:
{
"mcpServers": {
"hebline": {
"command": "npx",
"args": ["-y", "-p", "@hebline.ai/mcp-server", "hebline-mcp"]
}
}
}Zu .mcp.json hinzufügen:
{
"mcpServers": {
"hebline": {
"command": "hebline-mcp"
}
}
}Zu .cursor/mcp.json hinzufügen:
{
"mcpServers": {
"hebline": {
"command": "npx",
"args": ["-y", "-p", "@hebline.ai/mcp-server", "hebline-mcp"]
}
}
}Zu ~/.codeium/windsurf/mcp_config.json hinzufügen:
{
"mcpServers": {
"hebline": {
"command": "npx",
"args": ["-y", "-p", "@hebline.ai/mcp-server", "hebline-mcp"]
}
}
}Zu .vscode/mcp.json hinzufügen:
{
"servers": {
"hebline": {
"type": "stdio",
"command": "npx",
"args": ["-y", "-p", "@hebline.ai/mcp-server", "hebline-mcp"]
}
}
}npm install -g @hebline.ai/mcp-serverSetze Umgebungsvariablen für alle kostenpflichtigen Anbieter, die du nutzen möchtest:
GOOGLE_MAPS_API_KEY=your-key-here
DEEPL_API_KEY=your-key-here
LIBRETRANSLATE_API_KEY=your-key-hereKeine Schlüssel? Kein Problem – Hebline leitet automatisch zu kostenlosen Alternativen weiter.
Kategorie | Kostenlos | Kostenpflichtig (BYOK) |
LLMs | Groq (Llama 3.3 70B), Google Gemini Flash | OpenAI GPT-4o-mini ( |
Geokodierung | Nominatim (OpenStreetMap) | Google Maps ( |
Übersetzung | MyMemory | DeepL ( |
Web Scraping | Fetch Scraper | Firecrawl ( |
Währung | ExchangeRate-API | Fixer.io ( |
OCR | OCR.space | Google Vision ( |
Wetter | Open-Meteo | OpenWeatherMap ( |
Websuche | DuckDuckGo | Brave Search ( |
Nachrichten | HackerNews | NewsAPI.org ( |
9 Kategorien, 20 Dienste. Kostenlose Dienste funktionieren sofort – kein API-Schlüssel erforderlich. LLMs werden über den Hebline-Proxy geleitet, wenn kein lokaler Schlüssel gesetzt ist (50 kostenlose Aufrufe/Tag).
Ein Agent fragt: "Geokodiere das Brandenburger Tor in Berlin"
Hebline empfängt:
{
"capability": "geocoding",
"input": { "query": "Brandenburger Tor, Berlin" },
"constraint": "free"
}Hebline antwortet:
{
"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
}
}Der Agent hat die Koordinaten erhalten, weiß, dass es kostenlos war, und Hebline hat den Aufruf für zukünftige Analysen protokolliert.
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 capabilitiesJeder API-Aufruf wird in ~/.hebline/calls.jsonl protokolliert:
{"timestamp":"2026-03-29T09:36:37Z","capability":"geocoding","serviceId":"nominatim","latencyMs":212,"success":true,"costUsd":0}Es werden keine Inhalte protokolliert – nur Metadaten. Diese Daten werden in zukünftigen Versionen das Hebbian Learning antreiben.
[x] Kern-MCP-Server mit stdio-Transport
[x] Gewichteter Bewertungs-Router
[x] Geokodierungs-Adapter (Nominatim, Google Maps)
[x] Übersetzungs-Adapter (MyMemory, LibreTranslate, DeepL)
[x] BYOK-Schlüsselverwaltung
[x] Nur-Anhängen-Aufrufprotokollierung
[x] CI/CD mit GitHub Actions
[ ] Hebbian Learning — Router lernt aus der Aufrufhistorie
[ ] Hopfield-Netzwerk-Bewertung (ersetzt gewichtete Bewertung)
[ ] Weitere Kategorien (Web Scraping, Währung, OCR, E-Mail)
[ ] Community-Adaptersystem
[ ] SSE-Transport für Remote-Bereitstellungen
[ ] Web-Dashboard für Kostenanalysen
[ ] Budget-Warnungen und Ausgabenlimits
[ ] Multi-Agenten-Kostenzuordnung
Beiträge sind willkommen! Das Hinzufügen eines neuen Adapters ist unkompliziert – implementiere das ServiceAdapter-Interface und registriere es.
git clone https://github.com/hebline/mcp-server.git
cd mcp-server
npm install
npm run build
npm testErstellt von Hebline — Zuerst kostenlos routen. Nur bezahlen, wenn es notwendig ist.
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.
