Aan de slag met de Gemini Live API

Als je ooit hebt geprobeerd een spraakassistent te bouwen, weet je hoe omslachtig de traditionele pijplijn is. Je neemt de stem van de gebruiker op, zet die om met een STT-model, stuurt die tekst naar een LLM, wacht op een reactie en laat die vervolgens door een TTS-engine lopen. 

Tegen de tijd dat je gebruiker een antwoord hoort, zijn er al enkele seconden ongemakkelijke stilte verstreken. Het voelt minder als een gesprek en meer als een trage vraag-en-antwoordcyclus. 

De Gemini Live API verandert deze flow door audio en video continu te laten streamen via een stateful WebSocket-verbinding. Omdat het model audio native verwerkt en uitstuurt, kan het onmiddellijk reageren, zich aanpassen aan natuurlijke vocale nuances en zelfs onderbrekingen (barge-in) halverwege een zin afhandelen. 

In deze tutorial laat ik je zien hoe je een Real-Time AI Travel Concierge bouwt met de code-first Google Agent Development Kit (ADK). We rusten onze agent uit met Google Search voor live weerrapporten op bestemming, koppelen hem aan een mock-vluchtdatabank en starten een lokale ontwikkelaarsinterface om te testen hoe hij realtime dialoog en tool-calling afhandelt.

Als je nieuw bent in het ecosysteem, raad ik je aan te beginnen met de cursus Building AI Agents with Google ADK om je basiskennis op te bouwen.

Wat je gaat bereiken: 

• Begrijp de werking, mogelijkheden en prijsstelling van de Gemini Live API.
• Configureer een Python-omgeving met de Google Agent Development Kit. 
• Stel zowel ingebouwde tools (Google Search) als aangepaste bedrijfslogica (vluchtstatus-databaseopvragingen) beschikbaar aan de spraakassistent. 
• Start een lokale web-UI om live met je reisagent te praten.

Vereisten: 

• Basiskennis van Python. 
• Een Google Cloud-project (voor Vertex AI-toegang) of een Google AI Studio API-sleutel.

Wat is de Gemini Live API? 

In de kern is de Gemini Live API een ontwikkelaarstool van Google waarmee je realtime spraak- en visuele interacties met Gemini-modellen kunt bouwen. In plaats van te wachten op beurtgebaseerde tekstantwoorden, maakt het continue, natuurlijke gesprekken tussen een gebruiker en een AI-agent mogelijk. 

Technisch gezien is de Gemini Live API ontworpen voor bidirectionele, realtime streaming. In tegenstelling tot standaard HTTP REST-API's met stateless request-responsecycli, vertrouwt de Live API op een stateful, persistente WebSocket (WSS)-verbinding. Via dit open kanaal streamt de client ruwe audio, video (verzonden als beeldframes met ~1 FPS) en tekst, terwijl het model direct native audio en tekst terugstreamt.

Belangrijkste mogelijkheden van Gemini Live

