Monitoring in het AI-tijdperk: wat verandert er als je app LLMs gebruikt

Traditionele monitoring werkt niet meer met AI#

Vroeger werkte je app zo:

Request → Je code → Database → Response (deterministisch)

Eenvoudig om te monitoren: draait de code? Reageert de database? Zijn de responses snel?

Nu ziet het er zo uit:

Request → Je code → LLM API → LLM verwerkt token voor token →
Database → Response (niet-deterministisch)

Drie nieuwe problemen:

1. De kosten zijn onvoorspelbaar: LLM API's rekenen per token. De request van een gebruiker kan $0,01 of $1,00 kosten, afhankelijk van de output-lengte.
2. Kwaliteit is moeilijk meetbaar: Traditionele monitoring zegt "request gelukt." Maar gaf de AI bruikbare output of een hallucinatie?
3. Latency is variabel: LLM responses kunnen 500ms of meer dan 30 seconden duren, afhankelijk van model en aantal tokens.

Traditionele monitoring vangt deze problemen niet op.

---

Wat AI-tijdperk monitoring moet bijhouden#

1. LLM API kosten & budget#

Het probleem:

Normale dag:
- 10.000 requests naar OpenAI
- Gemiddeld 500 input tokens, 200 output tokens
- Kosten: 10.000 × ($0,005 + $0,015) = $200/dag

Slechte dag (onverwacht):
- 50.000 requests naar OpenAI
- Gemiddeld 2.000 input tokens, 1.000 output tokens
- Kosten: 50.000 × ($0,05 + $0,15) = $10.000/dag

Zonder monitoring: je weet het pas als de AWS-rekening binnenkomt

Wat je moet monitoren:

✅ Tokens gebruikt per request
✅ Totaal aantal tokens dat vandaag is gebruikt (vs. dagbudget)
✅ Kosten per request
✅ Totale uitgaven (vs. maandbudget)
✅ Kosten per gebruiker (zware gebruikers identificeren)
✅ Kostentrend (groeien de kosten? Waarom?)

Alert thresholds:

• Kosten >2x normaal voor het uur → Warning
• Kosten >5x normaal voor het uur → Critical alert
• Maandelijkse uitgaven >80% van budget → Alert

2. AI output-kwaliteit#

Het probleem:

Traditionele monitor zegt: "Request gelukt, response time 2s, status 200"
Realiteit: AI hallucineerde (gaf foutieve informatie)
Gebruikerservaring: gefrustreerde gebruiker

Wat je moet monitoren:

✅ Hallucinatie-detectie
  - Verzon de AI feiten? (Vergelijk met knowledge base)
  - Sprak de AI zichzelf tegen? (Check op consistentie)
  - Verwees de AI naar niet-bestaande documenten? (Valideren)

✅ Kwaliteitsmetrics van responses
  - Beantwoordde de response de vraag van de gebruiker?
  - Bevatte de response de vereiste secties?
  - Voldeed de response aan de minimum-nauwkeurigheidsdrempel?

✅ Gebruikersfeedback
  - Beoordeelde de gebruiker de response als nuttig?
  - Meldde de gebruiker de response als onjuist?
  - Stelde de gebruiker een vervolgvraag (suggereert verwarring)?

Implementatievoorbeeld:

Nadat de LLM een response genereert:
1. Check: verwijst de response naar een specifiek document?
2. Verifieer: dat document bestaat in de knowledge base
3. Alert als: de response naar een niet-bestaande bron verwijst (hallucinatie)

Nadat de gebruiker de response ontvangt:
1. Verzamel: 👍 / 👎 feedback
2. Track: % van responses dat als nuttig wordt beoordeeld
3. Alert als: helpfulness rating >10% daalt (kwaliteitsdaling)

3. LLM latency & rate limits#

Het probleem:

OpenAI rate limit: 3.500 requests per minuut
Jouw app: 4.000 requests per minuut tijdens piekmomenten
Gedrag: 500 requests in queue of geweigerd

