MCP-Server

MCP-Server für KI-Telefonie: Lass deinen KI-Agenten telefonieren

Der MCP-Server von anicall.io unter https://api.anicall.io/mcp gibt KI-Agenten wie Claude, Cursor oder deinem eigenen Agenten 22 Werkzeuge, um Telefonagenten zu steuern: Anrufe starten und auswerten, Wissenslücken schließen und Anruflisten anlegen – mit Freigabe-Tor und nur mit den Rechten deines API-Schlüssels.

Zur API-Dokumentation

Stand: November 2026

Auf einen Blick

Server-URL: https://api.anicall.io/mcp
Transport: Streamable HTTP · JSON-RPC 2.0
Anmeldung: Authorization: Bearer anc_live_…
Werkzeuge: 22 – gefiltert nach den Rechten deines Schlüssels

Was ist ein MCP-Server für Telefonie?

Ein MCP-Server übersetzt das Model Context Protocol in echte Aktionen – bei anicall.io sind das Telefonate, Wissenspflege und Auswertungen deiner KI-Telefonagenten.

Telefonie-Schicht für KI-Agenten

Dein KI-Agent muss keine Telefonie, Spracherkennung oder Rufnummern kennen. Er ruft Werkzeuge wie start_call oder list_calls auf, anicall.io erledigt den Rest.

Gleiche Rechte wie die API

Jedes Werkzeug ruft intern die REST-API v2 auf. Der Schlüssel bestimmt, welche Werkzeuge dein Agent überhaupt sieht – nicht freigegebene erscheinen gar nicht erst.

Der Mensch bleibt im Loop

Anruflisten starten erst, wenn ein namentlich genannter Mensch sie freigibt. Werkzeuge, die echte Anrufe auslösen, sind für deinen KI-Client als destruktiv markiert.

Wofür du den MCP-Server nutzt

Typische Einsätze sind Auswertungen per Chat, Wissenspflege, Outbound-Listen aus anderen Systemen und vollautomatische Agenten-Workflows.

Auswertung per Chat

„Wie viele Anrufe hatten wir diese Woche und welche Termine wurden gebucht?“ – Claude holt Kennzahlen und Transkripte und fasst sie zusammen.

Wissenslücken schließen

Dein Agent listet offene Fragen von Anrufern, du diktierst die Antwort, Claude lernt sie mit add_answer an – ab dem nächsten Anruf weiß es dein Telefonagent.

Rückruflisten aus deinem CRM

Ein KI-Agent stellt aus deinem CRM eine Liste mit Kontaktgrundlage zusammen und legt einen Anruf-Auftrag an. Gestartet wird erst nach deiner Freigabe.

Eigene Agenten & Workflows

Claude Agent SDK, OpenAI Agents SDK, n8n oder das MSL Cockpit von mysoftwarelab: Jeder MCP-fähige Client nutzt dieselbe URL und denselben Schlüssel.

Einrichtung in 3 Schritten

Du brauchst nur einen API-Schlüssel und die Server-URL https://api.anicall.io/mcp – eine Installation oder ein lokaler Server ist nicht nötig.

API-Schlüssel anlegen
Im Dashboard unter Einstellungen → Integrationen einen Schlüssel mit genau den Rechten anlegen, die dein Agent braucht – zum Beispiel nur calls:read und stats:read für Auswertungen.
KI-Client verbinden
URL und Header Authorization: Bearer anc_live_… in deinem Client eintragen. Beispiele für die gängigen Clients findest du unten.
Ausprobieren
Frag deinen Agenten: „Zeig mir meine Telefonagenten und die letzten fünf Anrufe.“ Er ruft list_agents und list_calls auf und antwortet mit echten Daten.

Konfiguration für deinen KI-Client

Claude Code (Terminal)

claude mcp add --transport http anicall https://api.anicall.io/mcp \
  --header "Authorization: Bearer anc_live_…"

claude.ai & Claude Desktop (Organisations-Connector)

Als Organisations-Inhaber unter Einstellungen → Connectors → Benutzerdefinierten Connector hinzufügen: URL eintragen und unter „Request headers“ den Header authorization mit dem Wert Bearer anc_live_… hinterlegen. Die Header-Option ist bei Anthropic aktuell eine Beta-Funktion.

