Use o ThunderPhone com o Pipecat

Execute um agente de voz do ThunderPhone como o serviço de fala para fala em um pipeline do Pipecat, com seu próprio transporte e telefonia.

Pipecat é um framework de código aberto para criar agentes de voz com serviços combináveis. O ThunderPhone se integra como um serviço de LLM de fala para fala: o Pipecat envia o áudio de quem liga, o ThunderPhone retorna a voz do agente, transcrições e chamadas de função, e o transporte do Pipecat (Daily, LiveKit, Twilio, WebRTC, um microfone local) transporta o áudio. Reconhecimento de fala, o modelo de linguagem, a voz, alternância de turnos, 47 idiomas e ferramentas são todos executados no ThunderPhone.

As chamadas feitas dessa forma aparecem no histórico de chamadas e são cobradas pela tarifa por minuto do seu produto, como qualquer outra chamada em tempo real. Não há assinatura nem número de telefone do ThunderPhone envolvido.

Instalar

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

O pacote encapsula o serviço OpenAI Realtime do Pipecat, porque o Realtime WebSocket do ThunderPhone usa o mesmo protocolo. Ele requer pipecat-ai 1.8 ou mais recente.

Executar um agente salvo

Tudo o que o agente faz (prompt, voz, mecanismo, idiomas, ferramentas, saudação, verificações de silêncio) é configurado no ThunderPhone. O pipeline apenas transporta áudio.

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))

Um agente salvo inicia a chamada conforme sua própria programação, então o serviço não solicita uma resposta inicial do Pipecat. Passe greet_on_connect=True se ainda quiser uma.

Configurar a sessão em linha

Sem agent_id, as instruções e ferramentas vêm do contexto do Pipecat, da mesma forma que no OpenAI. product seleciona o mecanismo e voice seleciona a voz do 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"],
        )
    ]),
)

As sessões em linha são conduzidas pelo cliente: o agente fala primeiro porque o Pipecat solicita uma resposta quando o contexto chega e permanece em silêncio durante períodos de silêncio, a menos que você adicione uma mensagem ou solicite outra resposta.

Opções

Argumento	Significado
`api_key`	Chave secreta (`sk_live_...`). O padrão é `THUNDERPHONE_API_KEY`.
`agent_id`	Executa um agente salvo. Mutuamente exclusivo com `product` e `voice`.
`product`	Mecanismo para sessões inline: `spark`, `bolt` ou `storm`.
`voice`	Nome da voz do ThunderPhone para sessões inline.
`language`	Indicação do idioma principal para sessões inline, por exemplo, `es`.
`from_number`, `to_number`	Números a registrar na chamada quando o pipeline atende uma linha telefônica.
`live_transcripts`	Transmite fragmentos da transcrição de quem liga durante a fala (cobrado à parte).
`greet_on_connect`	Solicita uma primeira resposta assim que a sessão estiver pronta.
`end_task_on_call_ended`	Envia `EndWorkerFrame` quando o ThunderPhone encerra a chamada (ativado por padrão).

Eventos

O ThunderPhone adiciona eventos da plataforma ao protocolo em tempo real. O serviço os entrega aos 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 é definido quando a sessão entra em operação. Use-o com GET /v1/calls/{call_id} para buscar a gravação, a transcrição e a avaliação após a chamada.

Limites

A detecção de turnos ocorre no servidor e está sempre ativada; turnos controlados pelo Pipecat (turn_detection=False) não são compatíveis.
Funções registradas no serviço são executadas apenas em sessões inline. Um agente salvo executa suas próprias ferramentas no ThunderPhone.
O áudio é PCM mono de 16 bits a 24 kHz em ambas as direções.
Quadros de vídeo são ignorados.

Use o ThunderPhone com o Pipecat

Instalar#

Executar um agente salvo#

Configurar a sessão em linha#

Opções#

Eventos#

Limites#