De Beste Open Source LLM-Evaluatieframeworks in 2026 (Eén Is Niet Echt Open Source)

De Beste Open Source LLM-Evaluatieframeworks in 2026 (Eén Is Niet Echt Open Source)

Regel 1 van het LICENSE-bestand in de Arize Phoenix-repo luidt "Elastic License 2.0 (ELv2)". Geen Apache. Geen MIT. Eén sterk aanbevolen open source LLM-evaluatieframework is geen open source volgens de OSI-definitie, en bijna elke pagina die voor deze zoekopdracht rankt, herhaalt die claim toch. Dat gold ook voor ons, tot vandaag. Op 2026-08-04 lazen we handmatig het licentiebestand en het commit-log van de default branch van acht frameworks, plus drie extra die de best scorende pagina's nog steeds aanbevelen, en installeerden we er zes om dezelfde 10 cases door elk te draaien. Wij verkopen geen evalframework, dus geen enkel oordeel hieronder beschermt een product.

Key Takeaways

• Arize Phoenix draait onder de Elastic License 2.0, die de OSI niet erkent als open source.
• De laatste commit van UpTrain naar main dateert van 2024-07-29. Begin er geen nieuw project op.
• pip install promptfoo installeert een wrapper van derden. Het echte project verschijnt op npm.
• Ragas heeft sinds 2026-02-24 geen commits meer en verhuisde naar de GitHub-organisatie vibrantlabsai.

Welk Open Source LLM-Evaluatieframework Moet Je in 2026 Installeren?

Kies op basis van je beperking, niet op ranking. Voor pytest-achtige assertions binnen een bestaande testsuite installeer je DeepEval. Voor een YAML-config en een CLI die bij elke taalstack past, installeer je promptfoo. Voor de scherpste scheiding tussen goed en fout die we maten, installeer je Opik. Alle drie zijn Apache-2.0 of MIT.

Hier is de audit. Acht frameworks binnen scope, plus drie extra die de best scorende pagina's voor deze zoekopdracht nog steeds aanbevelen.

Data zijn de laatste commit op de default branch van elk project, gepeild op 2026-08-04. De repo-pagina van GitHub toont de laatste push naar om het even welke branch, wat voor twee projecten hier later is: UpTrain 2024-08-18 en Deepchecks 2025-12-28. Geen van beide repo's is gearchiveerd.

De kolom overstapkosten is degene die mensen overslaan en later betreuren. Scores zijn gewoon getallen, dus overstappen tussen DeepEval, Ragas, Opik en phoenix-evals betekent vooral een loop herschrijven. Overstappen van promptfoo of Inspect AI betekent een config- of taakformaat herschrijven zonder equivalent elders, en overstappen van Evidently betekent elke threshold die je schreef opnieuw controleren, omdat de schaal andersom loopt. Twee van de frameworks die de best scorende pagina's nog steeds aanbevelen, hebben sinds 2024 geen release meer uitgebracht.

Wil je liever tiers, gehoste platforms en een rechttoe-rechtaan ranglijst? Dat is een andere klus, en die hebben we al gedaan in onze gerangschikte vergelijking van LLM-evaluatietools inclusief betaalde platforms.

De Acht LLM-Evaluatieframeworks, Gegroepeerd Naar Installatiewijze

De installatievorm is waar je mee moet leven, dus dat is de indeling.

Python-bibliotheken die je in tests importeert

DeepEval (pip install deepeval, Apache-2.0) verpakt LLM-metrics in pytest-achtige assertions: bouw een LLMTestCase, geef die aan assert_test, en de test faalt onder je threshold. Het sterkste punt: een kwaliteitspoort naast de unittests die een team al draait. Kies dit als je evals in dezelfde CI-job horen als al het andere.

