ThunderPhone 2.0 ist live.Direkt im Self-Service – ab 2 ¢/Min..Ankündigung lesen
Jetzt starten

Connect tools & data

ThunderPhone über Pipecat verwenden

Führen Sie einen ThunderPhone-Sprachagenten als Speech-to-Speech-Dienst in einer Pipecat-Pipeline mit Ihrem eigenen Transport und Ihrer eigenen Telefonie aus.

Pipecat ist ein Open-Source-Framework zum Erstellen von Sprachagenten aus kombinierbaren Diensten. ThunderPhone lässt sich als Sprach-zu-Sprach-LLM-Dienst einbinden: Pipecat sendet Anruferaudio, ThunderPhone gibt die Stimme des Agenten, Transkripte und Funktionsaufrufe zurück, und der Transport von Pipecat (Daily, LiveKit, Twilio, WebRTC, ein lokales Mikrofon) überträgt das Audio. Spracherkennung, das Sprachmodell, die Stimme, die Sprecherwechselerkennung, 47 Sprachen und Tools laufen alle auf ThunderPhone.

Auf diese Weise getätigte Anrufe erscheinen im Anrufverlauf und werden wie jeder andere Echtzeitanruf zum Minutentarif Ihres Produkts abgerechnet. Es ist weder ein Abonnement noch eine ThunderPhone-Telefonnummer erforderlich.

Installieren

pip install pipecat-thunderphone
export THUNDERPHONE_API_KEY=sk_live_...   # a secret API key

Das Paket kapselt den OpenAI-Realtime-Dienst von Pipecat, da der Realtime-WebSocket von ThunderPhone dasselbe Protokoll verwendet. Es erfordert pipecat-ai 1.8 oder neuer.

Einen gespeicherten Agenten ausführen

Alles, was der Agent tut (Prompt, Stimme, Engine, Sprachen, Tools, Begrüßung, Rückfragen bei Stille), wird in ThunderPhone konfiguriert. Die Pipeline überträgt nur Audio.

from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.worker import PipelineParams, PipelineWorker
from pipecat.processors.aggregators.llm_context import LLMContext
from pipecat.processors.aggregators.llm_response_universal import LLMContextAggregatorPair
from pipecat_thunderphone import ThunderPhoneRealtimeLLMService
 
llm = ThunderPhoneRealtimeLLMService(agent_id=12)
 
context = LLMContext()
aggregators = LLMContextAggregatorPair(context)
pipeline = Pipeline([
    transport.input(),
    aggregators.user(),
    llm,
    aggregators.assistant(),
    transport.output(),
])
worker = PipelineWorker(pipeline, params=PipelineParams(allow_interruptions=True))

Ein gespeicherter Agent eröffnet den Anruf nach seinem eigenen Zeitplan, daher fordert der Dienst keine erste Antwort von Pipecat an. Übergeben Sie greet_on_connect=True, wenn Sie dennoch eine wünschen.

Die Sitzung inline konfigurieren

Ohne agent_id stammen Anweisungen und Tools aus dem Pipecat-Kontext, genau wie bei OpenAI. product wählt die Engine aus und voice wählt die ThunderPhone-Stimme aus.

from pipecat.adapters.schemas.function_schema import FunctionSchema
from pipecat.adapters.schemas.tools_schema import ToolsSchema
from pipecat.services.llm_service import FunctionCallParams
 
llm = ThunderPhoneRealtimeLLMService(product="bolt", voice="olivia", language="es")
 
async def check_availability(params: FunctionCallParams):
    slots = await calendar.free_slots(params.arguments["date"])
    await params.result_callback({"slots": slots})
 
llm.register_function("check_availability", check_availability)
 
context = LLMContext(
    messages=[{"role": "system", "content": "You are Acme Dental's receptionist."}],
    tools=ToolsSchema(standard_tools=[
        FunctionSchema(
            name="check_availability",
            description="Free appointment slots on a date",
            properties={"date": {"type": "string"}},
            required=["date"],
        )
    ]),
)

Inline-Sitzungen werden vom Client gesteuert: Der Agent spricht zuerst, weil Pipecat eine Antwort anfordert, wenn der Kontext eintrifft, und bleibt bei Stille ruhig, sofern Sie keine Nachricht anhängen oder eine weitere Antwort anfordern.

Optionen

ArgumentBedeutung
api_keyGeheimer Schlüssel (sk_live_...). Standardmäßig THUNDERPHONE_API_KEY.
agent_idEinen gespeicherten Agenten ausführen. Schliesst sich gegenseitig mit product und voice aus.
productEngine für Inline-Sitzungen: spark, bolt oder storm.
voiceThunderPhone-Sprachname für Inline-Sitzungen.
languageHinweis zur primären Sprache für Inline-Sitzungen, z. B. es.
from_number, to_numberNummern, die beim Anruf aufgezeichnet werden, wenn die Pipeline einer Telefonleitung vorgeschaltet ist.
live_transcriptsTranskriptfragmente des Anrufers während einer Äußerung streamen (gegen Aufpreis abgerechnet).
greet_on_connectEine erste Antwort anfordern, sobald die Sitzung bereit ist.
end_task_on_call_endedEndWorkerFrame senden, wenn ThunderPhone den Anruf beendet (standardmäßig aktiviert).

Ereignisse

ThunderPhone ergänzt das Echtzeitprotokoll um Plattformereignisse. Der Dienst übermittelt sie an Handler:

@llm.event_handler("on_call_ended")
async def on_call_ended(service, event):
    print("call ended:", event["reason"], "call id:", service.call_id)

service.call_id wird gesetzt, sobald die Sitzung aktiv ist. Verwenden Sie sie mit GET /v1/calls/{call_id}, um nach dem Anruf die Aufnahme, das Transkript und die Bewertung abzurufen.

Einschränkungen

  • Die Sprecherwechselerkennung erfolgt serverseitig und ist immer aktiviert; von Pipecat gesteuerte Sprecherwechsel (turn_detection=False) werden nicht unterstützt.
  • Beim Dienst registrierte Funktionen werden nur für Inline-Sitzungen ausgeführt. Ein gespeicherter Agent führt seine eigenen Tools in ThunderPhone aus.
  • Audio ist in beide Richtungen 16-Bit-Mono-PCM mit 24 kHz.
  • Videoframes werden ignoriert.