Claude API (MCP-Connector)

In der Messages API trägst du den Server im Feld mcp_servers ein und übergibst deinen Schlüssel als authorization_token – anicall.io akzeptiert ihn als Bearer-Token.

"mcp_servers": [{
  "type": "url",
  "url": "https://api.anicall.io/mcp",
  "name": "anicall",
  "authorization_token": "anc_live_…"
}]

Cursor (~/.cursor/mcp.json)

{
  "mcpServers": {
    "anicall": {
      "url": "https://api.anicall.io/mcp",
      "headers": { "Authorization": "Bearer anc_live_…" }
    }
  }
}

VS Code (.vscode/mcp.json)

{
  "servers": {
    "anicall": {
      "type": "http",
      "url": "https://api.anicall.io/mcp",
      "headers": { "Authorization": "Bearer anc_live_…" }
    }
  }
}

Verbindung testen (curl)

curl https://api.anicall.io/mcp \
  -H "Authorization: Bearer anc_live_…" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Alle 22 Werkzeuge

Lesende Werkzeuge sind als readOnly markiert; start_call, approve_dial_job und assign_phone_number sind als destruktiv gekennzeichnet, damit dein KI-Client vorher nachfragt.

Werkzeug	Recht	Bedeutung
`get_account`	`agents:read`	Workspace, Token-Guthaben und Rechte des Schlüssels.
`list_agents`	`agents:read`	Agenten auflisten
`get_agent`	`agents:read`	Konfiguration eines Agenten
`set_agent_strictness`	`agents:write`	Wissensgrenze eines Agenten setzen
`search_knowledge`	`knowledge:read`	Wissensbasis durchsuchen
`list_knowledge_sources`	`knowledge:read`	Wissensquellen eines Agenten mit Indexierungsstatus.
`add_knowledge_source`	`knowledge:write`	Wissensquelle hinzufügen
`list_knowledge_gaps`	`knowledge:read`	Wissenslücken auflisten
`answer_knowledge_gap`	`knowledge:write`	Wissenslücke beantworten
`dismiss_knowledge_gap`	`knowledge:write`	Wissenslücke als nicht relevant verwerfen.
`add_answer`	`knowledge:write`	Frage-Antwort-Paar anlernen (gilt ab dem nächsten Anruf).
`list_calls`	`calls:read`	Anrufe mit Ergebnis und Ampel
`get_call`	`calls:read`	Anruf mit Transkript und Nachprüfung
`start_call`	`calls:write`	Einzelanruf starten (destruktiv)
`create_dial_job`	`dial_jobs:write`	Anruf-Auftrag anlegen (destruktiv)
`approve_dial_job`	`dial_jobs:approve`	Anruf-Auftrag freigeben (destruktiv)
`get_dial_job`	`calls:read`	Status eines Anruf-Auftrags
`pause_dial_job`	`dial_jobs:write`	Laufenden Anruf-Auftrag sofort anhalten.
`get_stats`	`stats:read`	Kennzahlen
`list_phone_numbers`	`phone_numbers:read`	Rufnummern mit zugewiesenem Agenten.
`assign_phone_number`	`phone_numbers:write`	Rufnummer einem Agenten zuweisen oder lösen.
`list_calendars`	`calendars:read`	Verbundene Kalender für Terminbuchungen.

Sicherheit: Was ein KI-Agent darf – und was nicht

anicall.io prüft bei jedem MCP-Aufruf Schlüssel, Rechte und Rate-Limit; Anruflisten brauchen immer die Freigabe eines Menschen.

Least Privilege

16 einzelne Rechte pro Schlüssel. Dein KI-Agent sieht nur die Werkzeuge, für die sein Schlüssel berechtigt ist.

Freigabe-Tor

Anruf-Aufträge starten erst nach approve_dial_job durch einen Menschen – mit eigenem Recht und nie mit dem Schlüssel, der den Auftrag angelegt hat.

Kontaktgrundlage Pflicht