Eén disclosure, eenmalig genoemd: DeepEval wordt gebouwd door Confident AI, een betaalde partner bij twee andere posts op deze site, waaronder de gerangschikte vergelijking waar deze pagina naar linkt. Het krijgt hier geen voorkeursbehandeling, en elke DeepEval-link op deze pagina wijst naar de GitHub-repo.

Ragas (pip install ragas, Apache-2.0) is de RAG-specifieke optie: evaluate() neemt rijen met vraag, context en antwoord en geeft asynchroon per-metric scores terug. Het sterkste punt: retrievalkwaliteit meten binnen een Python-pipeline. De repo verhuisde van explodinggradients naar vibrantlabsai, de laatste release was v0.4.3 op 2026-01-13, en er zijn geen commits meer sinds 2026-02-24. Kies dit als RAG-metrics de hele klus zijn en een stille repo acceptabel is, en zie de bredere RAG-toolingstack.

Opik (pip install opik, Apache-2.0, van Comet) levert metrics die je op zichzelf kunt aanroepen. Zet OPIK_TRACK_DISABLE=true en AnswerRelevance().score() draait zonder account, zonder lokale server en zonder configbestand — iets wat de productframing niet adverteert. Het sterkste punt: een echte score in zo min mogelijk regels. Kies dit als je nu metrics wilt en het platform misschien later.

Evidently (pip install evidently, Apache-2.0) behandelt evals als descriptors over een dataset en schrijft als bijeffect een HTML-rapport. Het sterkste punt: batchrapportage over veel rijen in plaats van een binaire poort. De LLM-scores zijn omgekeerd: 1.0 betekent onbetrouwbaar. Kies dit als je iemand een deelbaar rapport verschuldigd bent, geen rode build.

Giskard (pip install giskard, Apache-2.0) scant een model op kwetsbaarheden in plaats van een dataset te scoren die jij schreef. Het PyPI-pakket lost naar de v2-lijn op, en de eigen README van het project stelt dat v2 "niet langer actief onderhouden wordt". Het sterkste punt: geautomatiseerde red-team-achtige scans. Kies dit als je liever kwetsbaarheden voor je laat vinden dan zelf LLM-as-a-judge-metrics te definiëren.

CLI-en-config-tools die je tegen een YAML-bestand draait

promptfoo (npm install promptfoo, MIT) is een CLI die een YAML-bestand leest: declareer providers, testcases en assertions, draai npx promptfoo eval, en krijg pass/fail per case plus een lokale results-UI. Het sterkste punt: prompts evalueren als je app niet in Python is geschreven. Kies dit als je kwaliteitspoort een configbestand moet zijn dat een niet-Python-teamgenoot kan bewerken.

Harness-klasse en platformgebundeld

Inspect AI (pip install inspect-ai, MIT) komt van het UK AI Safety Institute en evalueert modellen tegen taken die je in Python definieert, met echte solver- en scorer-abstracties en een run-viewer. Het sterkste punt: benchmarking op modelniveau met reproduceerbare taakdefinities. Kies dit als het geteste ding een model is in plaats van je applicatie.

Arize Phoenix (pip install arize-phoenix-evals) geeft je vooraf gebouwde evaluators zoals FaithfulnessEvaluator en CorrectnessEvaluator die een binair label plus een score teruggeven. Het sterkste punt: deterministische labels waarop je kunt gaten zonder een cutoff te kiezen. De licentie is de reden dat dit artikel een tussenzin in de titel heeft, en dat krijgt hierna zijn eigen sectie.

Is Arize Phoenix Open Source?

Nee, niet volgens de definitie die de Open Source Initiative hanteert. Arize Phoenix draait onder de Elastic License 2.0 (ELv2). Regel 1 van het LICENSE-bestand van de repo zegt dit, en PyPI verklaart onafhankelijk license: Elastic-2.0 op v19.15.0. De broncode is leesbaar, forkbaar en self-hostable. Eén gebruik is beperkt.