Zonder monitoring: gebruikers zien timeouts en weten niet waarom

Wat je moet monitoren:

✅ Diepte van de request queue
  - Hoeveel requests wachten op een LLM-response?
  - Groeiende queue = onvoldoende capaciteit

✅ Rate limit status
  - Nader je de rate limit van OpenAI?
  - Krijg je 429 (Too Many Requests) errors?

✅ Latency-distributie
  - 95e percentiel latency
  - 99e percentiel latency
  - Groeien de outliers?

✅ Verschillen in modelperformance
  - GPT-4 is langzamer maar nauwkeuriger
  - GPT-3.5 is sneller maar minder nauwkeurig
  - Lopen de response times van de modellen uiteen?

Alert thresholds:

• Queue-diepte >1.000 requests → Warning (backlog bouwt op)
• 429 errors >1% → Critical (rate limited)
• 95e percentiel latency >10s → Warning (verslechtert)
• 99e percentiel latency >30s → Critical (timeouts waarschijnlijk)

---

AI-specifieke monitoring patterns#

Pattern 1: kostenanomalie-detectie#

Dagbudget: $500
Normale dagelijkse uitgaven: $200

Monitoring:
- Houdt uitgaven realtime bij
- Detecteert wanneer uitgaven 50% boven normaal komen
- Als normaal $200/dag is en de actuele waarde om 14:00 al $300/dag → Alert
- Hoofdoorzaak: óf meer gebruikers, óf elke request is duurder

Pattern 2: detectie van kwaliteitsdaling#

Baseline metrics:
- Hallucinatie-percentage: <2%
- Helpfulness rating: 85%
- Gemiddelde response-lengte: 300 tokens

Na deploy:
- Hallucinatie-percentage: 8%
- Helpfulness: 72%
- Gemiddelde response: 500 tokens

Alert: kwaliteit is gedaald (hallucinaties omhoog, helpfulness omlaag)

Pattern 3: model performance tracking#

In productie gebruik je 3 modellen:
- GPT-4: duur, accuraat, langzaam
- GPT-3.5: goedkoop, voldoende, snel
- Claude-Haiku: heel goedkoop, goed, gemiddeld

Monitoring volgt per model:
- Latency
- Kosten
- Kwaliteit (via gebruikersfeedback)
- Aantal gebruiken

Als Claude-Haiku sneller/goedkoper wordt met dezelfde kwaliteit → overweeg meer te gebruiken
Als GPT-4 latency 50% stijgt → alert, mogelijk API-probleem

Pattern 4: trends in tokengebruik#

Baseline:
- Input tokens per request: 500
- Output tokens per request: 200
- Totaal per dag: 10M input, 2M output

Na een feature change (context toegevoegd):
- Input tokens per request: 2.000 (4x toename)
- Output tokens per request: 200
- Totaal per dag: 40M input, 2M output (4x kostenstijging)

Alert: kosten zijn onverwacht gestegen. Bekijk wat er is veranderd.

---

Implementatie: AI-monitoring opzetten#

Stap 1: instrumenteer je LLM-calls (2 uur)#

Voeg monitoring toe aan elke LLM API-call:

import time
from openai import OpenAI

def call_llm_monitored(prompt, user_id, request_type):
    start_time = time.time()

    try:
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )

        latency = time.time() - start_time
        tokens_input = response.usage.prompt_tokens
        tokens_output = response.usage.completion_tokens
        cost = (tokens_input * 0.0005 + tokens_output * 0.0015) / 1000

        # Stuur metrics naar monitoring
        monitor.track({
            "event": "llm_call",
            "model": "gpt-3.5-turbo",
            "latency_ms": latency * 1000,
            "input_tokens": tokens_input,
            "output_tokens": tokens_output,
            "cost_cents": cost * 100,
            "user_id": user_id,
            "request_type": request_type,
            "status": "success"
        })

        return response.choices[0].message.content

    except Exception as e:
        monitor.track({
            "event": "llm_call",
            "status": "error",
            "error": str(e),
            "user_id": user_id
        })
        raise

