Grok Voice Agent API: Eine Möglichkeit, Echtzeit-Sprachassistenten zu entwickeln

Sprachgesteuerte KI-Agenten sind gerade voll angesagt. Die Leute wollen mit ihren Apps reden, statt was einzutippen, und die Technik ist endlich so gut, dass sich diese Gespräche natürlich anfühlen.

Wenn du einen bauen willst, ist die Grok Voice Agent API von xAI ein guter Ausgangspunkt. Es hat Reaktionszeiten von weniger als einer Sekunde und ist günstiger als die meisten anderen Optionen. Außerdem passt es einfach in den bestehenden OpenAI-Code.

Dieses Tutorial zeigt dir, wie du einen funktionierenden Sprachagenten von Grund auf neu erstellst. Mit LiveKit Cloud kannst du die Authentifizierung einrichten, Persönlichkeits- und Sprachoptionen konfigurieren, Tool-Anrufe hinzufügen und die Lösung in der Produktion einsetzen. Die API läuft auf Grok 3, das von xAI für Echtzeit-Sprachkonversationen angepasst wurde, statt für den üblichen Text-In-Text-Out-Workflow.

Was ist die Grok Voice Agent API?

Die Grok Voice Agent API ist die Echtzeit-Sprachkonversationsplattform von xAI, die im Dezember 2025 auf den Markt kam. Es verarbeitet Audio direkt, ohne die übliche Umwandlung von Sprache in Text und wieder zurück, was die Reaktionszeit verkürzt und gleichzeitig dafür sorgt, dass Gespräche natürlich klingen.

Bei den klassischen Sprach-KI-Systemen gibt's drei Schritte: Erstens wird die Sprache in Text umgewandelt, dann wird der Text durch ein Sprachmodell geschickt und schließlich wird die Antwort wieder in Audio umgewandelt. Dieser Ansatz funktioniert, aber jeder Wechsel zwischen den Komponenten sorgt für Verzögerungen. Wenn du Transkription, Verarbeitung und Synthese mit einrechnest, dauert es zwischen 500 ms und 1.000 ms, bis der Nutzer eine Antwort bekommt. Diese Pausen summieren sich und lassen Gespräche mechanisch wirken.

Grok Voice Agent lässt die Konvertierungen komplett weg. Das System nimmt Audio auf, verarbeitet es im Audiobereich und gibt Audio mit einem einzigen Modell aus, das auf Konversationssprache trainiert wurde. Diese Architektur sorgt dafür, dass der erste Ton im Schnitt nach 0,78 Sekunden zu hören ist, und unterstützt dabei Vollduplex-Kommunikation (also, wenn der Agent gleichzeitig zuhören und sprechen kann). So kann der Agent antworten, ohne auf die strikte Gesprächsreihenfolge warten zu müssen.

Einrichten deiner Grok Voice Agent-Umgebung

Um einen Sprachagenten mit Grok zu erstellen, musst du ihn mit LiveKit verbinden, einer Open-Source-WebRTC-Plattform. Grok liefert das KI-Modell für die Unterhaltung, während LiveKit die Echtzeit-Audioinfrastruktur verwaltet, die die Nutzer mit deinem Agenten verbindet. In diesem Abschnitt geht's um die Einrichtung beider Dienste.

Grok einrichten

Schau mal rein console.x.ai und mach ein Konto mit X, E-Mail, Google oder Apple. Für die xAI-Konsole brauchst du Prepaid-Guthaben, bevor du API-Aufrufe machen kannst. Kauf Credits über den Bereich „Abrechnung“.

Wenn du Guthaben auf deinem Konto hast, geh zu „API-Schlüssel“ und mach einen neuen Schlüssel. Der Schlüssel wird nur einmal auf dem Display angezeigt, also kopier ihn sofort und bewahr ihn sicher auf. Wenn du ihn verlierst, musst du einen neuen machen und deine Apps aktualisieren. Für eine ausführlichere Einführung in das API-Ökosystem von xAI schau dir das Grok 3 API-Tutorial.

LiveKit einrichten

LiveKit ist eine WebRTC-Infrastruktur für Echtzeit-Audio und -Video. Es kümmert sich um die Audio-Transportschicht, die Grok braucht, um mit den Nutzern zu verbinden. Beim Aufbau eines Sprachagenten kümmert sich LiveKit um die Räume, in denen Gespräche stattfinden, leitet Audio-Streams zwischen den Teilnehmern weiter und stellt die Infrastruktur für die Bereitstellung bereit. Das LiveKit Agents-Framework kümmert sich um die ganze Komplexität, sodass du dich auf das Verhalten der Agenten konzentrieren kannst, während es sich um Verbindungsmanagement, Audiokodierung und Turn-Erkennung kümmert.