De beperking die telt: ELv2 verbiedt het aanbieden van de software aan derden als gehoste of beheerde dienst. Lees dat aandachtig, want het bindt veel minder mensen dan het klinkt. Als je arize-phoenix-evals installeert om je eigen applicatie te scoren, raakt ELv2 je nooit. Ben je een consultancy of een platformteam dat Phoenix verpakt in een evaluatiedienst die je aan externe klanten verkoopt, dan wel. Dat is het hele verschil, en de Open Source Definition is wat ELv2 niet haalt, specifiek de clausules over field-of-use-beperkingen.

Elke pagina die momenteel voor deze zoekopdracht rankt, plaatst Phoenix onder "open source", en wij deden dat ook. Onze eigen gerangschikte vergelijking van LLM-evaluatietools beschrijft Phoenix als volledig open source, wat onjuist is, en dat wordt gecorrigeerd. Phoenix is source-available, geen open source, en het onderscheid bijt alleen als je van plan bent het als dienst te verkopen. Als tracing in plaats van scoren is wat je eigenlijk nodig hebt, hoort dat bij AI-observability-platforms, niet hier.

Welke Hiervan Worden Nog Actief Onderhouden?

De meeste wel. Zes van de elf repo's die we controleerden kregen een commit naar main op 2026-08-03 of 2026-08-04: DeepEval, promptfoo, Opik, Arize Phoenix, Inspect AI en Giskard. Twee hebben sinds 2024 geen release meer uitgebracht. Eén is in 2026 stil geworden na een wijziging van GitHub-organisatie.

Frameworks waar we in 2026 geen nieuw project op zouden starten

UpTrain is dood. De laatste commit naar main landde op 2024-07-29 en de laatste release, v0.7.1, dateert van 2024-05-14, wat het op beide maten twee jaar koud maakt. De repo staat er nog en is nog steeds Apache-2.0, dus niets houdt je tegen, maar nieuw werk starten op een verlaten evaluatiebibliotheek is een beslissing die je later moet uitleggen.

Deepchecks verdient de precieze versie. Er is geen release meer geweest sinds 0.19.1 op 2024-12-15, hoewel de repo nog steeds commits ontvangt, met de laatste op main op 2025-11-24. Mensen werken er nog steeds aan; niemand heeft in meer dan achttien maanden een versie uitgebracht. Noch UpTrain, noch Deepchecks is gearchiveerd op GitHub, en geen van beide heeft de deur gesloten voor bijdragen.

Ragas krijgt data en verder niets. Laatste release v0.4.3 op 2026-01-13, geen commits sinds 2026-02-24, en de repo verhuisde van explodinggradients naar vibrantlabsai. We vonden geen verifieerbare verklaring voor de organisatiewijziging, dus verzinnen we er geen. Een stille repo is geen kapotte repo: Apache-2.0-code die vandaag een faithfulness-score berekent, doet dat volgend jaar nog steeds. Het risico zit in niet-gepatchte dependencies, precies wat ons in de test hieronder trof.

Andere pagina's op pagina één voor deze zoekopdracht bevelen UpTrain en Deepchecks nog steeds aan, zonder datum bij de aanbeveling. Een framework zonder release sinds december 2024 is een dependency-beslissing, geen feature-beslissing.

Heb Je een Eval-Framework Nodig of een Eval-Harness?

Een applicatie-evaluatieframework scoort de eigen outputs van je app tegen je eigen data. DeepEval, Ragas, promptfoo, Opik, phoenix-evals en Evidently doen dat allemaal. Een model-evaluatieharness (harness) benchmarkt in plaats daarvan een model tegen gestandaardiseerde publieke taken. lm-evaluation-harness en Inspect AI doen dat. De verkeerde klasse kiezen is de duurste fout op deze pagina.

Het faalscenario is concreet. Iemand koppelt lm-evaluation-harness aan de test van hun RAG-chatbot, krijgt een reeks MMLU-scores terug, en leert precies niets over of hun retriever de juiste passages teruggeeft. De scores zijn echt. Ze meten het basismodel, waar niemand zich zorgen om maakte.

