Erste Schritte mit der Gemini Live API

Wenn du schon einmal einen Sprachassistenten bauen wolltest, kennst du die typische, etwas holprige Pipeline: Du zeichnest die Stimme des Users auf, transkribierst sie mit einem STT-Modell, schickst den Text an ein LLM, wartest auf die Antwort und jagst sie dann durch eine TTS-Engine. 

Bis die Antwort zu hören ist, vergehen mehrere Sekunden unangenehme Stille. Das fühlt sich weniger wie ein Gespräch an und mehr wie ein langsamer Request-Response-Zyklus. 

Die Gemini Live API bricht diesen Ablauf auf, indem sie kontinuierliches Audio- und Videostreaming über eine zustandsbehaftete WebSocket-Verbindung erlaubt. Weil das Modell Audio nativ verarbeitet und ausgibt, reagiert es sofort, passt sich an natürliche Stimmnuancen an und kann sogar Unterbrechungen mitten im Satz verarbeiten (Barge-in). 

In diesem Tutorial zeige ich dir, wie du mit dem Code-first Google Agent Development Kit (ADK) einen Real-Time AI Travel Concierge baust. Wir rüsten unseren Agenten mit Google Search für Live-Wetterabfragen am Reiseziel aus, binden eine Mock-Flugdatenbank an und starten ein lokales Developer-Interface, um Echtzeitdialog und Tool-Aufrufe zu testen.

Wenn du neu im Ökosystem bist, empfehle ich, mit dem Building AI Agents with Google ADK Kurs zu starten, um dir die Grundlagen zu erarbeiten.

Was du erreichen wirst: 

• Verstehe Funktionsweise, Möglichkeiten und Preise der Gemini Live API.
• Richte eine Python-Umgebung mit dem Google Agent Development Kit ein. 
• Stelle dem Sprachassistenten sowohl integrierte Tools (Google Search) als auch eigene Business-Logik (Abfragen des Flugstatus aus einer Datenbank) zur Verfügung. 
• Starte ein lokales Web-UI, um live mit deinem Reiseagenten zu sprechen.

Voraussetzungen: 

• Grundkenntnisse in Python. 
• Ein Google Cloud Projekt (für Vertex AI) oder ein Google AI Studio API-Schlüssel.

Was ist die Gemini Live API? 

Im Kern ist die Gemini Live API ein Entwickler-Tool von Google, mit dem du Echtzeit-Voice- und Vision-Interaktionen mit Gemini-Modellen aufbauen kannst. Statt auf turnbasierte Textantworten zu warten, ermöglicht sie fortlaufende, natürliche Gespräche zwischen User und KI-Agent. 

Technisch ist die Gemini Live API für bidirektionales Echtzeit-Streaming ausgelegt. Anders als stateless HTTP-REST-APIs mit Request-Response-Zyklen setzt die Live API auf eine zustandsbehaftete, persistente WebSocket-(WSS)-Verbindung. Über diesen offenen Kanal streamt der Client Roh-Audio, Video (als Bildframes mit ~1 FPS) und Text, während das Modell sofort natives Audio und Text zurückstreamt.

Zentrale Fähigkeiten von Gemini Live

• Barge-in (Unterbrechbarkeit): In einem natürlichen Gespräch warten wir nicht, bis die andere Person einen ganzen Absatz beendet hat, wenn wir etwas klären müssen. Gemini Live unterstützt Barge-in out of the box: User können die Sprachausgabe des Modells mitten im Satz unterbrechen, der Server stoppt sofort den Audiostream und passt sich der neuen Eingabe an.
• Affektiver Dialog und natives Audio: Statt Text zu erzeugen und an eine Text-to-Speech-(TTS)-Engine zu übergeben, verarbeiten und erzeugen Modelle wie gemini-live-2.5-flash-native-audio und gemini-3.1-flash-live-preview Audio nativ. So bleiben emotionale Nuancen, Lachen, Tonalität und Sprachrhythmus erhalten – die Interaktion wirkt deutlich menschlicher. 
• Multimodale Eingaben und Tool-Nutzung: Die Live API ist nicht auf Audio beschränkt. Sie kann über Videoframes deine Umgebung „sehen“ und externe Funktionen oder Tools (z. B. Google Search oder eigene APIs) in Echtzeit auslösen und die Ergebnisse zurück in den Sprachstrom speisen.

