ThunderPhone 2.0 er lanceret.Selvbetjening fra 2 cent/min.Læs mere om lanceringen
Kom i gang

Connect tools & data

Brug ThunderPhone fra Pipecat

Kør en ThunderPhone-stemmeagent som tale-til-tale-tjenesten i en Pipecat-pipeline med din egen transport og telefoni.

Pipecat er et open source-framework til at bygge stemmeagenter af sammensættelige tjenester. ThunderPhone integreres som en tale-til-tale-LLM-tjeneste: Pipecat sender opkalderens lyd, ThunderPhone returnerer agentens stemme, transskriptioner og funktionskald, og Pipecats transport (Daily, LiveKit, Twilio, WebRTC, en lokal mikrofon) overfører lyden. Talegenkendelse, sprogmodellen, stemmen, turtagning, 47 sprog og værktøjer kører alle på ThunderPhone.

Opkald foretaget på denne måde vises i opkaldshistorikken og faktureres til dit produkts minutpris ligesom ethvert andet realtime-opkald. Der er intet abonnement og intet ThunderPhone-telefonnummer involveret.

Installer

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

Pakken omslutter Pipecats OpenAI Realtime-tjeneste, fordi ThunderPhones Realtime WebSocket taler den samme protokol. Den kræver pipecat-ai 1.8 eller nyere.

Kør en gemt agent

Alt, hvad agenten gør (prompt, stemme, motor, sprog, værktøjer, hilsen, opfølgninger ved stilhed), konfigureres i ThunderPhone. Pipelinjen flytter kun lyd.

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 gemt agent åbner opkaldet efter sin egen plan, så tjenesten anmoder ikke Pipecat om et indledende svar. Angiv greet_on_connect=True, hvis du alligevel ønsker et.

Konfigurer sessionen inline

Uden agent_id kommer instruktioner og værktøjer fra Pipecat-konteksten på samme måde som for OpenAI. product vælger motoren, og voice vælger ThunderPhone-stemmen.

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-sessioner styres af klienten: agenten taler først, fordi Pipecat anmoder om et svar, når konteksten ankommer, og forbliver stille under stilhed, medmindre du tilføjer en besked eller anmoder om et nyt svar.

Indstillinger

ArgumentBetydning
api_keyHemmelig nøgle (sk_live_...). Standard er THUNDERPHONE_API_KEY.
agent_idKør en gemt agent. Kan ikke bruges sammen med product og voice.
productMotor til indlejrede sessioner: spark, bolt eller storm.
voiceThunderPhone-stemmenavn til indlejrede sessioner.
languageHint til primært sprog for indlejrede sessioner, f.eks. es.
from_number, to_numberNumre, der skal registreres på opkaldet, når pipelinen håndterer en telefonlinje.
live_transcriptsStream transskriptionsfragmenter fra opkalderen midt i en ytring (faktureres ekstra).
greet_on_connectAnmod om et første svar, så snart sessionen er klar.
end_task_on_call_endedSend EndWorkerFrame, når ThunderPhone afslutter opkaldet (aktiveret som standard).

Hændelser

ThunderPhone tilføjer platformsbegivenheder oven på realtidsprotokollen. Tjenesten leverer dem til handlere:

@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 angives, når sessionen er aktiv. Brug det med GET /v1/calls/{call_id} til at hente optagelsen, transskriptionen og vurderingen efter opkaldet.

Begrænsninger

  • Taledetektering sker på serversiden og er altid aktiveret; Pipecat-styrede ture (turn_detection=False) understøttes ikke.
  • Funktioner, der er registreret på tjenesten, kører kun for indlejrede sessioner. En gemt agent udfører sine egne værktøjer på ThunderPhone.
  • Lyd er 16-bit mono PCM ved 24 kHz i begge retninger.
  • Videobilleder ignoreres.