Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Izveido pilnīgu balss aģentu

Nodarbība 14 no 18 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Izveido pilnīgu balss aģentu
  2. Aģenta arhitektūra
  3. Klase VoiceAgent
  4. Audio uztveršanas modulis
  5. Notikumu apstrādes modulis
  6. Rīku pārvaldības modulis
  7. Palaid aģentu
  8. Galvenās atziņas

Atjaunināts 2026. gada 2. novembrī — Audio modeļi. Vairāki šī kursa modeļi ir novecojuši: tts-1, tts-1-hd un gpt-4o-mini-tts pā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-realtime un 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-transcribe un /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 ne server_vad, ne semantic_vad. Sarunu sesijā, kāda ir šī, kur VAD apstiprina katru repliku, dokumentācija norāda izmantot gpt-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.

Audio
Uztveršana un atskaņošana
Sesija
WebSocket un konfigurācija
Rīki
Darījumdarbības darbības
Stāvoklis
Sarunu pārvaldība

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 VoiceAgent encapsulē 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