Gebruik ThunderPhone vanuit Pipecat

Gebruik een ThunderPhone-spraakagent als de spraak-naar-spraakservice binnen een Pipecat-pijplijn, met je eigen transport en telefonie.

Pipecat is een opensourceframework voor het bouwen van spraakagenten uit samenstelbare services. ThunderPhone koppelt in als een spraak-naar-spraak-LLM-service: Pipecat stuurt audio van de beller, ThunderPhone retourneert de stem van de agent, transcripties en functieaanroepen, en het transport van Pipecat (Daily, LiveKit, Twilio, WebRTC, een lokale microfoon) vervoert de audio. Spraakherkenning, het taalmodel, de stem, beurtwisseling, 47 talen en tools draaien allemaal op ThunderPhone.

Oproepen die op deze manier worden gedaan, verschijnen in de Oproepgeschiedenis en worden gefactureerd tegen het tarief per minuut van je product, net als elke andere realtime oproep. Er is geen pakket en er is geen ThunderPhone-telefoonnummer betrokken.

Installeren

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

Het pakket verpakt de OpenAI Realtime-service van Pipecat, omdat de Realtime WebSocket van ThunderPhone hetzelfde protocol spreekt. Het vereist pipecat-ai 1.8 of nieuwer.

Een opgeslagen agent uitvoeren

Alles wat de agent doet (prompt, stem, engine, talen, tools, begroeting, stiltecontroles) wordt geconfigureerd in ThunderPhone. De pipeline verplaatst alleen 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))

Een opgeslagen agent opent de oproep volgens zijn eigen planning, dus de service vraagt Pipecat niet om een openingsreactie. Geef toch greet_on_connect=True door als je er wel een wilt.

De sessie inline configureren

Zonder agent_id komen instructies en tools uit de Pipecat-context, op dezelfde manier als bij OpenAI. product kiest de engine en voice kiest de ThunderPhone-stem.

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 sessies worden door de client aangestuurd: de agent spreekt eerst omdat Pipecat een reactie aanvraagt wanneer de context arriveert, en blijft stil tijdens stiltes tenzij je een bericht toevoegt of een andere reactie aanvraagt.

Opties

Argument	Betekenis
`api_key`	Geheime sleutel (`sk_live_...`). Standaard ingesteld op `THUNDERPHONE_API_KEY`.
`agent_id`	Voer een opgeslagen agent uit. Kan niet tegelijk met `product` en `voice` worden gebruikt.
`product`	Engine voor inline sessies: `spark`, `bolt` of `storm`.
`voice`	ThunderPhone-stemnaam voor inline sessies.
`language`	Hint voor de primaire taal voor inline sessies, bijvoorbeeld `es`.
`from_number`, `to_number`	Nummers die tijdens het gesprek worden geregistreerd wanneer de pipeline een telefoonlijn afhandelt.
`live_transcripts`	Stream transcriptfragmenten van de beller tijdens een uiting (tegen extra kosten).
`greet_on_connect`	Vraag om een eerste reactie zodra de sessie gereed is.
`end_task_on_call_ended`	Push `EndWorkerFrame` wanneer ThunderPhone het gesprek beëindigt (standaard ingeschakeld).

Gebeurtenissen

ThunderPhone voegt platformgebeurtenissen toe boven op het realtimeprotocol. De service levert deze aan handlers:

@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 wordt ingesteld zodra de sessie actief is. Gebruik deze met GET /v1/calls/{call_id} om de opname, het transcript en de beoordeling na het gesprek op te halen.

Limieten

Beurtdetectie gebeurt server-side en staat altijd aan; door Pipecat aangestuurde beurten (turn_detection=False) worden niet ondersteund.
Functies die op de service zijn geregistreerd, worden alleen uitgevoerd voor inline sessies. Een opgeslagen agent voert zijn eigen tools uit op ThunderPhone.
Audio is 16-bits mono PCM op 24 kHz in beide richtingen.
Videoframes worden genegeerd.

Gebruik ThunderPhone vanuit Pipecat

Installeren#

Een opgeslagen agent uitvoeren#

De sessie inline configureren#

Opties#

Gebeurtenissen#

Limieten#