Usa ThunderPhone da Pipecat

Esegui un agente vocale ThunderPhone come servizio speech-to-speech all

Pipecat è un framework open source per creare agenti vocali con servizi componibili. ThunderPhone si integra come servizio LLM da voce a voce: Pipecat invia l'audio del chiamante, ThunderPhone restituisce la voce dell'agente, le trascrizioni e le chiamate di funzione, mentre il trasporto di Pipecat (Daily, LiveKit, Twilio, WebRTC, un microfono locale) veicola l'audio. Il riconoscimento vocale, il modello linguistico, la voce, la gestione dei turni, 47 lingue e gli strumenti sono tutti eseguiti su ThunderPhone.

Le chiamate effettuate in questo modo compaiono nella cronologia chiamate e vengono fatturate alla tariffa al minuto del tuo prodotto, come qualsiasi altra chiamata in tempo reale. Non sono previsti abbonamenti né è coinvolto un numero di telefono ThunderPhone.

Installa

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

Il pacchetto avvolge il servizio OpenAI Realtime di Pipecat, perché il WebSocket Realtime di ThunderPhone utilizza lo stesso protocollo. Richiede pipecat-ai 1.8 o una versione successiva.

Esegui un agente salvato

Tutto ciò che fa l'agente (prompt, voce, motore, lingue, strumenti, saluto, verifiche durante il silenzio) è configurato su ThunderPhone. La pipeline sposta solo l'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))

Un agente salvato avvia la chiamata secondo la propria pianificazione, quindi il servizio non richiede una risposta iniziale a Pipecat. Passa greet_on_connect=True se la desideri comunque.

Configura la sessione inline

Senza agent_id, le istruzioni e gli strumenti provengono dal contesto Pipecat, come avviene per OpenAI. product seleziona il motore e voice seleziona la voce ThunderPhone.

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"],
        )
    ]),
)

Le sessioni inline sono guidate dal client: l'agente parla per primo perché Pipecat richiede una risposta quando arriva il contesto e rimane in silenzio durante le pause, a meno che tu non aggiunga un messaggio o richieda un'altra risposta.

Opzioni

Argomento	Significato
`api_key`	Chiave segreta (`sk_live_...`). Per impostazione predefinita usa `THUNDERPHONE_API_KEY`.
`agent_id`	Esegui un agente salvato. Si esclude a vicenda con `product` e `voice`.
`product`	Motore per sessioni inline: `spark`, `bolt` o `storm`.
`voice`	Nome della voce ThunderPhone per sessioni inline.
`language`	Suggerimento della lingua principale per le sessioni inline, ad esempio `es`.
`from_number`, `to_number`	Numeri da registrare nella chiamata quando la pipeline è collegata a una linea telefonica.
`live_transcripts`	Trasmetti frammenti della trascrizione del chiamante durante l'enunciato (costo aggiuntivo).
`greet_on_connect`	Richiedi una prima risposta non appena la sessione è pronta.
`end_task_on_call_ended`	Invia `EndWorkerFrame` quando ThunderPhone termina la chiamata (attivo per impostazione predefinita).

Eventi

ThunderPhone aggiunge eventi della piattaforma al protocollo in tempo reale. Il servizio li invia ai gestori:

@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 viene impostato quando la sessione è attiva. Usalo con GET /v1/calls/{call_id} per recuperare la registrazione, la trascrizione e la valutazione dopo la chiamata.

Limiti

Il rilevamento dei turni è lato server ed è sempre attivo; i turni gestiti da Pipecat (turn_detection=False) non sono supportati.
Le funzioni registrate nel servizio vengono eseguite solo per le sessioni inline. Un agente salvato esegue i propri strumenti su ThunderPhone.
L'audio è PCM mono a 16 bit e 24 kHz in entrambe le direzioni.
I fotogrammi video vengono ignorati.

Usa ThunderPhone da Pipecat

Installa#

Esegui un agente salvato#

Configura la sessione inline#

Opzioni#

Eventi#

Limiti#