Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Byg en komplet taleagent

Lektion 14 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. Byg en komplet taleagent
  2. Agent-arkitektur
  3. Klassen VoiceAgent
  4. Modul til lydoptagelse
  5. Modul til begivenhedsbehandling
  6. Modul til værktøjshåndtering
  7. Start agenten
  8. Vigtige pointer

Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset: tts-1, tts-1-hd og gpt-4o-mini-tts stopper den 6. januar 2027 (efterfølger: gpt-realtime-2.1-mini, som OpenAI TTS-guiden angiver ikke understøttes af /v1/audio/speech: migration af talesyntese flyttes til Realtime API); gpt-realtime, gpt-4o-realtime og ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe og /v1/audio/translations den 26. februar 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026.

Rettet 3. november 2026. Input-transskription brugte gpt-live-transcribe, som kun fungerer i en transskriptions-session og hverken understøtter server_vad eller semantic_vad. I en konversationssession som denne, hvor VAD validerer hver tur, specificerer dokumentationen gpt-transcribe, som transskriberer validerede ture og bruger tidligere ture som kontekst. Kilder: Realtime transcription · GPT-Transcribe · GPT-Live-Transcribe.

Byg en komplet taleagent

Denne lektion samler alle de begreber, vi har dækket hidtil, for at bygge en fuldt funktionel ende-til-ende taleagent. Du vil skabe en assistent, der lytter til brugeren, forstår deres anmodning, udfører handlinger og svarer med tale – alt sammen i realtid via Realtime API.

Agent-arkitektur

Fire moduler, og frem for alt én begrænsning, der driver hele arkitekturen: alt skal ske på én gang. Mikrofonen optager, mens modellen svarer, begivenheder ankommer, mens lyd afspilles, og brugeren kan afbryde når som helst. En taleagent er ikke en spørgsmål-og-svar-løkke; det er et system, hvor flere strømme skrider frem parallelt – derfor læner vi os i det følgende kraftigt op ad asyncio.

Lyd
Optagelse og afspilning
Session
WebSocket og konfiguration
Værktøjer
Forretningshandlinger
Tilstand
Håndtering af konversation

Klassen VoiceAgent

Klassen samler den tilstand, som disse parallelle strømme skal dele: forbindelsen, den aktuelle session og det svar, der i øjeblikket afspilles. Netop fordi flere opgaver tilgår denne tilstand samtidigt, er et objekt at foretrække frem for et sæt globale variabler – når du skal annullere et igangværende svar, skal du vide, at et sådant eksisterer.

import asyncio
import json
import base64
import websockets
import sounddevice as sd
import numpy as np
import pyaudio

class VoiceAgent:
    """Komplet taleagent baseret på Realtime API."""

    def __init__(self, api_key: str, instructions: str, tools: list = None):
        self.api_key = api_key
        self.instructions = instructions
        self.tools = tools or []
        self.ws = None
        self.is_playing = False
        self.sample_rate = 24000
        self.chunk_size = 2400  # 100ms

    async def connect(self):
        """Etablerer forbindelsen og konfigurerer sessionen."""
        url = "wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1"
        headers = {
            "Authorization": f"Bearer {self.api_key}"
        }

        self.ws = await websockets.connect(url, additional_headers=headers)

        # Vent på session.created
        event = json.loads(await self.ws.recv())
        print(f"Session: {event['session']['id']}")

        # Konfigurer
        await self.ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "type": "realtime",
                "output_modalities": ["audio"],
                "instructions": self.instructions,
                "audio": {
                    "input": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "transcription": {"model": "gpt-transcribe", "languages": ["fr"]},
                        "turn_detection": {
                            "type": "server_vad",
                            "threshold": 0.5,
                            "silence_duration_ms": 600
                        }
                    },
                    "output": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "voice": "marin"
                    }
                },
                "tools": self.tools,
                "tool_choice": "auto"
            }
        }))

        await self.ws.recv()  # session.updated
        print("Taleagent klar.")

    async def start(self):
        """Starter taleagenten."""
        await self.connect()
        await asyncio.gather(
            self._capture_audio(),
            self._process_events()
        )