Das Framework unterstützt mehrere KI-Anbieter, darunter auch xAI. Es gibt einen Testbereich, auf den du über eine Webschnittstelle zugreifen kannst. Dort kannst du deinen Agenten vor dem Einsatz überprüfen.

Melde dich an unter Cloud.livekit.io. Die kostenlose Stufe bietet genug Ressourcen für die Entwicklung und das Testen. Mach ein Projekt über das Dashboard. Geh zu „Einstellungen“ und dann zu „API-Schlüssel“. Kopiere drei Anmeldedaten: LIVEKIT_URL (der WebSocket-Endpunkt deines Projekts), LIVEKIT_API_KEY (die öffentliche Kennung) und LIVEKIT_API_SECRET (der private Authentifizierungsschlüssel). Diese Anmeldedaten bestätigen deinen Agentencode bei deinem LiveKit Cloud-Projekt.

Abhängigkeiten installieren und konfigurieren

Installiere die benötigten Pakete:

uv add "livekit-agents[xai,openai]>=1.3.10" python-dotenv

Damit installierst du das LiveKit-Agenten-Framework mit dem xAI-Plugin und den OpenAI-Abhängigkeiten (das xAI-Plugin basiert auf der Kompatibilität mit der Echtzeit-API von OpenAI) sowie python-dotenv für die Verwaltung von Umgebungsvariablen.

Mach eine Datei namens „ .env “ in deinem Projektverzeichnis:

XAI_API_KEY=xai-YourActualKeyHere
 LIVEKIT_URL=wss://your-project.livekit.cloud
 LIVEKIT_API_KEY=APIYourKeyHere
 LIVEKIT_API_SECRET=YourSecretHere

Ersetze die Platzhalterwerte durch deine echten Anmeldedaten. Lade diese Anmeldedaten in deinen Python-Code:

from dotenv import load_dotenv
 load_dotenv()

Dadurch sind die Anmeldedaten sowohl für die xAI- als auch für die LiveKit-Bibliotheken verfügbar. Füge „ .env “ zu deiner „.gitignore “ hinzu, um zu verhindern, dass Anmeldedaten in der Versionskontrolle durchsickern.

Deinen ersten Grok-Sprachassistenten erstellen

Sobald deine Umgebung eingerichtet ist, kannst du einen funktionierenden Sprachagenten erstellen. Fang mit den Importen und der Agent-Klasse in einer neuen Datei namens „ agent.py ” an:

from livekit.agents import Agent, AgentSession, AgentServer, JobContext, cli
from livekit.plugins.xai import realtime
from dotenv import load_dotenv

load_dotenv()

class ResearchAssistant(Agent):
	def __init__(self):
    	super().__init__(
        	instructions="You are a research assistant who helps users find information.",
 	)

Deine Unterklasse „ Agent ” enthält nur die Anweisungen, die bestimmen, wie der Agent reagiert. Die funktionieren wie eine Systemaufforderung und sagen dem Agenten, welche Rolle er spielen soll. Die eigentliche Modellkonfiguration ist woanders.

Als Nächstes richtest du den Server und den Verbindungshandler ein:

server = AgentServer()


@server.rtc_session()
async def entrypoint(ctx: JobContext):
	await ctx.connect()

 	session = AgentSession(
         llm=realtime.RealtimeModel(voice="ara"),
 	)

 	await session.start(
     	room=ctx.room,
     	agent=ResearchAssistant(),
 	)

Der Dekorator ` @server.rtc_session() ` sagt LiveKit, dass es deine Einstiegsfunktion ausführen soll, sobald jemand eine Verbindung herstellt. Im Inneren übernimmt „ AgentSession “ die Modellkonfiguration, einschließlich der Auswahl einer der sieben Stimmen von Grok (Ara, Eve, Leo, Sal, Rex, Mika oder Valentin). Wenn „ session.start() “ läuft, verbindet es deinen Agenten mit dem LiveKit-Raum, wo die Unterhaltung stattfindet.

Bei Sprachgesprächen wartet man auf Audioeingabe und -ausgabe, ohne das Programm anzuhalten. Deshalb nutzt die Funktion async def und await , um diese Vorgänge gleichzeitig zu erledigen.

Zum Schluss noch den Einstiegspunkt hinzufügen:

if __name__ == "__main__":
 	cli.run_app(server)

Lass deinen Agenten im Entwicklungsmodus laufen:

uv run agent.py dev

Das Terminal zeigt die Startsequenz an: Initialisierung der Worker, HTTP-Server, der auf einem lokalen Port lauscht, und Registrierung bei deinem LiveKit Cloud-Projekt.

Um den Agenten zu testen, geh einfach auf dein LiveKit Cloud-Dashboard unter cloud.livekit.io. Such dein Projekt aus und klick dann in der Seitenleiste auf den Reiter „Sandbox“. Wähle „Web Voice Agent“ aus den Vorlagen aus.

Die Vorlagenseite zeigt eine Vorschau der Sprachschnittstelle und Details zu den enthaltenen Funktionen. Klick einfach auf den Button „Sandbox erstellen“.

Im angezeigten Modal kannst du eine eigene URL einrichten, Funktionen wie Kamera und Bildschirmfreigabe aktivieren und die Einstellungen für das Aussehen anpassen. Die Standardeinstellungen funktionieren gut für Testzwecke, also klick auf „Erstellen“ und dann auf „Fertig“.

Zurück auf der Sandbox-Seite findest du deine neue Sandbox unter „Sandbox-Apps”. Klick auf „Starten“, um es zu öffnen.

Klick auf „Anruf starten“ und gib die Mikrofonberechtigungen frei, wenn du dazu aufgefordert wirst. Achte auf die Terminal-Meldung, die zeigt, dass der Agent bereit ist, Audio zu empfangen:

DEBUG livekit.agents start reading stream {"participant": "...", "source": "SOURCE_MICROPHONE", ...}

Sobald diese Nachricht da ist, kommen die Antworten schnell.

Wenn du nach etwas fragst, auf das der Agent keinen Zugriff hat (wie das aktuelle Wetter in einer bestimmten Stadt), erklärt er dir seine Grenzen, anstatt irgendwas zu erfinden.

So fügst du Tools zu deinen Grok Voice Agents hinzu

Der einfache Agent kann sich unterhalten, kann aber nichts nachschlagen. Mit Tool Calling kann Grok mitten im Gespräch Funktionen ausführen und über die Ergebnisse reden. Du kannst die Tools von xAI nutzen oder deine eigenen Tools machen.

Mit den eingebauten Tools arbeiten

Das xAI-Plugin hat „ WebSearch ” für allgemeine Web-Suchanfragen und „ XSearch ” zum Suchen von Beiträgen auf X. Importiere sie und gib sie an „AgentSession ” weiter :

from livekit.agents import Agent, AgentSession, AgentServer, JobContext, cli
from livekit.plugins.xai import realtime
from livekit.plugins.xai.realtime import WebSearch, XSearch
from dotenv import load_dotenv

load_dotenv()


class ResearchAssistant(Agent):
 	def __init__(self):
     	super().__init__(
             instructions="""You are a research assistant with access to web search and X search.

- Use web search for general queries and current information
- Use X search when users ask about posts or what people are saying on X/Twitter

Always mention your sources when providing information.""",
     	)


server = AgentServer()


@server.rtc_session()
async def entrypoint(ctx: JobContext):
	await ctx.connect()

	session = AgentSession(
         llm=realtime.RealtimeModel(voice="ara"),
     	tools=[
         	WebSearch(),
         	XSearch(),
     	],
 	)

 	await session.start(
     	room=ctx.room,
     	agent=ResearchAssistant(),
 	)


if __name__ == "__main__":
 	cli.run_app(server)

Der Parameter „ tools “ nimmt eine Liste von Werkzeugobjekten an. Starte den Agenten und probier ihn mit Fragen wie „Was gibt's Neues zum Thema KI?“ oder „Was sagen die Leute über Grok auf X?“ aus. Die Terminalprotokolle zeigen vielleicht Warnungen zu unbekannten AI-Funktionen wie „ web_search_with_snippets “ oder „x_semantic_search “, aber die Tools liefern trotzdem aktuelle Infos.

Das Vollduplex-Audio von Grok fällt auch bei der Nutzung von Tools auf. Du kannst den Agenten unterbrechen, während er spricht, und er hört auf, hört zu und passt seine Antwort an. Dadurch fühlen sich die Gespräche weniger roboterhaft an als bei Systemen, bei denen man warten muss, bis der Agent fertig ist, bevor man selbst sprechen kann.

Benutzerdefinierte Tools hinzufügen