• Barge-in (onderbreekbaarheid): In een natuurlijk gesprek wachten we niet tot de ander een hele alinea heeft uitgesproken voordat we iets verduidelijken. Gemini Live ondersteunt barge-in standaard; gebruikers kunnen de spraak van het model halverwege een zin onderbreken, waarna de server onmiddellijk stopt met audiostreamen en zich aanpast aan de nieuwe input.
• Affectieve dialoog en native audio: In plaats van tekst te genereren en die door een Text-to-Speech (TTS)-engine te sturen, verwerken en genereren modellen zoals gemini-live-2.5-flash-native-audio en gemini-3.1-flash-live-preview audio native. Dit behoudt emotionele nuances, lachen, toonaanpassing en spreekritme, waardoor interacties menselijk aanvoelen. 
• Multimodale input en toolgebruik: De Live API is niet beperkt tot audio. Hij kan je omgeving "zien" via videoframes en externe functies of tools (zoals Google Search of aangepaste API's) in realtime triggeren, waarbij de resultaten weer in de spraakstroom worden gevoed.

Prijzen van de Gemini Live API

Omdat realtime streaming een continue, full-duplexverbinding inhoudt, wijkt het factureringsmodel af van standaard statische tekst-API's. Google biedt zowel een royaal gratis niveau voor prototyping in Google AI Studio als een productieklare betaalde laag op Vertex AI. 

Het model gemini-3.1-flash-live-preview wordt gefactureerd per miljoen tokens of omgerekend 

direct naar een op duur gebaseerd metriek voor audio- en videomedia:

Als je aan het prototypen bent, raad ik sterk aan om gratis te testen in Google AI Studio, dat royale toegang biedt binnen snelheidslimieten. 

Wanneer je klaar bent om op te schalen, kun je je project overzetten naar Vertex AI voor productie-Pay-as-you-go-provisioning, met gegarandeerde throughput en enterprise-grade SLA's.

Toegang krijgen tot de Gemini Live API

Als ontwikkelaar heb je een paar architectuuropties bij het implementeren van de Live API. Omdat deze op WebSockets steunt, is het belangrijk hoe je de verbinding routeert, voor latency en beveiliging.

Client-naar-server versus server-naar-server

• Client-naar-server: Je frontend (bijv. een web- of mobiele app) maakt rechtstreeks verbinding met Google's WebSocket-endpoint. Dit is de beste aanpak om de latency te minimaliseren, omdat de audiostream geen extra hops maakt. 
• Je kunt echter geen ruwe Google Cloud API-sleutels in een frontend-cliënt blootstellen; je moet een authenticatiestroom implementeren die tijdelijke, kortdurende tokens genereert voor veilige clienttoegang.
• Server-naar-server: Je frontend streamt audio naar je eigen backendserver, die vervolgens de WebSocket opent naar de Gemini Live API. Dit is zeer veilig en stelt je in staat backendlogica toe te voegen (zoals gebruikersauthenticatie of databaseopvragingen), maar het voegt een kleine netwerkvertraging toe aan de audiostream.

SDK's en partnerintegraties

Hoewel je ruwe WebSocket-code kunt schrijven, is de eenvoudigste manier om te starten het gebruik van Google's GenAI SDK of de Agent Development Kit (ADK). 

Voor enterpriseproductie heeft het ecosysteem zich snel ontwikkeld om WebRTC-integraties te ondersteunen. Platformen zoals LiveKit, Pipecat van Daily, Twilio en Voximplant bieden robuuste infrastructuur om netwerkjitter, echo-onderdrukking en realtime audiorouting rechtstreeks naar de Gemini Live API af te handelen.

Een realtime spraakassistent bouwen met de Gemini Live API

Laten we dit in de praktijk brengen. We gaan een AI Travel Concierge bouwen. 

Deze agent gebruikt de Gemini Live API om via spraak met gebruikers te praten, maar belangrijker: hij krijgt toegang tot aangepaste Python-functies om realtime vluchtstatussen op te zoeken tijdens het gesprek.

We gebruiken de Google Agent Development Kit (ADK) en het krachtige gemini-3.1-flash-live-preview-model, dat is geoptimaliseerd voor zowel standaard tekstbeurten als realtime WebSocket-streaming.

1. De omgeving instellen

Eerst moet je een virtuele Python-omgeving instellen en het vereiste ADK-pakket installeren. Voer deze commando's uit in je terminal:

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

Configureer vervolgens je omgevingsvariabelen zodat de ADK veilig kan authenticeren bij je Google Cloud-project:

export GOOGLE_CLOUD_PROJECT="your-project-id" 
export GOOGLE_CLOUD_LOCATION="us-central1"Mogelijk gemaakt door

Als je in plaats daarvan een Gemini API Key van Google AI Studio gebruikt, maak dan een .env-bestand in je hoofdmap:

GEMINI_API_KEY=your_google_ai_studio_api_keyMogelijk gemaakt door

2. De Gemini Live-agent initialiseren 

Maak een bestand met de naam agent.py in je projectmap. De ADK is zo ontworpen dat de variabele root_agent automatisch wordt gedetecteerd en uitgevoerd. In deze code definiëren we een aangepaste Python-functie om vluchtstatussen te controleren en geven we die vervolgens direct door aan de toolbelt van de agent. Initialiseer de agentmap: 

mkdir voice_assistant 
touch voice_assistant/__init__.py 
touch voice_assistant/agent.pyMogelijk gemaakt door

Stel het agentpakket bloot in voice_assistant/__init__.py:

from . import agentMogelijk gemaakt door

3. De agent definiëren en aangepaste tools beschikbaar maken 

Open voice_assistant/agent.py en schrijf de configuratie van de reisagent. In de onderstaande code definiëren we een standaard Python-functie check_flight_status. 

In Google ADK wordt elke Python-functie met correcte typehints en een docstring automatisch omgezet in een agenttool. De LLM gebruikt de beschrijving in de docstring en de parameters om te bepalen wanneer en hoe de functie moet worden aangeroepen. 

Modelconfiguratie 

Gebruikmaken van Gemini 3.1 Flash Live Preview Om beide interactiemodi in de ADK-ontwikkelserver te ondersteunen—standaard tekstchat (die standaard REST generateContent-endpoints gebruikt) en de realtime bidirectionele WebSocket-microfooninterface—stellen we het model expliciet in op gemini-3.1-flash-live-preview.

In tegenstelling tot oudere streaming-only modellen, die een 404 Not Found retourneren wanneer ze via standaard HTTP REST-verzoeken worden aangeroepen, ondersteunt gemini-3.1-flash-live-preview native zowel standaard REST-contentgeneratie als stateful 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],
)Mogelijk gemaakt door

