Izveido pilnīgu balss aģentu
Šajā lapā
Atjaunināts 2026. gada 2. novembrī — Audio modeļi. Vairāki šī kursa modeļi ir novecojuši:
tts-1,tts-1-hdungpt-4o-mini-ttspārtrauks darbu 2027. gada 6. janvārī (pēctecis:gpt-realtime-2.1-mini, ko OpenAI TTS rokasgrāmata norāda kā ** neatbalstītu ar/v1/audio/speech**: runas sintēzes migrācija pāriet uz Realtime API);gpt-realtime,gpt-4o-realtimeun vecie audio modeļi — 2027. gada 20. janvārī (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeun/v1/audio/translations— 2027. gada 26. februārī (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pilndupleksa balsij GPT-Live 1 ir pieejams API kopš 2026. gada 10. septembra.
Labots 2026. gada 3. novembrī. Ievades transkripcijā tika izmantots
gpt-live-transcribe, kas darbojas tikai transkripcijas sesijā un neatbalsta neserver_vad, nesemantic_vad. Sarunu sesijā, kāda ir šī, kur VAD apstiprina katru repliku, dokumentācija norāda izmantotgpt-transcribe, kas transkribē apstiprinātās replikas un izmanto iepriekšējās replikas kā kontekstu. Avoti: Realtime transkripcija · GPT-Transcribe · GPT-Live-Transcribe.
Izveido pilnīgu balss aģentu
Šī nodarbība apvieno visus līdz šim aplūkotos jēdzienus, lai izveidotu pilnībā funkcionējošu balss aģentu no sākuma līdz beigām. Tu izveidosi asistentu, kas klausās lietotāju, saprot viņa pieprasījumu, veic darbības un atbild ar balsi — viss reāllaikā, izmantojot Realtime API.
Aģenta arhitektūra
Četri moduļi un, pāri visam, viens ierobežojums, kas virza visu arhitektūru: viss notiek vienlaicīgi. Mikrofons ieraksta, kamēr modelis atbild, notikumi pienāk, kamēr atskaņo audio, un lietotājs var pārtraukt procesu jebkurā brīdī. Balss aģents nav jautājumu un atbilžu cikls; tā ir sistēma, kurā vairākas plūsmas virzās paralēli — tieši tāpēc turpmākajā tekstā mēs plaši izmantojam asyncio.
Klase VoiceAgent
Šī klase apkopo stāvokli, kas šīm paralēlajām plūsmām ir jākopīgo: savienojumu, pašreizējo sesiju un pašlaik atskaņoto atbildi. Tieši tāpēc, ka vairāki uzdevumi vienlaicīgi piekļūst šim stāvoklim, objekts ir piemērotāks nekā globālo mainīgo kopa — ja tev ir jāatceļ notiekoša atbilde, tev ir jāzina, ka tāda pastāv.
import asyncio
import json
import base64
import websockets
import sounddevice as sd
import numpy as np
import pyaudio
class VoiceAgent:
"""Pilnīgs balss aģents, kas balstīts uz 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):
"""Izveido savienojumu un konfigurē sesiju."""
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)
# Gaida session.created
event = json.loads(await self.ws.recv())
print(f"Sesija: {event['session']['id']}")
# Konfigurē
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("Balss aģents ir gatavs.")
async def start(self):
"""Sāk balss aģenta darbību."""
await self.connect()
await asyncio.gather(
self._capture_audio(),
self._process_events()
)
Audio uztveršanas modulis
async def _capture_audio(self):
"""Uztver mikrofona ievadi un nosūta to uz 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
}))
Notikumu apstrādes modulis
async def _process_events(self):
"""Apstrādā visus servera notikumus."""
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"\nKļūda: {event['error']['message']}")
finally:
player.close()
pa.terminate()
Rīku pārvaldības modulis
Šis modulis pārvērš aģentu no vienkārša balss čatbota par asistentu, kas spēj veikt darbības. Atšķirība no klasiskās funkciju izsaukšanas slēpjas laika ierobežojumā: lietotājs ir līnijā bez vizuāla progresa indikatora. Ja izpilde ilgst vairāk par sekundi vai divām, liec aģentam runāt, kamēr tas strādā — „Ļauj man to tev tūlīt pārbaudīt”, jo klusums balss sarunā izklausās pēc kļūmes.
async def _handle_response_done(self, event):
"""Apstrādā funkciju izsaukumus atbildē."""
response = event["response"]
function_calls = [
o for o in response.get("output", [])
if o["type"] == "function_call"
]
if not function_calls:
print() # Jauna rinda pēc transkripcijas
return
for call in function_calls:
name = call["name"]
args = json.loads(call["arguments"])
call_id = call["call_id"]
print(f"\n→ {name}({args})")
# Izpilda funkciju (pielāgo savai darījumdarbības loģikai)
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)
}
}))
# Lūdz modelim turpināt
await self.ws.send(json.dumps({"type": "response.create"}))
async def _execute_function(self, name: str, args: dict) -> dict:
"""Novirza funkcijas izsaukumu."""
# Implementē atbilstoši savai darījumdarbības loģikai
return {"error": f"Funkcija {name} nav implementēta"}
Palaid aģentu
async def main():
agent = VoiceAgent(
api_key="sk-...",
instructions=(
"Tu esi balss asistents Corsen AI. "
"Tu palīdzi lietotājiem pārvaldīt savas tikšanās "
"un iegūt informāciju par mūsu pakalpojumiem. "
"Atbildi franču valodā, kodolīgi un profesionāli."
),
tools=[
{
"type": "function",
"name": "check_availability",
"description": "Pārbauda pieejamību konkrētam laika slotam",
"parameters": {
"type": "object",
"properties": {
"date": {"type": "string"},
"service": {"type": "string"}
},
"required": ["date"]
}
}
]
)
await agent.start()
asyncio.run(main())
Galvenās atziņas
- Pilnīgs balss aģents apvieno četrus moduļus: audio, sesiju, rīkus un stāvokļa pārvaldību
- Klase
VoiceAgentencapsulē visu loģiku aiz vienkārša interfeisa asyncio.gatherļauj paralēli uztvert mikrofonu un apstrādāt notikumus- Pārtraukumu apstrāde (atbildes atcelšana, kad lietotājs sāk runāt) ir būtiska
- Rīki pārvērš aģentu no vienkārša balss čatbota par asistentu, kas spēj veikt darbības