Die integrierten Tools decken gängige Anwendungsfälle ab, aber wenn du deine eigenen Tools definierst, hast du die Kontrolle über Parameter, Fehlerbehandlung und welche APIs aufgerufen werden sollen. In diesem Abschnitt wird gezeigt, wie man mit Firecrawls Such-Endpunkt, der Filteroptionen wie „ limit “, „ lang “ und „country “ bietet , die die integrierte Websuche nicht hat.

Melde dich an unter firecrawl.dev. Die kostenlose Stufe hat 500 Credits und man braucht keine Kreditkarte. Installier das SDK und füg deinen Schlüssel zu „ .env “ hinzu:

uv add firecrawl-py

FIRECRAWL_API_KEY=fc-your-key-here

Benutzerdefinierte Tools sind Methoden, die mit ` @function_tool()` gekennzeichnet sind. Aktualisiere die Importe in „ search_agent.py “:

from livekit.agents import (
 	Agent,
 	AgentSession,
 	AgentServer,
 	JobContext,
 	cli,
 	function_tool,
 	RunContext,
 )

from livekit.plugins.xai import realtime
from livekit.plugins.xai.realtime import XSearch
from firecrawl import FirecrawlApp
from dotenv import load_dotenv

import os 
load_dotenv()

Die Ergänzungen sind „ function_tool “ für den Dekorator, „ RunContext “, das an Tool-Funktionen weitergegeben wird, und „ FirecrawlApp “ für den Firecrawl-Client. „WebSearch “ wurde entfernt, weil es durch das benutzerdefinierte Tool ersetzt wird.

Definiere das Tool als Methode in deiner Agent-Klasse:

class ResearchAssistant(Agent):
 	def __init__(self):
     	super().__init__(
             instructions="""You are a research assistant with access to web search and X search.

 - Use Firecrawl search for general queries and current information
 - Use X search when users ask about posts or what people are saying on X/Twitter

 Always mention your sources when providing information.""",
     	)
     	self.firecrawl = FirecrawlApp(api_key=os.getenv("FIRECRAWL_API_KEY"))

 	@function_tool()
     async def search_web(
     	self,
     	context: RunContext,
     	query: str,
 	) -> dict:
     	"""Search the web for current information using Firecrawl.

     	Args:
         	query: The search query
     	"""
     	result = self.firecrawl.search(query, limit=3)
     	return {
         	"results": [
             	{
                 	"title": item.title,
                 	"url": item.url,
                     "description": item.description,
             	}
             	for item in result.web
         	]
     	}

Grok liest die Docstring, um zu verstehen, was das Tool macht. Wenn du fragst: „Wie ist der aktuelle Wechselkurs von USD zu EURO?“, extrahiert Grok die Anfrage, ruft deine Funktion auf und integriert die Ergebnisse in seine Antwort.

Methoden, die mit „ @function_tool() “ gekennzeichnet sind, werden automatisch registriert. Also, streiche „WebSearch() “ aus der Liste der Tools:

session = AgentSession(
     llm=realtime.RealtimeModel(voice="ara"),
 	tools=[
     	XSearch(),
 	],
 )

Starte den aktualisierten Agenten:

uv run search_agent.py dev

Das Terminal zeigt die Ausführung des Tools an:

DEBUG livekit.agents executing tool {
 	"function": "search_web",
 	"arguments": "{\"query\":\"current USD to EURO exchange rate\"}",
 	...
 }
DEBUG livekit.agents tools execution completed {...}

In meinen Tests hat Firecrawl die Ergebnisse in etwa zwei Sekunden geliefert. Du kannst mehrere benutzerdefinierte Tools mit den integrierten Tools im selben Agenten kombinieren. Ein Kundensupport-Mitarbeiter könnte zum Beispiel XSearch zusammen mit den Tools „ lookup_order() “ und „check_inventory() “ nutzen, die mit internen Datenbanken verbunden sind.

Anpassen der Kurvenerkennung

Die Standardeinstellungen für die Erkennung von Gesprächswechseln funktionieren bei normalen Gesprächen gut. Anpassungen sind nötig, wenn die Umgebung oder das Verhalten der Nutzer nicht der Norm entspricht. Ein lauter Raum kann dazu führen, dass der Agent auf Hintergrundgeräusche reagiert, während ein Nutzer, der kurz innehält, um seine Gedanken zu sammeln, unterbrochen werden könnte, bevor er fertig ist.

from livekit.plugins.xai import realtime
from openai.types.beta.realtime.session import TurnDetection