Gemini Live API: Preise

Echtzeit-Streaming nutzt eine kontinuierliche, bidirektionale Verbindung – entsprechend unterscheidet sich das Abrechnungsmodell von klassischen, statischen Text-APIs. Google bietet eine großzügige Free Tier zum Prototyping in Google AI Studio sowie eine produktionsreife, kostenpflichtige Stufe auf Vertex AI. 

Das Modell gemini-3.1-flash-live-preview wird pro Million Tokens abgerechnet oder 

für Audio- und Videomedien direkt in eine dauerbasierte Metrik umgerechnet:

Wenn du prototypisierst, empfehle ich, zunächst kostenlos in Google AI Studio zu testen. Der Zugriff ist großzügig, unterliegt aber Rate Limits. 

Sobald du skalieren willst, kannst du dein Projekt für produktive Pay-as-you-go-Bereitstellung zu Vertex AI umziehen – mit garantiertem Durchsatz und Enterprise-SLAs.

So erhältst du Zugriff auf die Gemini Live API

Als Developer hast du mehrere Architekturoptionen für die Live API. Da sie auf WebSockets basiert, ist dein Verbindungsrouting für Latenz und Sicherheit entscheidend.

Client-zu-Server vs. Server-zu-Server

• Client-zu-Server: Dein Frontend (z. B. Web- oder Mobile-App) verbindet sich direkt mit Googles WebSocket-Endpunkt. Das ist die beste Option für minimale Latenz, weil der Audiostream keine zusätzlichen Hops macht. 
• Du darfst jedoch keine Google-Cloud-API-Schlüssel im Frontend exponieren; implementiere stattdessen eine Authentifizierung mit temporären, kurzlebigen Tokens für sicheren Clientzugriff.
• Server-zu-Server: Dein Frontend streamt Audio an deinen eigenen Backend-Server, der dann den WebSocket zur Gemini Live API öffnet. Das ist sehr sicher und erlaubt dir Backend-Logik (z. B. User-Auth oder Datenbankabfragen) einzubinden, fügt aber dem Audiostream eine geringe Netzwerklatenz hinzu.

SDKs und Partnerintegrationen

Du kannst zwar reinen WebSocket-Code schreiben, am einfachsten startest du aber mit Googles GenAI SDK oder dem Agent Development Kit (ADK). 

Für Enterprise-Produktionsszenarien hat sich das Ökosystem rasant in Richtung WebRTC-Integrationen entwickelt. Plattformen wie LiveKit, Pipecat von Daily, Twilio und Voximplant stellen robuste Infrastruktur für Netzjitter, Echounterdrückung und Echtzeit-Audiorouting direkt in die Gemini Live API bereit.

Einen Echtzeit-Sprachassistenten mit der Gemini Live API bauen

Lass uns das praktisch umsetzen. Wir bauen einen AI Travel Concierge. 

Dieser Agent nutzt die Gemini Live API für Sprachdialoge und erhält zusätzlich Zugriff auf eigene Python-Funktionen, um während des Gesprächs Echtzeit-Flugstatus abzufragen.

Wir verwenden das Google Agent Development Kit (ADK) und das leistungsstarke gemini-3.1-flash-live-preview Modell, das sowohl für klassische Text-Turns als auch für Echtzeit-WebSocket-Streaming optimiert ist.

1. Umgebung einrichten

Zuerst richtest du eine Python-virtuelle Umgebung ein und installierst das benötigte ADK-Paket. Führe diese Befehle im Terminal aus:

# Create and activate a virtual environment
python3 -m venv .venv
source .venv/bin/activate
# Install the Agent Development Kit
pip install google-adkBereitgestellt von

Als Nächstes konfigurierst du deine Umgebungsvariablen, damit sich das ADK sicher bei deinem Google-Cloud-Projekt authentifizieren kann:

export GOOGLE_CLOUD_PROJECT="your-project-id" 
export GOOGLE_CLOUD_LOCATION="us-central1"Bereitgestellt von

Wenn du stattdessen einen Gemini API Key aus Google AI Studio nutzt, lege im Projekt-Root eine .env-Datei an:

GEMINI_API_KEY=your_google_ai_studio_api_keyBereitgestellt von

2. Den Gemini-Live-Agent initialisieren 

Erstelle eine Datei namens agent.py in deinem Projektordner. Das ADK erkennt und startet automatisch die Variable root_agent. Im folgenden Code definieren wir eine eigene Python-Funktion zur Abfrage des Flugstatus und übergeben sie direkt an den Toolbelt des Agenten. Initialisiere das Agent-Verzeichnis: 

mkdir voice_assistant 
touch voice_assistant/__init__.py 
touch voice_assistant/agent.pyBereitgestellt von

Mache das Agent-Paket in voice_assistant/__init__.py verfügbar:

from . import agentBereitgestellt von

3. Agent definieren und eigene Tools bereitstellen 

Öffne voice_assistant/agent.py und schreibe die Konfiguration für den Reiseagenten. Im folgenden Code definieren wir eine Standard-Python-Funktion check_flight_status. 

Im Google ADK wird jede Python-Funktion mit korrekten Typannotationen und Docstring automatisch in ein Agent-Tool konvertiert. Das LLM nutzt die Docstring-Beschreibung und Parameter, um zu entscheiden, wann und wie die Funktion aufgerufen wird. 

Modellkonfiguration 

Gemini 3.1 Flash Live Preview nutzen: Um in der ADK-Dev-Server-Umgebung beide Interaktionsmodi zu unterstützen – Standard-Textchat (über REST generateContent) und die Echtzeit-bidirektionale WebSocket-Mikrofonschnittstelle – setzen wir das Modell explizit auf gemini-3.1-flash-live-preview.

Im Gegensatz zu älteren reinen Streaming-Modellen, die bei Standard-HTTP-REST-Anfragen 404 Not Found zurückgeben, unterstützt gemini-3.1-flash-live-preview nativ sowohl REST-Content-Generierung als auch zustandsbehaftetes WebSocket-Streaming.

from google.adk.agents.llm_agent import Agent
from google.adk.tools import google_search
def check_flight_status(flight_no: str) -> str:
   """Check the real-time flight status (e.g. delays, gate info, cancellations).
   Args:
       flight_no: The flight number to look up (e.g., AA120, DL450, UA990).
   """
   flight_no = flight_no.upper().strip()
   if "AA120" in flight_no:
       return "Flight AA120 to Paris is currently delayed by 45 minutes due to air traffic control. New departure time: 3:15 PM. Gate status: B22."
   elif "DL450" in flight_no:
       return "Flight DL450 to London is on time. Gate status: Boarding now at Gate C10."
   elif "UA990" in flight_no:
       return "Flight UA990 to Tokyo is cancelled due to adverse weather conditions at the destination. Passengers are advised to rebook at the counter."
   else:
       return f"Flight {flight_no} is currently scheduled on time. No delay reports found in the flight database."
# Define the root agent with search grounding and custom database flight checks
root_agent = Agent(
   model='gemini-3.1-flash-live-preview',
   name='root_agent',
   description='A real-time AI Travel Concierge with flight tracking and search grounding.',
   instruction=(
       'You are an expert AI Travel Concierge. You assist users with real-time flight status checkups, '
       'destination recommendations, and general travel planning. '
       'Always answer professionally and conversationally. '
       'Use the check_flight_status tool when a user asks about a specific flight status. '
       'Use Google Search to look up weather, transit conditions, or travel advisories at destinations.'
   ),
   tools=[google_search, check_flight_status],
)Bereitgestellt von

4. Interaktives Dev-UI starten und testen

Das ADK bringt einen integrierten Entwicklungsserver und ein Web-UI mit. Damit testest du deinen Agenten lokal, ohne Frontend-Code zu schreiben. Starte den Webserver aus deinem Workspace:

.venv/bin/adk web .Bereitgestellt von

Du solltest eine Ausgabe sehen, die den Start des Servers bestätigt:

1. Öffne http://127.0.0.1:8000 in deinem Browser.
2. Wähle deinen Agenten aus der Anwendungsliste.
3. Klicke auf das Mikrofon, um eine Live-Session zu starten.

Wähle in der Liste root_agent aus, um die Chat-Oberfläche zu öffnen.

