ThunderPhone 2.0 är här.Kom igång själv, från 2 cent/minut.Läs lanseringsnyheten
Kom igång

Connect tools & data

Använd ThunderPhone från Pipecat

Kör en ThunderPhone-röstagent som tal-till-tal-tjänst i en Pipecat-pipeline med din egen transport och telefoni.

Pipecat är ett ramverk med öppen källkod för att bygga röstagentar av kombinerbara tjänster. ThunderPhone kopplas in som en tal-till-tal-LLM-tjänst: Pipecat skickar ljud från den som ringer, ThunderPhone returnerar agentens röst, transkriptioner och funktionsanrop, och Pipecats transport (Daily, LiveKit, Twilio, WebRTC, en lokal mikrofon) överför ljudet. Taligenkänning, språkmodellen, rösten, turtagning, 47 språk och verktyg körs alla på ThunderPhone.

Samtal som görs på detta sätt visas i samtalshistoriken och debiteras enligt produktens minutpris, precis som alla andra realtidssamtal. Det finns ingen prenumeration och inget ThunderPhone-telefonnummer är inblandat.

Installera

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

Paketet omsluter Pipecats OpenAI Realtime-tjänst, eftersom ThunderPhones Realtime WebSocket använder samma protokoll. Det kräver pipecat-ai 1.8 eller senare.

Kör en sparad agent

Allt agenten gör (prompt, röst, motor, språk, verktyg, hälsning, tystnadsavstämningar) konfigureras i ThunderPhone. Pipelinen flyttar bara ljud.

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

En sparad agent inleder samtalet enligt sitt eget schema, så tjänsten begär inte ett inledande svar från Pipecat. Skicka greet_on_connect=True om du ändå vill ha ett.

Konfigurera sessionen direkt i koden

Utan agent_id kommer instruktioner och verktyg från Pipecat-kontexten, på samma sätt som för OpenAI. product väljer motor och voice väljer ThunderPhone-röst.

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

Direktkonfigurerade sessioner styrs av klienten: agenten talar först eftersom Pipecat begär ett svar när kontexten kommer fram, och förblir tyst under tystnad om du inte lägger till ett meddelande eller begär ett nytt svar.

Alternativ

ArgumentBetydelse
api_keyHemlig nyckel (sk_live_...). Standardvärdet är THUNDERPHONE_API_KEY.
agent_idKör en sparad agent. Kan inte användas tillsammans med product och voice.
productMotor för infogade sessioner: spark, bolt eller storm.
voiceNamn på ThunderPhone-röst för infogade sessioner.
languagePrimär språkindikation för infogade sessioner, t.ex. es.
from_number, to_numberNummer att registrera i samtalet när pipelinen hanterar en telefonlinje.
live_transcriptsStrömma fragment av uppringarens transkription mitt i yttranden (debiteras extra).
greet_on_connectBegär ett första svar så snart sessionen är klar.
end_task_on_call_endedSkicka EndWorkerFrame när ThunderPhone avslutar samtalet (aktiverat som standard).

Händelser

ThunderPhone lägger till plattformshändelser ovanpå realtidsprotokollet. Tjänsten levererar dem till hanterare:

@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 anges när sessionen är live. Använd det med GET /v1/calls/{call_id} för att hämta inspelningen, transkriptionen och betyget efter samtalet.

Begränsningar

  • Turidentifiering sker på serversidan och är alltid aktiverad; Pipecat-styrda turer (turn_detection=False) stöds inte.
  • Funktioner som registreras i tjänsten körs endast för infogade sessioner. En sparad agent kör sina egna verktyg i ThunderPhone.
  • Ljud är 16-bitars mono-PCM vid 24 kHz i båda riktningarna.
  • Videobilder ignoreras.