4. De interactieve dev-UI draaien en testen

De ADK bevat een ingebouwde development server en web-UI. Hiermee kun je je agent lokaal testen zonder frontendcode te schrijven. Start de webserver vanuit je werkruimte:

.venv/bin/adk web .Mogelijk gemaakt door

Je zou output moeten zien die aangeeft dat de server is gestart:

1. Open http://127.0.0.1:8000 in je webbrowser.
2. Selecteer je agent uit de toepassingslijst.
3. Klik op de microfoonknop om een live sessie te starten.

Selecteer root_agent in de toepassingslijst om de chatinterface te openen.

4. Spreek in je microfoon: Kun je de status van vlucht AA120 checken? De agent zal je verzoek parseren, herkennen dat hij database-informatie nodig heeft, de aangepaste check_flight_status Python-functie triggeren en het JSON-resultaat van de toolcall weergeven voordat hij het antwoord terug naar je uitspreekt.

5. Google Search Grounding testen:  Vraag de conciërge vervolgens een weersvraag over een bestemming: Wat is het weer in Londen op dit moment? De agent activeert de ingebouwde google_search-tool, crawlt het web en vat de actuele omstandigheden samen in de audio-uitvoer.

6. De barge-infunctie testen: Stel een brede vraag zoals: Vertel me over de beste historische bezienswaardigheden in Rome. Zodra de agent plekken begint op te sommen, praat er luid doorheen: Wacht, nee! Check in plaats daarvan vlucht UA990!. De agent stopt onmiddellijk zijn spraakstream, onderbreekt de Rome-details, draait de aangepaste vluchttracker-tool en meldt dat vlucht UA990 is geannuleerd. Dit toont de low-latency, full-duplex aard van de Live API-verbinding.

Best practices voor productie met de Gemini Live API

Realtime spraakapplicaties bouwen brengt unieke vereisten met zich mee rond promptarchitectuur, netwerkstatusbeheer, audio-inname en resource-schaalbaarheid. Hieronder staan belangrijke best practices afgeleid van officiële ontwikkelaarsrichtlijnen.

1. Duidelijke systeeminstructies ontwerpen

Om het beste uit Gemini Live te halen, structureer je systeeminstructies (SI's) in een strikte hiërarchie: Persona, Gespreksregels en Guardrails.

• Scheid persona's: Beperk de rol van elke agent tot één duidelijke systeeminstructie in plaats van één agent met meerdere persona's te overladen.
• Scheid conversatiestromen: Splits expliciet eenmalige elementen (bijv. "vraag de gebruiker één keer om zijn naam en ticketnummer") van open conversatielussen (bijv. "beantwoord vragen over reisaanbevelingen zolang ze willen").
• Schrijf toolaanroepen in zinnen: Beschrijf het gebruik van tools sequentieel. Bijvoorbeeld: 'Vraag eerst de gebruiker om zijn ticketnummer. Roep daarna look_up_ticket aan met dit nummer.'
• Handhaaf taalconsistentie: Native audiomodellen kunnen van taal wisselen als de context verandert. Als je agent alleen Engels spreekt, dwing dit dan af in je instructie: RESPOND IN English. YOU MUST RESPOND UNMISTAKABLY IN English.

2. Precieze tooldefinities en aanroepcondities

Wanneer je tools beschikbaar maakt voor de Live API:

• Neem altijd typeannotaties en gedetailleerde parameterbeschrijvingen op.
• Documenteer de aanroepcondities expliciet in de metadata-beschrijving van de tool (bijv. "Roep deze tool pas aan nadat de gebruiker zijn vertrekdatum en bestemming heeft bevestigd"). Dit voorkomt dat de LLM functies te vroeg triggert.

3. Native audiocontext beheren (compressie)

Native audiotokens stapelen zich snel op, ongeveer 25 tokens per seconde gesprek. Bij langdurige spraaksessies kan dit het contextvenster snel vullen en de latency verhogen.

• Schakel ContextWindowCompressionConfig in je verbindingsinstellingen in om oudere geschiedenis te laten vallen zodra een drempel is bereikt:

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),
   ),
)Mogelijk gemaakt door