session = AgentSession(
 	llm=realtime.RealtimeModel(
     	voice="ara",
     	turn_detection=TurnDetection(
         	type="server_vad",
         	threshold=0.5,
         	prefix_padding_ms=300,
         	silence_duration_ms=200,
     	),
 	),
 )

Der Parameter „ threshold “ legt fest, wie laut Audio sein muss, damit es als Sprache gilt, und reicht von 0,0 bis 1,0. Wenn du diesen Wert auf 0,7 oder höher stellst, hilft das in lauten Umgebungen, wo sonst Hintergrundgeräusche Reaktionen auslösen könnten.

Der Parameter „ prefix_padding_ms “ entscheidet, wie viel Audio vor dem erkannten Beginn der Sprache aufgenommen wird. Die Standardeinstellung von 300 ms verhindert, dass die erste Silbe abgeschnitten wird. Mach das größer, wenn Leute sagen, dass ihre ersten Worte abgeschnitten werden.

Der Parameter „ silence_duration_ms “ legt fest, wie lange der Agent wartet, nachdem du aufgehört hast zu sprechen, bevor er antwortet. Bei 200 ms fühlen sich Unterhaltungen reaktionsschnell an. Wenn du das auf 400 oder 500 ms hochziehst, ist das gut für Leute, die mitten im Satz innehalten oder langsamer reden.

Für Push-to-Talk-Schnittstellen oder Telefonsysteme, bei denen du die Unterhaltung genau steuern musst, deaktiviere die automatische Gesprächserkennung:

session = AgentSession(
 	llm=realtime.RealtimeModel(
     	voice="ara",
     	turn_detection=None,
 	),
 )

Der Agent wartet dann auf ein programmatisches Signal, bevor er antwortet, anstatt auf Stille zu warten.

Grok Voice Agent in der Produktion einsetzen

Der Entwicklungsmodus verbindet den Agenten mit deinem lokalen Rechner. Für eine Produktionsumgebung, die rund um die Uhr läuft und sich nach Bedarf anpassen lässt, hostet LiveKit Cloud deinen Agenten auf ihrer Infrastruktur.

Vorbereitung für die Bereitstellung

Die LiveKit-CLI erkennt deinen Projekttyp anhand von Abhängigkeitsdateien. Mach eine Datei namens „ requirements.txt “ in deinem Agent-Verzeichnis:

livekit-agents[xai,openai]>=1.3.10
python-dotenv>=1.2.1
firecrawl-py>=4.12.0

Mach eine eigene Datei für Produktionsgeheimnisse. LiveKit Cloud stellt automatisch LIVEKIT_URL, LIVEKIT_API_KEY und LIVEKIT_API_SECRET zur Verfügung, sodass du nur noch deine anderen API-Schlüssel hinzufügen musst:

XAI_API_KEY=xai-your-key-here
FIRECRAWL_API_KEY=fc-your-key-here

Speicher das als „ .env.production ” und füge es zu „.gitignore ” hinzu .

Den Agenten einrichten

Mach die CLI mit deinem LiveKit Cloud-Konto fertig:

lk cloud auth

Das öffnet einen Browser, um deine CLI mit deinem Projekt zu verbinden. Sobald du dich angemeldet hast, installier den Agenten:

lk agent create --secrets-file .env.production

Die CLI registriert deinen Agenten, erstellt eine Dockerfile, baut das Container-Image und stellt es in der LiveKit Cloud bereit. Die Protokolle werden beim Start des Agenten an dein Terminal übertragen:

{"message": "registered worker", "level": "INFO", "name": "livekit.agents", "url": "https://your-project.livekit.cloud", "region": "Germany 2", ...}

Schau dir den Bereitstellungsstatus an:

lk agent status

┌─────────────────┬─────────────────┬────────────┬─────────┬────────┬─────────┬───────────┐
 │ ID          	│ Version     	│ Region 	│ Status  │ CPU	│ Mem 	│ Replicas  │
 ├─────────────────┼─────────────────┼────────────┼─────────┼────────┼─────────┼───────────┤
 │ CA_AAVy5WbUYpmA │ v20260109102531 │ eu-central │ Running │ 0m / 2 │ 0 / 4GB │ 0 / 1 / 1 │
 └─────────────────┴─────────────────┴────────────┴─────────┴────────┴─────────┴───────────┘

Wie Nutzer auf deinen Agenten zugreifen