De vorm van Inspect AI volgt uit zijn herkomst: het werd gebouwd bij het UK AI Safety Institute onder MIT voor het evalueren van frontier-modellen, dus solvers, scorers en taken zijn eersteklas en je applicatie is geen concept dat het kent. Dat is een goede reden om het te gebruiken waarvoor het bedoeld is. Als je probleem agents zijn in plaats van single turns, dan is agents evalueren in productie alweer een andere discipline, en tool-calling-servers krijgen hun eigen behandeling in onze gids over MCP-servers en -tools evalueren.

Wat Er Gebeurde Toen We Zes Ervan Installeerden en Dezelfde 10 Cases Draaiden

Op 2026-08-04 installeerden we zes hiervan in verse Python 3.11.14-venvs (plus npm voor promptfoo) en scoorden we één identieke RAG-set van 10 items met één judge, openai/gpt-4o-mini via OpenRouter op temperature 0. Zeven items waren correct. Drie waren op drie verschillende manieren fout: één spreekt de eigen context tegen, één verzint specifieke details, één is vloeiend proza dat de vraag nooit beantwoordt. Elk framework draaide twee keer, achter elkaar.

Vijf van de zes grounding-metrics vingen alle drie de fouten op. De drie bevindingen hieronder zijn de reden dat deze sectie bestaat.

Relevance-metrics zijn geen kwaliteitsmetrics, en twee ervan scoorden een zelfverzekerde leugen hoger dan een correct antwoord. Ragas ResponseRelevancy scoorde het item dat beweert dat HTTP 404 een 5xx-serverfout is op 0.777, hoger dan twee van de zeven correcte antwoorden, en het item met verzonnen rate limits op 0.813, hoger dan vier. promptfoo answer-relevance deed hetzelfde: 0.800 voor het 404-item, een schone pass tegen een threshold van 0.7, terwijl het correcte q01 faalde op 0.679. Geen bug. Een zelfverzekerd fout antwoord beantwoordt de vraag perfect. Maar als relevance het getal op je dashboard is, ziet een vloeiende hallucinatie eruit als je beste output.

Een poort die alleen op faithfulness let, mist het irrelevante antwoord. DeepEval scoorde het item dat de vraag nooit beantwoordt op 1.000 faithfulness, een schone pass, wat verdedigbaar is: een antwoord dat niets beweert over de context spreekt er ook niets in tegen. Alleen relevancy ving het op, op 0.000. Dat is de ene gemiste grounding-fout in de tabel hierboven. Elke metric apart heeft een gat; samen dekken ze beide.

Binaire evaluators waren stabiel op temperature 0. Gegradeerde niet. Phoenix en DeepEval verschoven geen van de tien items over twee identieke runs. Opik verschoof er vier, allemaal op AnswerRelevance, op een 0.05-grid; Evidently verschoof er ook vier. Geen enkele drift kantelde hier een verdict, maar promptfoo's correcte q01 landde op 0.679 en toen op 0.642 tegen een threshold van 0.700, wat de vorm heeft van een flaky CI-poort.

Twee kleinere kanttekeningen: drie van de zes (DeepEval, Opik, Phoenix) installeerden en draaiden meteen schoon, terwijl Ragas pas importeerde nadat we langchain-community<0.4 hadden vastgepind. Alleen promptfoo rapporteerde judge-tokengebruik: 16.011 assertion-tokens in run 1 en 16.010 in run 2.