Let op: Contextcompressie zorgt ervoor dat oude gespreksgeschiedenis verloren gaat.

4. Transparant hervatten van sessies

Realtime mobiele verbindingen zijn gevoelig voor pakketverlies en tijdelijke onderbrekingen. In plaats van een volledig nieuwe gespreksstatus te starten, implementeer je transparant hervatten van sessies:

• Configureer je stream met SessionResumptionConfig(transparent=True).
• Luister naar session_resumption_update-events van de server en sla de new_handle op.
• Onderhoud een lokale buffer van uitgaande berichten. Wanneer de verbinding wegvalt, vang de APIError of GoAway-signaal op, maak opnieuw verbinding met de opgeslagen handle en speel alleen de niet-bevestigde clientberichten opnieuw af (gebruik de door de server gerapporteerde last_consumed_client_message_index om de buffer op te schonen).

5. Optimalisatie van audiostreaming

• Clientbuffering: Buffer geen lange audioframes op de client voordat je ze verstuurt. Stream continu kleine audiochuncks (tussen 20 ms en 40 ms) om de end-to-end latency te minimaliseren.
• Microfoon-resampling: Zorg dat de audio-opname aan de clientzijde inputs (meestal 44,1 kHz of 48 kHz) downsamplet naar 16 kHz PCM voordat je deze via de WebSocket verstuurt.
• Expliciete VAD-signalen: Laat het model Voice Activity Detection (VAD) afhandelen. Als je frontend directe UI-indicatoren moet tonen (bijv. "AI luistert" vs "AI denkt"), zet dan explicit_vad_signal=True in je configuratie om VAD start/stop-events direct in de serverberichtenstroom te ontvangen.

6. Beveiliging (tokenbeheer)

• Hardcode nooit mastersleutels: Voorkom dat je je AI Studio API-sleutel of Google Cloud Service Account-credentials blootstelt in client-side code (browsers of mobiele apps).
• Implementeer een uitwisseling met kortdurende tokens: Bouw een authenticatie-endpoint op je beveiligde backend. Wanneer een client een spraaksessie wil starten, genereert de backend een kortdurende, beperkte OAuth- of API-toegangstoken (bijv. via Vertex AI IAM) en geeft die door aan de client. De client gebruikt deze tijdelijke referentie om de directe WebSocket-verbinding te openen.

Conclusie: De horizon van conversationele AI

De overgang van beurtgebaseerde, tekst-only LLM's naar low-latency, multimodale streaming vormt een paradigmawisseling in hoe we mens-computerinterfaces bouwen. Door audio en video native te verwerken via stateful WebSocket-verbindingen, stelt de Gemini Live API ons in staat agent-ervaringen te bouwen die minder aanvoelen als statische softwareprogramma's en meer als vloeiende menselijke interacties.

In deze gids hebben we de interne architectuur van Gemini Live verkend, prijsmodellen bekeken en een volledig functionerende AI Travel Concierge gebouwd met de Google Agent Development Kit (ADK). We zagen hoe ADK standaard Python-functies omzet in actieve agenttools, waardoor onze spraakassistent toegang krijgt tot zowel brede webgebaseerde search grounding als privé interne database-opvragingen.

Wat ga je hierna bouwen? 

Nu je de basis van realtime spraakagenten beheerst, kun je je AI Travel Concierge uitbreiden: 

1. Live videostreams aanbieden: Voeg ondersteuning toe voor camerabeeldoverdracht zodat de conciërge in realtime kaarten, instapkaarten of fysieke reisvouchers kan "zien". 
2. Transactionele aangepaste tools integreren: Implementeer een book_flight- of reserve_hotel-tool die echte status wijzigt, met integratie van authenticatiescopes voor veilige gebruikersbevestigingen. 
3. Productiemiddleware-routing: Ga van lokale ADK-tests naar een WebRTC-gebaseerd framework met LiveKit of Pipecat om productiegesprekken direct te streamen vanuit web- en mobiele apps.

Klaar om geavanceerdere conversationele workflows te bouwen? Bekijk DataCamp's AI Agent Fundamentals skill track om je kennis van agentische architecturen, toolgebruik en generatieve AI-deployments te verdiepen.