Stap 2: track kosten in real-time#

Aggregeer dagelijks:
- Totaal aantal requests: 5.000
- Totaal input tokens: 2,5M
- Totaal output tokens: 500K
- Totale kosten: $18,50
- Kosten per request: $0,0037

Vergelijk met budget:
- Dagbudget: $25
- Gebruikt: $18,50 (74% van budget)
- Resterend: $6,50

Stap 3: meet output-kwaliteit#

Voor een customer support AI:
1. Nadat de response is gegenereerd: vraag de klant "Was dit nuttig?"
2. Bij een 👎 click → markeer als low-quality
3. Track: welk % van de responses wordt als nuttig beoordeeld?

Baseline: 90% nuttig
Na deploy: 75% nuttig
Alert: kwaliteit is met 15 punten gedaald

Stap 4: stel alerts in#

Critical (direct paging):

• Kosten/uur >5x normaal (duidt op oncontroleerbaar LLM-gebruik)
• 429 errors (LLM API rate limited)
• Hallucinatie-percentage >10%
• Helpfulness rating <50%

Warning (Slack alert):

• Kosten/uur >2x normaal
• Latency P95 >10 seconden
• Queue-diepte >500 requests
• Hallucinatie-percentage >5%

Info (dagelijkse digest):

• Kostentrends (uitgaven stijgend?)
• Vergelijking modelperformance
• Trends in gebruikersfeedback

---

Veelgemaakte AI-monitoringfouten#

Fout 1: tokengebruik niet monitoren#

Wat er gebeurt: je app roept de LLM aan met steeds langere context. Tokengebruik stijgt. Kosten stijgen. Je merkt het pas als de maandrekening 10x het verwachte bedrag is.

Oplossing: track tokens per request. Alert als het aantal tokens met >50% stijgt.

Fout 2: alleen response-snelheid meten, niet kwaliteit#

Wat er gebeurt: je optimaliseert voor latency. Het model wordt sneller maar genereert meer hallucinaties. Gebruikers verliezen vertrouwen. Omzet daalt.

Oplossing: monitor zowel latency ALS kwaliteit (hallucinatie-percentage, gebruikersfeedback).

Fout 3: de status van de LLM API niet bijhouden#

Wat er gebeurt: OpenAI heeft een storing. Je requests stapelen op. Gebruikers wachten 30+ seconden. Jij denkt dat je code stuk is.

Oplossing: monitor de health van de OpenAI API apart. Weet wanneer het probleem aan hun kant ligt of aan die van jou.

Fout 4: dezelfde kosten-alert voor verschillende modellen#

Wat er gebeurt: je stelt alert in: "Kosten >$10/dag". Werkt voor GPT-3.5. Maar je voegt GPT-4 toe (duurder). Nu gaat de alert continu af.

Oplossing: stel kosten-alerts per model in. GPT-3.5: alert bij $10/dag. GPT-4: alert bij $50/dag.

Fout 5: gebruikersfeedback niet monitoren#

Wat er gebeurt: AI genereert hallucinaties. Traditionele monitoring zegt "alles werkt." Gebruikers krijgen verkeerde informatie.

Oplossing: vraag gebruikers responses te beoordelen. Track ratings. Alert als ratings dalen.

Fout 6: kosten per gebruiker negeren#

Wat er gebeurt: de requests van één gebruiker kosten $10/maand. Jij rekent ze $5/maand subscription. Je verliest geld per gebruiker.

Oplossing: track kosten per gebruiker. Alert als de kosten van een gebruiker zijn revenue-bijdrage overschrijden.

---

AI monitoring tools (status 2026)#

Ingebouwde LLM monitoring:

• Langsmith (LangChain monitoring) — Houdt LLM-calls vanuit LangChain bij
• OpenAI API dashboard — Basis token-/kosten-tracking
• Anthropic console — Claude API-gebruik

Generieke APM tools (met AI tracking toegevoegd):

• Datadog — Heeft LLM-monitoring toegevoegd (kosten, latency, kwaliteit)
• New Relic — Heeft LLM-tracking toegevoegd
• Dynatrace — Heeft AI-monitoring toegevoegd

Gespecialiseerde AI-monitoring:

• Arize — AI-modelmonitoring (hallucinatiedetectie, data drift)
• Whylabs — Monitoring van modelkwaliteit
• Arthur.ai — AI-governance en monitoring

Beste setup: Langsmith of de Anthropic console voor LLM-specifieke tracking + Datadog voor correlatie met applicatiemetrics.

---

Real-world AI monitoring voorbeeld#

Scenario: customer support chatbot met GPT-4

Baseline metrics:

• Requests/dag: 10.000
• Gem. input tokens: 1.500
• Gem. output tokens: 300
• Kosten: $65/dag
• User rating: 88% nuttig
• Hallucinatie-percentage: 1%

Na product update (context toegevoegd):

• Requests/dag: 10.000 (gelijk)
• Gem. input tokens: 3.500 (+133%)
• Gem. output tokens: 300 (gelijk)
• Kosten: $116/dag (+78%)
• User rating: 92% nuttig (+4%)
• Hallucinatie-percentage: 0,5% (-50%)

Analyse:

• Kosten stegen met 78% maar de kwaliteit verbeterde
• ROI-berekening: extra $51/dag × 30 dagen = $1.530/maand
• Voordeel: 4% meer gebruikers vinden de response nuttig
• Bij 10.000 gebruikers/dag betekent 4% verbetering 400 extra tevreden gebruikers/dag
• Waarde: voorkom support-escalaties (bespaar $5 per voorkomen escalatie)
• Break-even: 306 voorkomen escalaties/maand = $1.530

Beslissing: kostenstijging is gerechtvaardigd. De product update verhoogde de klanttevredenheid genoeg om de hogere LLM-kosten op te vangen.

Zonder AI-monitoring: beslissing blind genomen op basis van gevoel.

---

Samenvatting: AI-applicaties monitoren#

AI-apps vereisen monitoring die verder gaat dan traditionele performance metrics:

1. Kostenmonitoring — track tokengebruik en uitgaven realtime. Alert bij kostenanomalieën.
2. Kwaliteitsmonitoring — meet AI output-kwaliteit (hallucinatie-percentage, gebruikersfeedback).
3. Latency monitoring — houd LLM response times en queue-diepte bij.
4. Budget alerting — alert voordat je je LLM API-budget overschrijdt.
5. Gebruikersfeedback — verzamel ratings om kwaliteit te meten zonder handmatige review.

Snelle implementatie-checklist:

• ✅ Instrumenteer alle LLM-calls met token tracking
• ✅ Bereken en monitor kosten per request
• ✅ Track totale dagelijkse/maandelijkse uitgaven vs. budget
• ✅ Monitor LLM API latency en rate limits
• ✅ Verzamel gebruikersfeedback over response-kwaliteit
• ✅ Alert bij kostenanomalieën (>2x normaal)
• ✅ Alert bij kwaliteitsdaling (stijging hallucinatie-percentage)
• ✅ Track verschillen in modelperformance
• ✅ Monitor veranderingen in user sentiment
• ✅ Stel kostenbudgetten in per feature/gebruiker/model

AI monitoring is cruciaal voor het beheersen van kosten met behoud van kwaliteit. Het verschil tussen winstgevende en verliesgevende AI-features zit vaak in 1-2% kwaliteitsverbetering gecombineerd met kostenmonitoring.

Klaar om AI-applicaties te monitoren? Start met Nova Uptime's uptime monitoring voor je API en voeg daarna applicatie-specifieke LLM-monitoring toe met Langsmith of Datadog.