De grenzen hiervan, zonder omwegen. n = 10 is een smoke test, geen benchmark: het vertelt je iets over ergonomie en blinde vlekken, niet over metric-nauwkeurigheid. Eén judge-model scoorde alles, en een groter judge-model zou elk getal verschuiven, waarschijnlijk inclusief de twee false positives die DeepEval en Ragas beide op hetzelfde correcte item produceerden. Twee runs bewijzen dat drift bestaat en kunnen die niet karakteriseren. Antwoorden waren vooraf geschreven, dus niets hier oefent generatie, tracing of datasetbeheer, wat promptfoo's installatie van 337.9 seconden er slechter uit laat zien dan het verdient. "Best" betekent altijd best voor een beperking: een CI-poort, RAG-metrics of een UI veranderen elk het antwoord, net als de scheiding tussen offline en online evaluatie.

Dezelfde Check, Drie Keer Geschreven

De snelste manier om een interface-vorm te kiezen is dezelfde assertion drie keer te lezen. Hier is een grounding-check op één item in DeepEval, Ragas en promptfoo, ingekort uit de scripts die we daadwerkelijk draaiden. De metric-namen verschillen; we linken naar hoe LLM-as-a-judge-metrics eigenlijk werken in plaats van ze hier opnieuw te definiëren.

# DeepEval 4.1.5: pytest-vormig, faalt de test onder de threshold
from deepeval import assert_test
from deepeval.models import GPTModel
from deepeval.metrics import FaithfulnessMetric
from deepeval.test_case import LLMTestCase

judge = GPTModel(
    model="openai/gpt-4o-mini",
    base_url="https://openrouter.ai/api/v1",
    api_key=OPENROUTER_KEY,
)

def test_faithfulness():
    case = LLMTestCase(
        input=question,
        actual_output=answer,
        retrieval_context=[context],
    )
    assert_test(case, [FaithfulnessMetric(threshold=0.7, model=judge)])

# Ragas 0.4.3: let op het importpad. `from ragas.metrics import Faithfulness`
# geeft een ImportError in deze versie; de concrete metric is verplaatst.
from ragas import evaluate, EvaluationDataset
from ragas.metrics._faithfulness import Faithfulness
from ragas.llms import LangchainLLMWrapper
from langchain_openai import ChatOpenAI

judge = LangchainLLMWrapper(
    ChatOpenAI(model="openai/gpt-4o-mini",
               base_url="https://openrouter.ai/api/v1")
)

result = evaluate(
    dataset=EvaluationDataset.from_list(rows),
    metrics=[Faithfulness(llm=judge)],
)

# promptfoo 0.121.20: npm install promptfoo, daarna npx promptfoo eval
providers:
  - id: echo          # we scored pre-written answers instead of generating them
defaultTest:
  assert:
    - type: context-faithfulness
      threshold: 0.7
tests:
  - vars:
      query: "Is HTTP 404 a client error or a server error?"
      context: "HTTP 404 Not Found is in the 4xx class, which denotes client errors."
      output: "HTTP 404 is a server error in the 5xx class."

De installatieregels bevatten meer valkuilen dan de code, en elke comment hieronder is iets dat ons tijd kostte op 2026-08-04:

# De echte promptfoo verschijnt op npm. Het PyPI-pakket met dezelfde naam is een
# wrapper van derden: https://pypi.org/project/promptfoo/ vs
# https://www.npmjs.com/package/promptfoo
npm install promptfoo

# pip install giskard lost naar de v2-lijn op, die de eigen README van het
# project markeert als niet langer actief onderhouden.
pip install giskard

# lm-evaluation-harness installeert onder de pakketnaam lm-eval.
pip install lm-eval

# Evidently trekt geen openai binnen, en de judge crasht bij call-time in plaats
# van import-time, nadat je de dataset al hebt opgebouwd.
pip install evidently openai

# Ragas 0.4.3 importeert niet tegen langchain-community 0.4.x.
pip install ragas "langchain-community<0.4"

Kun Je een Build Laten Falen op een Eval-Score?

Ja. Elk framework hier geeft een numerieke of binaire score terug, en elk sluit af met een non-zero exit code als een threshold-assertion faalt, wat alles is wat GitHub Actions nodig heeft om een build rood te kleuren. De exit code aansluiten is het makkelijke deel. Een threshold kiezen die je judge-model niet per ongeluk overschrijdt, is het deel dat een week kost.