Jeder Anruf braucht eine Rechtsgrundlage nach § 7 UWG (Einwilligung, Anfrage, Rückrufwunsch, Bestandskunde oder begründetes Interesse).

Rate-Limits je Schlüssel

Allgemeine und strengere Limits für kostenrelevante Aktionen bremsen Fehlschleifen und geleakte Schlüssel.

Schutz vor Prompt-Injection

Transkripte und Notizen von Anrufern sind für den KI-Client als Daten gekennzeichnet, nicht als Anweisungen.

Schlüssel nur als Hash

anicall.io speichert nur einen SHA-256-Hash. Du siehst den Schlüssel einmal und kannst ihn jederzeit widerrufen.

MCP, REST-API oder Webhooks?

Der MCP-Server ist für KI-Agenten gedacht, die REST-API v2 für klassische Software und Webhooks für Ereignisse in Echtzeit – alle drei nutzen dieselben Rechte.

Kriterium	MCP-Server	REST-API v2	Webhooks
Gedacht für	KI-Agenten (Claude, Cursor, eigene Agenten)	Eigene Software, Backends, Skripte	Reaktion auf Ereignisse
Richtung	Agent → anicall.io	Dein System → anicall.io	anicall.io → dein System
Einrichtung	URL + Schlüssel im KI-Client	HTTP-Aufrufe nach OpenAPI	HTTPS-Ziel + Signaturprüfung
Anmeldung	Bearer anc_live_…	Bearer anc_live_…	HMAC-SHA256-Signatur
Beispiel	„Claude, leg eine Rückrufliste an.“	Nächtlicher Import aus deinem ERP	call.completed → Ticket im Helpdesk

Model Context Protocol – Specification 2025-06-18

Häufige Fragen

Was ist ein MCP-Server?

Ein MCP-Server stellt KI-Anwendungen über das offene Model Context Protocol Werkzeuge bereit. Der MCP-Server von anicall.io macht Telefonagenten für KI-Agenten bedienbar: Anrufe, Wissensbasis, Anruflisten und Kennzahlen.

Welche KI-Clients funktionieren mit dem anicall-MCP-Server?

Jeder Client, der Remote-MCP über Streamable HTTP mit einem Authorization-Header unterstützt – zum Beispiel Claude Code, Cursor, VS Code, die Claude API (MCP-Connector), claude.ai-Organisations-Connectors mit Request-Headern sowie eigene Agenten mit dem Claude Agent SDK oder OpenAI Agents SDK.

Kann ein KI-Agent ohne meine Zustimmung Leute anrufen?

Nicht in Massen: Anruflisten starten erst nach Freigabe durch einen Menschen mit eigenem Recht. Einzelanrufe gehen nur mit dem Recht calls:write und einer Kontaktgrundlage nach § 7 UWG – vergib dieses Recht nur, wenn dein Agent wirklich anrufen soll.

Kostet der MCP-Server extra?

Nein. MCP-Server und REST-API sind ohne Aufpreis enthalten. Du zahlst nur die Gespräche und Rufnummern über dein Token-Guthaben, genau wie bei Anrufen aus dem Dashboard.

Wie unterscheiden sich MCP-Server und REST-API?

Beide nutzen dieselben Schlüssel und Rechte. Die REST-API ist für Software gedacht, die du selbst programmierst; der MCP-Server beschreibt dieselben Funktionen als Werkzeuge, die ein KI-Agent selbstständig auswählt.

Wo laufen die Daten?

Die Datenbank von anicall.io liegt in der EU. Sprach- und KI-Verarbeitung läuft teils über Anbieter in den USA; Details stehen in der Datenschutzerklärung. Dein KI-Client verarbeitet die Antworten der Werkzeuge nach seinen eigenen Bedingungen.

Gibt es OAuth für den MCP-Server?

Aktuell meldest du dich mit einem API-Schlüssel als Bearer-Token an. Eine OAuth-Anmeldung für Ein-Klick-Connectors ist geplant.

Verbinde deinen KI-Agenten in 2 Minuten

API-Schlüssel unter Einstellungen → Integrationen anlegen, Rechte wählen, MCP-URL eintragen – fertig.