---
title: "Brug ThunderPhone fra LiveKit Agents"
description: "Kør en ThunderPhone-stemmeagent som realtidsmodellen (tale-til-tale) i en LiveKit Agents-session med LiveKit-rum, SIP og telefoni omkring den."
---

[LiveKit Agents](https://github.com/livekit/agents) er et open source-framework
til stemmeagenter i realtid oven på LiveKit-rum. ThunderPhone integreres som
**realtidsmodellen**: frameworket sender deltagerens lyd, ThunderPhone
returnerer agentens stemme, transskriptioner og funktionskald, og LiveKits rum,
SIP-trunks og telefoni transporterer lyden. Talegenkendelse, sprogmodellen,
stemmen, turstyring, 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 alle andre realtimeopkald ([priser](/da/guides/pricing)). Der
er intet abonnement og intet ThunderPhone-telefonnummer involveret.

## Installer

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

Med uv installerer `uv add "livekit-agents[thunderphone]~=1.8"` det samme
plugin. Det leveres i [livekit/agents](https://github.com/livekit/agents)-arkivet
og udgives sammen med `livekit-agents`, så hold begge på samme version. LiveKit dokumenterer det i sin egen
[ThunderPhone-pluginguide](https://docs.livekit.io/agents/models/realtime/thunderphone/).

Pluginet indpakker LiveKits OpenAI Realtime-model, fordi ThunderPhones
[Realtime WebSocket](/api-reference/realtime) taler den samme protokol. Det
kræver `livekit-agents` 1.8 eller nyere.

## Kør en gemt agent

Alt, hvad agenten gør (prompt, stemme, motor, sprog, værktøjer, hilsen,
tjek under stilhed), konfigureres i ThunderPhone. Sessionen 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 implementerer på ThunderPhone, gælder for det næste opkald uden at
berøre din LiveKit-kode.

```python
from livekit.agents import Agent, AgentSession, JobContext, WorkerOptions, cli
from livekit.plugins import thunderphone


async def entrypoint(ctx: JobContext):
    session = AgentSession(llm=thunderphone.RealtimeModel(agent_id=12))
    await session.start(agent=Agent(instructions=""), room=ctx.room)


if __name__ == "__main__":
    cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint))
```

En gemt agent hilser og kører sine egne værktøjer på ThunderPhone; LiveKit-
`Agent`ens instruktioner og værktøjer sendes ikke. Opkaldet afsluttes, når
ThunderPhone-agenten lægger på, og sessionen lukkes sammen med den.

## Konfigurer sessionen direkte

Uden `agent_id` kommer instruktioner og værktøjer fra LiveKit-`Agent`, på
samme måde som de gør for OpenAI. `model` vælger motoren, og `voice` vælger
ThunderPhone-stemmen.

```python
from livekit.agents import Agent, AgentSession, RunContext, function_tool
from livekit.plugins import thunderphone


class Receptionist(Agent):
    def __init__(self):
        super().__init__(instructions="You are Acme Dental's receptionist. Be brief.")

    @function_tool
    async def check_availability(self, context: RunContext, date: str) -> dict:
        """Free appointment slots on a date."""
        return {"slots": await calendar.free_slots(date)}


async def entrypoint(ctx: JobContext):
    session = AgentSession(
        llm=thunderphone.RealtimeModel(model="bolt", voice="olivia", language="es"),
    )
    await session.start(agent=Receptionist(), room=ctx.room)
    await session.generate_reply()   # the agent speaks first
```

ThunderPhone låser instruktioner og værktøjer, når opkaldet starter, så
`update_instructions`, `update_tools` og agentoverdragelser, der ændrer dem,
understøttes ikke under opkaldet. Direkte sessioner styres af klienten: agenten
taler, når du kalder `generate_reply()`, eller når deltageren afslutter en tur.

## 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 `model` og `voice`. |
| `model` | Motor til integrerede sessioner: `bolt` (de ældre `spark` og `storm` accepteres stadig). |
| `voice` | ThunderPhone-stemmenavn til integrerede sessioner. |
| `language` | Primært sprogtip til integrerede sessioner, f.eks. `es`. |
| `caller_number`, `callee_number` | Opkaldets telefonnumre, når rummet er forbundet til en telefonlinje. De vises som fra- og til-numre i opkaldshistorikken. |
| `live_transcripts` | Stream fragmenter af opkalderens transskription midt i en ytring (faktureres ekstra). |
| `base_url` | Tilsidesættelse af endpoint; standard er `wss://api.thunderphone.com/v1/realtime`. |

## Hændelser

ThunderPhone tilføjer platformshændelser oven på realtime-protokollen. Sessionen
udsender dem:

```python
@session.llm.session.on("thunderphone_call_ended")  # or on the RealtimeSession you hold
def on_call_ended(event):
    print("call ended:", event["reason"])
```

`RealtimeSession` eksponerer `call_id`, når sessionen er aktiv. Brug den med
[`GET /v1/calls/{call_id}`](/api-reference/calls) til at hente optagelsen,
transskriptionen og vurderingen efter opkaldet. Alle andre `call.*`-hændelser
(overførsel, tastatur, tale ignoreret) ankommer som `thunderphone_call_event`.

## Begrænsninger

- Turdetektering foregår på serversiden og er altid aktiveret; turdetektering
  på frameworksiden (`turn_detection` på `AgentSession`) ignoreres.
- Instruktioner og værktøjer kan ikke ændres, når opkaldet er startet.
- Lyd er 16-bit mono-PCM ved 24 kHz i begge retninger.
- Videobilleder ignoreres.

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