Dit is de workflow-vorm die wij draaien, vastgepind op de versies uit onze test van 2026-08-04:

name: evals
on: [pull_request]

jobs:
  eval:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.11.14"
      - run: pip install deepeval==4.1.5

      - name: Score de golden set
        env:
          # Pin het judge-model. Een model-upgrade halverwege het kwartaal verschuift elke score.
          JUDGE_MODEL: openai/gpt-4o-mini
          # Thresholds staan op één plek, uitgelezen door de metric-constructors.
          EVAL_THRESHOLD: "0.7"
          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
        run: deepeval test run tests/evals/

Twee valkuilen bijten voordat de threshold dat doet. Ten eerste zijn judge-calls netwerkcalls: onze DeepEval-run met 10 items duurde 126.8 seconden omdat .measure() sequentieel is, en een golden set van 200 items op dat codepad is een koffiepauze bij elke pull request. Elk ander framework in de test parallelliseert standaard, wat de grootste enkele hendel is voor CI-wall-clock-tijd.

Ten tweede, flakiness. Op temperature 0 verschoven Opik en Evidently elk vier van de tien items tussen runs achter elkaar, en promptfoo's correcte antwoord stond op 0.679 en toen op 0.642 tegen een 0.700-poort. De mitigaties zijn saai en ze werken: draai een vaste golden dataset die alleen per pull request verandert, pin het judge-model, geef de voorkeur aan binaire evaluators waar een label volstaat, en gate op een delta in plaats van een absolute vloer. Dat laatste telt het meest voor multi-turn-evaluatie, waar één gesprek veel scores oplevert die elk kunnen wiebelen.

Ter schaal: LangChain's State of Agent Engineering survey (1.340 respondenten, verzameld van 18 november tot 2 december 2025, gepubliceerd op 12 juni 2026) vond dat 89% van de organisaties een vorm van observability heeft geïmplementeerd voor hun agents, terwijl slechts 52.4% offline evaluaties draait op testsets. Kijken is gebruikelijk. Gaten is dat niet.

Wat We Deze Week Zouden Installeren

Vier dingen om mee te nemen. Arize Phoenix is source-available onder Elastic License 2.0 en is geen OSI-goedgekeurde open source, wat voor de meeste lezers niets verandert en alles als je eval-tooling doorverkoopt. UpTrain is dood, en pagina's zonder datum erop bevelen het nog steeds aan. Deepchecks heeft ook sinds december 2024 geen release meer uitgebracht, hoewel de repo nog steeds commits ontvangt. Een grounding-metric en een relevance-metric hebben elk een gat dat de ander dekt, dus gate op beide. En gegradeerde scores drijven af op temperature 0, dus pin je judge en geef thresholds ruimte.

Als ik deze week een nieuwe evalsuite zou starten, zou ik DeepEval installeren voor de CI-poort, omdat assertions naast tests horen (disclosure hierboven), en Opik's losstaande metrics toevoegen voor de scherpste scheiding die we maten. Als onze stack geen Python was, dan promptfoo, zonder aarzelen. Als je liever hebt dat iemand anders de golden set en de workflow opzet, dat is een gesprek dat we graag voeren.

Veelgestelde Vragen

Wat is het beste open source LLM-evaluatieframework?

Er is geen enkele winnaar, alleen een beste fit per beperking. Voor een pass/fail-poort binnen een Python-testsuite: DeepEval. Voor een taalonafhankelijke YAML- en CLI-opzet: promptfoo. Voor RAG-retrievalmetrics: Ragas, als je een repo zonder commits sinds 2026-02-24 kunt accepteren. Voor de scherpste scheiding tussen goede en foute antwoorden in onze test van 2026-08-04: Opik.

Is Arize Phoenix open source?

