Byg en komplet taleagent
På denne side
Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset:
tts-1,tts-1-hdoggpt-4o-mini-ttsstopper 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-realtimeog ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeog/v1/audio/translationsden 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øtterserver_vadellersemantic_vad. I en konversationssession som denne, hvor VAD validerer hver tur, specificerer dokumentationengpt-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.
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
VoiceAgentkapsler al logik bag en simpel grænseflade asyncio.gathermuliggø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