CI/CD voor AI: Geautomatiseerde Evals
Op deze pagina
Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie:
temperatureentop_pworden alleen geaccepteerd met een redeneerinspanning vannone, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daaromreasoning={"effort": "none"}(Responses API) ofreasoning_effort="none"(Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.
Evals integreren in uw CI/CD-pipeline
Het implementeren van een wijziging in een prompt naar productie zonder evaluatie is vergelijkbaar met het deployen van code zonder tests. De vergelijking is accurater dan het misschien lijkt: in beide gevallen lijkt de wijziging triviaal, is deze handmatig geverifieerd aan de hand van een of twee voorbeelden, en manifesteert het neveneffect zich drie dagen later bij een gebruiker die u er niet over zal informeren. Het verschil is dat een regressie in een prompt geen uitzondering veroorzaakt; de applicatie blijft reageren, alleen slechter.
Het doel is om geautomatiseerde evaluatie tot een verplichte poort in uw deployproces te maken, zodat elke wijziging de kwaliteit behoudt of verbetert. Dat is precies wat we hierna behandelen.
Het principe: een poort, geen rapport
De eval-pipeline integreert in uw deployflow via een vertrouwd mechanisme. Een ontwikkelaar wijzigt een prompt of parameter, de commit activeert de CI-pipeline en de evals worden automatisch uitgevoerd tegen de referentieset. Als de scores aan de drempelwaarden voldoen, gaat de implementatie door; anders wordt deze geblokkeerd, vergezeld van een gedetailleerd rapport dat aangeeft welke evaluatie is mislukt en met hoeveel.
Het cruciale punt is dit blokkerende gedrag. Een CI die een mooi rapport produceert zonder de pipeline te stoppen, wordt binnen twee weken een artefact dat niemand meer controleert. Alleen een exitcode ongelijk aan nul verandert meting in een vangrail.
Het onderstaande script leest een configuratie, laadt elke dataset, voert de cases uit en vergelijkt de gemiddelde score met de opgegeven drempelwaarde. De scoremethode – eenvoudige trefwoordopname – is bewust rudimentair: een CI-check moet snel, deterministisch en onafhankelijk zijn van een judge wiens score per uitvoering kan variëren.
import json
import sys
import openai
from pathlib import Path
client = openai.OpenAI()
def load_eval_config(path: str = "evals/config.json") -> dict:
"""Loads the evaluation configuration."""
with open(path) as f:
return json.load(f)
def load_dataset(path: str) -> list[dict]:
"""Loads a JSONL dataset."""
cases = []
with open(path) as f:
for line in f:
cases.append(json.loads(line))
return cases
def run_ci_evals(config: dict) -> dict:
"""Runs evaluations for CI."""
results = {}
for eval_config in config["evaluations"]:
name = eval_config["name"]
dataset = load_dataset(eval_config["dataset"])
threshold = eval_config["min_threshold"]
model = eval_config["model"]
prompt = Path(eval_config["prompt_file"]).read_text()
scores = []
for case in dataset:
response = client.responses.create(
model=model,
reasoning={"effort": "none"}, # temperature requires effort none
instructions=prompt,
input=case["input"],
temperature=0.0,
)
# Simple evaluation by keyword inclusion
if "keywords" in case:
response_lower = response.output_text.lower()
found = sum(
1 for word in case["keywords"]
if word.lower() in response_lower
)
score = found / len(case["keywords"])
else:
score = 1.0 # No specific criterion
scores.append(score)
avg_score = sum(scores) / len(scores)
passed = avg_score >= threshold
results[name] = {
"score": avg_score,
"threshold": threshold,
"passed": passed,
"num_cases": len(dataset),
}
return results
def ci_report(results: dict) -> tuple[str, bool]:
"""Generates a report for CI and indicates if it's OK."""
lines = ["# AI Evaluation Report\n"]
all_pass = True
for name, r in results.items():
status = "PASS" if r["passed"] else "FAIL"
if not r["passed"]:
all_pass = False
lines.append(
f"- [{status}] {name}: {r['score']:.2%} "
f"(threshold: {r['threshold']:.0%}, {r['num_cases']} cases)"
)
report = "\n".join(lines)
return report, all_pass
Merk op dat de prompt uit een bestand wordt gelezen in plaats van direct in het script te worden geschreven. Dit maakt triggering mogelijk: een prompt die versiebeheerd is in de repository genereert een diff, en een diff kan een evaluatie activeren. Zolang uw prompts als string-literals verspreid door uw applicatiecode staan, is goede automatisering niet mogelijk.
De configuratie declareert één evaluatie per taak, elk met een eigen drempelwaarde.
{
"evaluations": [
{
"name": "ticket-classification",
"dataset": "evals/datasets/classification.jsonl",
"prompt_file": "prompts/classification.txt",
"model": "gpt-5.6-terra",
"min_threshold": 0.90
},
{
"name": "resume-generation",
"dataset": "evals/datasets/resumes.jsonl",
"prompt_file": "prompts/resume.txt",
"model": "gpt-5.6-terra",
"min_threshold": 0.75
}
]
}
Het verschil tussen deze twee drempelwaarden vormt de kern van de methode. Ticketclassificatie is een gesloten taak: onder de 0,90 levert de functie niet de verwachte service. Samenvatten is een open taak, beoordeeld op trefwoorden die een goede tekst legitiem anders zou kunnen formuleren; een vereiste van 0,90 zou elke implementatie blokkeren en snel leiden tot het uitschakelen van de check. Kalibreer elke drempelwaarde op basis van scores die in productie zijn waargenomen, in plaats van op een rond getal dat geruststellend aanvoelt.
Alles koppelen in GitHub Actions
De workflow wordt alleen geactiveerd op relevante paden – prompts, evals, AI-integratiecode – zodat een wijziging in een stylesheet geen API-calls verbruikt.
# .github/workflows/eval-ai.yml
name: AI Evaluation
on:
pull_request:
paths:
- "prompts/**"
- "evals/**"
- "src/ai/**"
jobs:
evaluate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- run: pip install openai
- name: Run evals
env:
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
run: python evals/run_ci.py
- name: Publish report
if: always()
uses: actions/upload-artifact@v4
with:
name: eval-report
path: evals/report.md
Twee details zijn het vermelden waard. De API-sleutel wordt via repository-secrets doorgegeven, nooit via het workflow-bestand, dat leesbaar is voor iedereen met toegang tot de code. En de publicatie van het rapport gebruikt if: always(), anders zou het artefact niet worden geproduceerd wanneer evals mislukken – wat precies het enige geval is waarin u het moet lezen.
Het entry-script bindt alles samen: het schrijft het rapport naar schijf voor het artefact, print het naar de logs en stelt de exitcode in die de rest van de pipeline toelaat of blokkeert.
#!/usr/bin/env python3
"""Evaluation script for CI — evals/run_ci.py"""
import sys
from pathlib import Path
def main():
config = load_eval_config("evals/config.json")
results = run_ci_evals(config)
report, all_pass = ci_report(results)
# Write the report
Path("evals/report.md").write_text(report)
print(report)
# Exit code for CI
if not all_pass:
print("\nSome evaluations failed. Deployment blocked.")
sys.exit(1)
else:
print("\nAll evaluations pass.")
sys.exit(0)
if __name__ == "__main__":
main()
Vergelijk in plaats van absoluut te beoordelen
Een vaste drempelwaarde beantwoordt de vraag “Is dit goed genoeg?”. Het beantwoordt niet de vraag “Is dit beter dan eerder?”, wat vaak de echte vraag is. Een herschreven prompt kan boven de drempelwaarde blijven terwijl deze drie punten verliest ten opzichte van de vorige versie: de CI wordt groen en de degradatie belandt in productie zonder dat iemand het merkt.
De regressietest voert daarom beide versies uit op dezelfde dataset, in dezelfde campagne, en vergelijkt de gemiddelden. Een tolerantie van 5% absorbeert de ruis die inherent is aan generatieve outputs; daarbeyond is het oordeel expliciet.
def prompt_regression_test(
current_prompt: str,
previous_prompt: str,
dataset: list[dict],
model: str,
degradation_threshold: float = 0.05,
) -> dict:
"""Verifies that a new prompt does not degrade performance."""
scores_current = []
scores_previous = []
for case in dataset:
# Evaluate with current prompt
r1 = client.responses.create(
model=model, instructions=current_prompt,
reasoning={"effort": "none"}, # temperature requires effort none
input=case["input"], temperature=0.0,
)
# Evaluate with previous prompt
r2 = client.responses.create(
model=model, instructions=previous_prompt,
reasoning={"effort": "none"}, # temperature requires effort none
input=case["input"], temperature=0.0,
)
s1 = evaluate_response(r1.output_text, case)
s2 = evaluate_response(r2.output_text, case)
scores_current.append(s1)
scores_previous.append(s2)
avg_current = sum(scores_current) / len(scores_current)
avg_previous = sum(scores_previous) / len(scores_previous)
delta = avg_current - avg_previous
return {
"current_score": avg_current,
"previous_score": avg_previous,
"delta": delta,
"regression": delta < -degradation_threshold,
"verdict": "OK" if delta >= -degradation_threshold else "REGRESSION",
}
Deze test verdubbelt het aantal calls, en dus de kosten en duur. Reserveer dit voor wijzigingen in prompts, houd het buiten het pad van gewone commits, en voer het uit op een representatieve subset in plaats van uw volledige referentieset.
Belangrijkste punten
- Integreer evals in uw CI/CD-pipeline zoals unit tests
- Beheer prompts in bestanden: zonder diff is triggering niet mogelijk
- Definieer minimumdrempels per evaluatietype, gekalibreerd op productiedata
- Blokkeer implementaties via exitcode wanneer scores onder de drempels zakken
- Test op regressies door nieuwe en oude prompts op dezelfde dataset te vergelijken