Niet volgens de definitie van de Open Source Initiative. Arize Phoenix draait onder de Elastic License 2.0, die PyPI declareert als license: Elastic-2.0 op v19.15.0 en die regel 1 van het LICENSE-bestand van de repo rechtstreeks vermeldt. Het is source-available: je kunt het lezen, forken, aanpassen en self-hosten. De enige beperking is het aanbieden van de software aan derden als gehoste of beheerde dienst.

Wordt Ragas nog onderhouden?

De verifieerbare feiten, per 2026-08-04: de laatste release was v0.4.3 op 2026-01-13, er zijn geen commits meer geweest sinds 2026-02-24, en de repository verhuisde van de organisatie explodinggradients naar vibrantlabsai. De repo is niet gearchiveerd. We vonden geen betrouwbare publieke verklaring voor de organisatiewijziging en speculeren er niet over. De Apache-2.0-code draait nog steeds; het risico zit in niet-gepatchte dependencies.

Heb ik een eval-framework nodig of een observability-platform?

Beide, uiteindelijk, maar ze beantwoorden verschillende vragen. Een eval-framework vertelt je of een wijziging je outputs beter of slechter maakte voordat je hem uitrolt, op een dataset die jij beheert. Een observability-platform vertelt je wat er daadwerkelijk gebeurde in productie nadat je hebt uitgerold. Begin met het eval-framework als je een CI-pipeline hebt; zie AI-observability-platforms voor de productiekant.

Kan ik LLM-evals in CI/CD draaien?

Ja. Elk hier behandeld framework sluit af met non-zero bij een gefaalde threshold-assertion, wat alles is wat een GitHub Actions-job nodig heeft. De praktische beperkingen zijn wall-clock-tijd (judge-calls zijn netwerkcalls, en onze sequentiële DeepEval-run duurde 126.8 seconden voor 10 items) en judge-non-determinisme. De workflow-vorm en mitigaties staan in de CI-sectie hierboven.

Wat is het verschil tussen DeepEval en Ragas?

Interface-vorm en scope, geen kwaliteit. DeepEval is pytest-vormig en algemeen bruikbaar: je schrijft testcases en assert op metric-thresholds, en het dekt applicatie-outputs van vele soorten. Ragas is een RAG-specifieke bibliotheek waarvan evaluate() asynchroon draait over een dataset van rijen met vraag, context en antwoord. DeepEval past natuurlijker bij een CI-poort; Ragas gaat dieper op retrieval.

Waarom geeft pip install promptfoo mij het verkeerde pakket?

Omdat promptfoo een Node-project is. Het echte project wordt gepubliceerd op npm onder MIT en installeert met npm install promptfoo. Het PyPI-pakket met dezelfde naam is een wrapper van derden, niet het upstream project, en het installeren ervan is een veelvoorkomende manier om te eindigen met het debuggen van een CLI die niet degene is die de docs beschrijven.

Is lm-evaluation-harness een LLM-evaluatieframework?

Het is een model-evaluatieharness, een verwante maar andere klus. lm-evaluation-harness (geïnstalleerd als pip install lm-eval) benchmarkt een model tegen gestandaardiseerde publieke taken zoals MMLU. Het vertelt je niet of je retrievalpipeline de juiste passage teruggaf, omdat je applicatie geen concept is dat het kent. Zie de sectie framework-versus-harness hierboven voor het onderscheid.

Zijn deze frameworks gratis te gebruiken?

Licentiegewijs wel. DeepEval, Ragas, Opik, Evidently en Giskard zijn Apache-2.0; promptfoo, Inspect AI en lm-evaluation-harness zijn MIT. Beide licenties staan commercieel gebruik, aanpassing en herdistributie toe. Arize Phoenix is de uitzondering: Elastic License 2.0 staat self-hosting toe maar niet het aanbieden van de software aan derden als beheerde dienst. Judge-model-API-gebruik wordt apart in rekening gebracht door je provider.