---
title: "Brug ThunderPhone fra Pipecat"
description: "Kør en ThunderPhone-stemmeagent som tale-til-tale-tjenesten i en Pipecat-pipeline med din egen transport og telefoni."
---

[Pipecat](https://github.com/pipecat-ai/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 lyd fra den, der ringer, ThunderPhone
returnerer agentens stemme, transskriptioner og funktionskald, og Pipecats
transport (Daily, LiveKit, Twilio, WebRTC, en lokal mikrofon) overfører
lyden. Talegenkendelse, sprogmodellen, stemmen, turhåndtering, 62
sprog og værktøjer kører alle på ThunderPhone.

Opkald foretaget på denne måde vises i [opkaldshistorikken](/api-reference/calls) og
faktureres som ethvert andet realtidsopkald ([priser](/da/guides/pricing)). Der
er intet abonnement og intet ThunderPhone-telefonnummer involveret.

## Installer

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

Pakken omslutter Pipecats OpenAI Realtime-tjeneste, fordi ThunderPhones
[Realtime WebSocket](/api-reference/realtime) 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 på ThunderPhone. Pipelinen flytter kun lyd.
Byg agenten i dashboardet, eller lad Zeus (AI-agenten, der bygger, tester
og finjusterer ThunderPhone-agenter) konfigurere den, og angiv derefter dens ID her. Ændringer, du
udruller på ThunderPhone, gælder for det næste opkald uden at ændre din pipeline.

```python
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.

```python
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

| Argument | Betydning |
|---|---|
| `api_key` | Hemmelig nøgle (`sk_live_...`). Standard er `THUNDERPHONE_API_KEY`. |
| `agent_id` | Kør en gemt agent. Kan ikke bruges sammen med `product` og `voice`. |
| `product` | Motor til indlejrede sessioner: `bolt` (de ældre `spark` og `storm` understøttes stadig). |
| `voice` | ThunderPhone-stemmenavn til indlejrede sessioner. |
| `language` | Hint til primært sprog for indlejrede sessioner, f.eks. `es`. |
| `from_number`, `to_number` | Numre, der skal registreres på opkaldet, når pipelinen ligger foran en telefonlinje. |
| `live_transcripts` | Stream transskriptionsfragmenter fra opkalderen midt i en ytring (faktureres ekstra). |
| `greet_on_connect` | Anmod om et første svar, så snart sessionen er klar. |
| `end_task_on_call_ended` | Send `EndWorkerFrame`, når ThunderPhone afslutter opkaldet (aktiveret som standard). |

## Hændelser

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

```python
@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}`](/api-reference/calls) 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.

<Note>
Bygger du i stedet på LiveKit Agents? Se
[Brug ThunderPhone fra LiveKit Agents](/da/guides/use-with-livekit).
</Note>