Modul til lydoptagelse

    async def _capture_audio(self):
        """Optager mikrofoninput og sender det til Realtime API."""
        loop = asyncio.get_event_loop()
        queue = asyncio.Queue()

        def callback(indata, frames, time_info, status):
            pcm = (indata[:, 0] * 32767).astype(np.int16)
            loop.call_soon_threadsafe(queue.put_nowait, pcm)

        stream = sd.InputStream(
            samplerate=self.sample_rate,
            channels=1,
            dtype="float32",
            blocksize=self.chunk_size,
            callback=callback
        )

        with stream:
            while True:
                pcm_data = await queue.get()
                audio_b64 = base64.b64encode(pcm_data.tobytes()).decode()
                await self.ws.send(json.dumps({
                    "type": "input_audio_buffer.append",
                    "audio": audio_b64
                }))

Modul til begivenhedsbehandling

    async def _process_events(self):
        """Behandler alle begivenheder fra serveren."""
        pa = pyaudio.PyAudio()
        player = pa.open(
            format=pyaudio.paInt16, channels=1,
            rate=self.sample_rate, output=True
        )

        try:
            async for raw in self.ws:
                event = json.loads(raw)
                t = event["type"]

                if t == "response.output_audio.delta":
                    audio = base64.b64decode(event["delta"])
                    player.write(audio)
                    self.is_playing = True

                elif t == "response.output_audio.done":
                    self.is_playing = False

                elif t == "response.output_audio_transcript.delta":
                    print(event["delta"], end="", flush=True)

                elif t == "input_audio_buffer.speech_started":
                    if self.is_playing:
                        await self.ws.send(json.dumps({
                            "type": "response.cancel"
                        }))
                        self.is_playing = False

                elif t == "response.done":
                    await self._handle_response_done(event)

                elif t == "error":
                    print(f"\nFejl: {event['error']['message']}")

        finally:
            player.close()
            pa.terminate()

Modul til værktøjshåndtering

Dette modul transformerer agenten fra en simpel tale-chatbot til en assistent, der er i stand til at handle. Forskellen fra klassisk funktionskald ligger i tidsbegrænsningen: brugeren er i røret uden visuel fremskridtsindikator. Hvis eksekveringen tager mere end et sekund eller to, så lad agenten tale, mens den arbejder – „Lad mig tjekke det for dig med det samme” – fordi tavshed i en talesamtale lyder som en nedbrydning.

    async def _handle_response_done(self, event):
        """Håndterer funktionskald i svaret."""
        response = event["response"]
        function_calls = [
            o for o in response.get("output", [])
            if o["type"] == "function_call"
        ]

        if not function_calls:
            print()  # Ny linje efter transskription
            return

        for call in function_calls:
            name = call["name"]
            args = json.loads(call["arguments"])
            call_id = call["call_id"]

            print(f"\n→ {name}({args})")

            # Udfør funktionen (tilpas til din forretningslogik)
            result = await self._execute_function(name, args)

            await self.ws.send(json.dumps({
                "type": "conversation.item.create",
                "item": {
                    "type": "function_call_output",
                    "call_id": call_id,
                    "output": json.dumps(result)
                }
            }))

        # Bed modellen om at fortsætte
        await self.ws.send(json.dumps({"type": "response.create"}))

    async def _execute_function(self, name: str, args: dict) -> dict:
        """Dispatcher funktionskaldet."""
        # Implementér i henhold til din forretningslogik
        return {"error": f"Funktion {name} ikke implementeret"}

Start agenten

async def main():
    agent = VoiceAgent(
        api_key="sk-...",
        instructions=(
            "Du er en taleassistent for Corsen AI. "
            "Du hjælper brugere med at administrere deres aftaler "
            "og få information om vores tjenester. "
            "Svar på fransk, koncist og professionelt."
        ),
        tools=[
            {
                "type": "function",
                "name": "check_availability",
                "description": "Tjekker tilgængelighed for en tidsperiode",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "date": {"type": "string"},
                        "service": {"type": "string"}
                    },
                    "required": ["date"]
                }
            }
        ]
    )

    await agent.start()

asyncio.run(main())

Vigtige pointer

  • En komplet taleagent kombinerer fire moduler: lyd, session, værktøjer og tilstandshåndtering
  • Klassen VoiceAgent kapsler al logik bag en simpel grænseflade
  • asyncio.gather muliggør parallel mikrofonoptagelse og begivenhedsbehandling
  • Håndtering af afbrydelser (annullering af et svar, når brugeren taler) er afgørende
  • Værktøjer transformerer agenten fra en simpel tale-chatbot til en assistent, der er i stand til at handle