Die URL in den Bereitstellungsprotokollen (https://your-project.livekit.cloud) ist das WebSocket-Backend, keine Benutzeroberfläche. Die Nutzer kommunizieren mit deinem Agenten über ein Frontend, das mit diesem Backend verbunden ist.

Die Sandbox, die du vorhin erstellt hast, ist dafür da. Geh zu deinem LiveKit-Dashboard, öffne den Bereich „Sandbox“ und kopier deine Sandbox-URL. Diese URL ist öffentlich zugänglich und funktioniert ohne Authentifizierung. Teile es mit den Nutzern, damit sie sofort mit deinem Agenten chatten können.

Für ein markenspezifisches Erlebnis kannst du das Aussehen der Sandbox im Dashboard anpassen (Logo, Farben, Schaltflächentext) oder dein eigenes Frontend mit LiveKits JavaScript SDK.

Bereitstellungen verwalten

Schau dir Echtzeitprotokolle von deinem eingesetzten Agenten an:

lk agent logs

Mach Updates, nachdem du deinen Code geändert hast:

lk agent deploy --secrets-file .env.production

LiveKit nutzt rollierende Bereitstellungen. Neue Instanzen kümmern sich um neue Sitzungen, während die alten ihre laufenden Gespräche zu Ende bringen, sodass Updates keine Ausfallzeiten verursachen.

Wenn was kaputt geht, mach einfach eine frühere Version wieder gut:

lk agent rollback

Der eingesetzte Agent läuft unabhängig von deinem lokalen Rechner. Mach dein Terminal dicht, schalt deinen Computer aus, und der Agent reagiert weiter auf Benutzer. LiveKit Cloud kümmert sich um die Skalierung, sodass bei Traffic-Spitzen automatisch zusätzliche Instanzen hochgefahren werden.

Bereitstellungskosten

Wenn du einen Grok-Sprachagenten in der Produktion einsetzt, fallen zwei Kosten an: die API von xAI und das Hosting von LiveKit.

xAI kostet 0,05 $ pro Minute für Sprachgespräche. LiveKit Cloud kostet 0,01 $ pro Minute, die ein Agent in einer Sitzung ist. Insgesamt kannst du mit ungefähr 0,06 $ pro Minute rechnen, wenn dein Agent aktiv für Nutzer da ist.

Der kostenlose Tarif von LiveKit (Build-Plan) umfasst 1.000 Minuten Agentensitzungen pro Monat, ohne dass du eine Kreditkarte brauchst. Das reicht für ungefähr 16 Stunden Gesprächszeit, was für Tests und Anwendungen mit wenig Datenverkehr okay ist. Die kostenpflichtigen Tarife fangen bei 50 $ pro Monat an, mit 5.000 Minuten inklusive und höheren Begrenzungen für die gleichzeitige Nutzung.

Der Agent kostet nichts, wenn er nicht gebraucht wird. Gebühren fallen nur während aktiver Gespräche an, sodass für eine Bereitstellung, die über Nacht nicht genutzt wird, keine LiveKit-Gebühren anfallen. Die Abrechnung von xAI folgt dem gleichen Muster und misst nur die tatsächliche API-Nutzung. Während meiner Experimente beim Schreiben dieses Artikels habe ich insgesamt 78 Cent für xAI ausgegeben, wobei LiveKit durch die kostenlose Version abgedeckt war.

Fazit

Du hast jetzt einen Sprachassistenten, der zuhört, denkt und antwortet. Der Agent verbindet sich über Tools mit Live-Daten, passt sein Listening-Verhalten an verschiedene Umgebungen an und läuft auf einer Infrastruktur, die ohne manuelles Eingreifen skaliert werden kann.

Die hier behandelten Codemuster lassen sich auch auf andere Anwendungsfälle anwenden. Tausch die Anweisungen für Forschungsassistenten gegen Kundensupport-Richtlinien aus und füge Tools hinzu, die deine Bestelldatenbank abfragen. Mach einen Sprachlehrer, der nach Beispielsätzen sucht. Mach eine Sprachschnittstelle für deine vorhandene API.

xAI will eigenständige Text-to-Speech- und Speech-to-Text-Endpunkte rausbringen, die hybride Architekturen ermöglichen, bei denen man die Sprachfunktionen von Grok mit anderen Sprachmodellen kombinieren kann. Im Moment kümmert sich die Voice-Agent-API um die ganze Pipeline.

Die LiveKit Agents-Dokumentation geht auf weitere Funktionen wie Multi-Agent-Handoffs und Sitzungsfortführung ein. Die xAI-Dokumente gehen genauer auf Audioformate und Unternehmensfunktionen ein.