4. Sprich ins Mikrofon: Kannst du den Status des Flugs AA120 prüfen? Der Agent analysiert deine Anfrage, erkennt den Bedarf an Datenbankinformationen, ruft die eigene Python-Funktion check_flight_status auf und zeigt das JSON-Ergebnis des Tool-Calls an, bevor er dir die Antwort vorspricht.

5. Google Search Grounding testen:  Frage den Concierge als Nächstes nach dem Wetter am Ziel: Wie ist das Wetter in London gerade? Der Agent aktiviert das integrierte google_search Tool, durchsucht das Web und fasst die aktuellen Bedingungen in seiner Audioausgabe zusammen.

6. Barge-in-Feature testen: Stelle eine offene Frage wie: Erzähl mir von den besten historischen Sehenswürdigkeiten in Rom. Wenn der Agent mit der Liste beginnt, sprich laut dazwischen: Moment mal! Prüfe stattdessen Flug UA990!. Der Agent stoppt den Audiostream sofort, bricht die Rom-Details ab, ruft das Custom-Flight-Tracker-Tool auf und meldet, dass Flug UA990 annulliert wurde. Das demonstriert die niedrige Latenz und die Vollduplex-Eigenschaften der Live-API-Verbindung.

Best Practices für den produktiven Einsatz der Gemini Live API

Echtzeit-Sprachanwendungen stellen besondere Anforderungen an Prompt-Architektur, Netzwerkzustände, Audioeingang und Ressourcenskalierung. Hier sind zentrale Best Practices nach offiziellen Entwicklerleitfäden.

1. Klare Systemanweisungen entwerfen

Um die beste Performance aus Gemini Live zu holen, strukturiere deine System Instructions (SIs) strikt: Persona, Gesprächsregeln und Guardrails.

• Getrennte Personas: Beschränke die Rolle jedes Agenten auf eine einzelne, eigenständige Systemanweisung, statt eine Persona zu überladen.
• Gesprächsabläufe trennen: Trenne explizit einmalige Elemente (z. B. „Frage den User einmalig nach Name und Ticketnummer“) von offenen Gesprächsschleifen (z. B. „Beantworte beliebig viele Fragen zu Reiseempfehlungen“).
• Tool-Aufrufe als Sätze formulieren: Beschreibe die Tool-Nutzung schrittweise. Beispiel: „Bitte zuerst die Ticketnummer erfragen. Dann look_up_ticket mit dieser Nummer aufrufen.“
• Sprachkonsistenz erzwingen: Native Audio-Modelle können bei Kontextwechsel die Sprache wechseln. Wenn dein Agent nur Englisch sprechen soll, zwinge es in der Instruction: RESPOND IN English. YOU MUST RESPOND UNMISTAKABLY IN English.

2. Präzise Tool-Definitionen und Aufrufbedingungen

Wenn du Tools der Live API zugänglich machst:

• Füge immer Typannotationen und detaillierte Parameterbeschreibungen hinzu.
• Dokumentiere die Invocation Conditions explizit in der Tool-Metabeschreibung (z. B. „Dieses Tool erst aufrufen, nachdem der User Abreisedatum und Ziel bestätigt hat“). So vermeidest du vorzeitige Funktionsaufrufe durch das LLM.

3. Native Audiokontexte managen (Kompression)

Native Audiotoken summieren sich schnell – etwa 25 Tokens pro Sekunde Gespräch. Bei langen Sessions kann das zügig das Kontextfenster füllen und die Latenz erhöhen.

• Aktiviere ContextWindowCompressionConfig in deinen Verbindungseinstellungen, um ältere Historie ab einer Schwelle zu verwerfen:

from google.genai import types
live_config = types.LiveConnectConfig(
   context_window_compression=types.ContextWindowCompressionConfig(
       trigger_tokens=100_000,
       sliding_window=types.SlidingWindow(target_tokens=4_000),
   ),
)Bereitgestellt von

Hinweis: Kontextkompression führt dazu, dass ältere Gesprächshistorie verloren geht.

4. Transparente Sitzungswiederaufnahme

Echtzeit-Mobileverbindungen sind anfällig für Paketverluste und kurze Disconnects. Statt jedes Mal ganz neu zu starten, implementiere eine transparente Sitzungswiederaufnahme:

• Konfiguriere den Stream mit SessionResumptionConfig(transparent=True).
• Höre auf session_resumption_update-Events vom Server und speichere den new_handle.
• Halte einen lokalen Puffer ausgehender Nachrichten vor. Wenn die Verbindung abbricht, fange die APIError- oder GoAway-Signale ab, verbinde dich mit dem gespeicherten Handle neu und spiele nur die nicht bestätigten Clientnachrichten erneut ein (mithilfe von server-reported last_consumed_client_message_index zum Prunen des Puffers).

5. Audiostreaming optimieren

• Client-Pufferung: Puffer keine langen Audioframes, bevor du sie sendest. Streame kleine Audioblöcke (zwischen 20 ms und 40 ms) kontinuierlich, um die Ende-zu-Ende-Latenz zu minimieren.
• Mikrofon-Resampling: Stelle sicher, dass die Client-Audioaufnahme Eingänge (typisch 44,1 kHz oder 48 kHz) vor dem Senden über den WebSocket auf 16 kHz PCM herunterresampelt.
• Explizite VAD-Signale: Überlasse dem Modell die Voice Activity Detection (VAD). Wenn dein Frontend sofortige UI-Indikatoren zeigen soll (z. B. „KI hört zu“ vs. „KI denkt nach“), aktiviere explicit_vad_signal=True in der Konfiguration, um VAD-Start/Stopp-Events direkt im Server-Message-Flow zu erhalten.

6. Sicherheit (Token-Management)

• Master-Keys niemals hardcoden: Lege deinen AI-Studio-API-Schlüssel oder Google-Cloud-Service-Account-Zugangsdaten nicht im Client-Code (Browser oder Mobile-Apps) offen.
• Ephemeren Token-Austausch nutzen: Baue einen Auth-Endpunkt in deinem sicheren Backend. Wenn ein Client eine Sprachsession starten will, erzeugt das Backend ein kurzlebiges, eingeschränktes OAuth- oder API-Access-Token (z. B. via Vertex AI IAM) und übergibt es an den Client. Der Client nutzt diese temporären Zugangsdaten, um die direkte WebSocket-Verbindung zu öffnen.

Fazit: Der Horizont konversationaler KI

Der Wechsel von turnbasierten, reinen Text-LLMs zu latenzarmen, multimodalen Streams ist ein Paradigmenwechsel für Mensch-Computer-Schnittstellen. Durch die native Verarbeitung von Audio und Video über zustandsbehaftete WebSocket-Verbindungen ermöglicht die Gemini Live API agentische Experiences, die sich weniger wie starre Software und mehr wie flüssige, menschliche Interaktionen anfühlen.

In diesem Guide haben wir die Architektur von Gemini Live beleuchtet, die Preismodelle betrachtet und mit dem Google Agent Development Kit (ADK) einen vollständig funktionsfähigen AI Travel Concierge gebaut. Wir haben gesehen, wie ADK Standard-Python-Funktionen in aktive Agent-Tools überführt – und so unserem Sprachassistenten sowohl breites webbasiertes Grounding als auch interne Datenbankabfragen eröffnet.

Was baust du als Nächstes? 

Jetzt, da du die Grundlagen von Echtzeit-Sprachagenten beherrschst, könntest du deinen AI Travel Concierge erweitern: 

1. Live-Videostreams einbinden: Unterstütze die Übertragung von Kamerabildern, damit der Concierge in Echtzeit Karten, Boardingpässe oder physische Reisebelege „sehen“ kann. 
2. Transaktionale Custom-Tools integrieren: Implementiere ein Tool wie book_flight oder reserve_hotel, das echten Zustand verändert, inklusive Auth-Scopes für sichere Nutzerbestätigungen. 
3. Produktives Middleware-Routing: Wechsle vom lokalen ADK-Test zu einem WebRTC-Framework wie LiveKit oder Pipecat, um Sprachcalls produktiv direkt aus Web- und Mobile-Apps zu streamen.

Bereit für fortgeschrittene Konversations-Workflows? Sieh dir DataCamps AI Agent Fundamentals Lernpfad an, um dein Wissen zu agentischen Architekturen, Tool-Nutzung und generativen KI-Deployments zu vertiefen.