Opik, śledzenie i ocena aplikacji LLM

Opik, śledzenie i ocena aplikacji LLM

Opik to platforma firmy Comet ML do zbierania śladów wywołań modeli językowych i do ich oceny. Wersja 2.2.36 wyszła 21 sierpnia 2026 roku i tego samego dnia pojawiła się w PyPI oraz w npm, obie paczki na Apache 2.0. Cały kod leży w jednym repozytorium na tej samej licencji, bez katalogu z osobnymi warunkami, a to w tej kategorii narzędzi rzadkość.

Co Opik robi i skąd pochodzi

Opik składa się z trzech warstw i rozdzielenie ich od siebie od razu porządkuje myślenie o kosztach.

Pierwsza to biblioteki klienckie: paczka opik w PyPI i paczka opik w npm. Zbierają ślady, czyli drzewa spanów opisujących przebieg pojedynczego żądania: wywołanie modelu, wywołanie narzędzia, krok agenta. Druga to serwer z bazami danych i panelem, uruchamiany u siebie albo dostępny jako usługa hostowana pod adresem https://www.comet.com/opik/api. Trzecia to biblioteka ewaluacyjna: zestawy danych, funkcje oceniające, eksperymenty i porównania między nimi.

Comet ML jest firmą starszą niż Opik. Jej pierwotny produkt to platforma MLOps do śledzenia treningów modeli, a Opik jest osobną linią produktową dla aplikacji generatywnych. Na stronie z cennikiem obie rodziny mają własne tabele planów i własne jednostki rozliczeniowe, co przy pierwszym czytaniu potrafi zmylić.

Repozytorium comet-ml/opik odpowiada kodem 200 i nie przekierowuje gdzie indziej. Kanał wydań w formacie Atom jest natomiast trudny do czytania: obok właściwego wydania 2.2.36 z 21 sierpnia 2026 roku leżą w nim dziesiątki tagów budowania z ciągłej integracji w rodzaju 2.2.37-6393 czy 2.2.37-7950-merge-3036, publikowanych tego samego dnia. Do śledzenia wersji rejestry pakietów są tu wiarygodniejsze niż lista wydań.

Zgodność numeracji między rejestrami zasługuje na osobne zdanie, bo w tej kategorii nie jest normą. PyPI i npm mają dla Opika ten sam numer 2.2.36 i tę samą datę. Dla porównania w npm langfuse ma 3.38.20 z 1 kwietnia 2026 roku, a w PyPI langfuse ma 4.14.4 z 11 sierpnia 2026 roku. Dla Braintrusta npm pokazuje 3.28.0, a PyPI 0.34.0. Jeśli przypinasz wersje w dwóch językach naraz, wspólna numeracja oszczędza sporo pilnowania.

Paczka pythonowa instaluje też polecenie opik jako skrypt konsolowy oraz rejestruje wtyczkę pytest przez punkt wejścia pytest11 wskazujący na opik.plugins.pytest.hooks. To wyjaśnia jedną z rzeczy, które zaraz zobaczysz na liście zależności.

Licencja sprawdzona w trzech miejscach

Sprawdziłem licencję w trzech niezależnych źródłach, bo w tej kategorii narzędzi deklaracja z rejestru bywa niezgodna z zawartością paczki.

W repozytorium jest plik LICENSE i tylko on, LICENSE.md zwraca 404. Ma 203 linie, zaczyna się od wiersza Copyright (c) Comet ML, Inc, dalej idzie standardowy tekst Apache License 2.0, a w załączniku widnieje Copyright 2024 Comet ML, Inc. Nie ma żadnych klauzul dodanych ponad tekst wzorcowy. Osobne, identyczne kopie leżą w sdks/python/LICENSE i sdks/typescript/LICENSE.

Pole license w rejestrach wygląda różnie w zależności od ekosystemu. npm podaje Apache-2.0, czyli poprawny identyfikator SPDX. PyPI podaje ciąg Apache 2.0 License, a pole license_expression jest puste. To tekst swobodny, nie identyfikator, więc narzędzie do audytu zależności dopasowujące po SPDX go nie rozpozna i będzie potrzebowało ręcznej reguły. Jest to i tak lepszy stan niż wklejenie całego tekstu licencji w to pole, co robią niektóre inne projekty.

Została zawartość opublikowanych paczek. Koło opik-2.2.36-py3-none-any.whl zawiera katalogi opik/ i _opik/ z prawdziwym kodem oraz plik licencyjny w opik-2.2.36.dist-info/licenses/LICENSE, znowu Apache 2.0. Archiwum npm opik-2.2.36.tgz zawiera LICENSE, README.md i katalog dist/ z index.cjs, index.js oraz deklaracjami typów. Żadna z paczek nie jest atrapą i w żadnej nie brakuje pliku licencyjnego.

Zostaje pytanie najważniejsze przy platformach ewaluacyjnych: czy w repozytorium nie ma katalogu serwerowego na osobnej, restrykcyjniejszej licencji. Sprawdziłem ścieżki, na których takie pliki zwykle leżą: apps/opik-backend/LICENSE, apps/opik-frontend/LICENSE, apps/opik-guardrails-backend/LICENSE, deployment/helm_chart/opik/LICENSE oraz NOTICE w katalogu głównym. Wszystkie zwracają 404. Zaznaczam wprost założenie: sprawdziłem kandydatów, a nie całe drzewo repozytorium, bo nie korzystałem z interfejsu programistycznego GitHuba. Przy tym zastrzeżeniu obraz jest czysty, czyli Apache 2.0 na całości, i to jest realny wyróżnik na tle narzędzi, które trzymają serwer na licencji wzajemnościowej, a klienta na permisywnej.

Instalacja, zależności i pierwszy ślad

Instalacja jest krótka, natomiast lista zależności zasługuje na spojrzenie przed dodaniem paczki do środowiska produkcyjnego.

# klient pythonowy, wymaga Pythona 3.10 lub nowszego
pip install opik

# interaktywna konfiguracja: zapisuje klucz i adres w ~/.opik.config
opik configure

# klient TypeScript, wymaga Node 18 lub nowszego
npm install opik

# uruchomienie platformy u siebie
git clone https://github.com/comet-ml/opik.git
cd opik
./opik.sh                      # pełny zestaw, panel na http://localhost:5173
./opik.sh --infra              # tylko bazy danych i magazyn obiektów
./opik.sh --backend            # infrastruktura plus backend, bez panelu
./opik.sh --guardrails         # z usługą guardrails
./opik.sh --verify             # sprawdzenie stanu kontenerów
./opik.sh --stop
./opik.sh --clean              # usunięcie danych

Po stronie Pythona wymagany jest interpreter co najmniej 3.10. Wśród zależności obowiązkowych, a nie opcjonalnych, siedzą pytest i sentry_sdk>=2.0.0. Pytest jest tam dlatego, że paczka rejestruje wtyczkę testową, ale efekt jest taki, że biblioteka do telemetrii wciąga framework testowy do obrazu produkcyjnego. Dalej jest litellm z długą listą wykluczeń wersji: !=1.81.*, !=1.82.*, !=1.83.0 do !=1.83.6, !=1.92.*, a dla Pythona starszego niż 3.11 dodatkowo górna granica <1.97, której na 3.11 i wyżej już nie ma. Taka lista jest zapisem historii zepsutych wydań u dostawcy i sygnałem, że aktualizacja litellm w projekcie potrafi zderzyć się z tym ograniczeniem. Do tego dochodzą boto3-stubs[bedrock-runtime], openai, pydantic, rich, tenacity, uuid6, jinja2, watchfiles oraz trzy paczki tree-sitter, pomijane na Linuksie w architekturze aarch64. Dodatek proxy dokłada fastapi i uvicorn.

Klient TypeScript ma zupełnie inny zestaw zależności i nie należy przenosić wniosków z jednego na drugi. Ma dwadzieścia sześć zależności wykonawczych, w tym ai w wersji ^6.0.13 oraz cztery pakiety dostawców @ai-sdk: openai, anthropic, google i google-vertex. Zależność równorzędna to zod w zakresie ^3.25.55 || ^4.0.0.

Tu jest usterka, na którą warto się przygotować. Pakiety integracyjne opik-openai i opik-langchain mają numer 2.2.36, ten sam co rdzeń, ale ich zakresy zależności równorzędnych zostały w poprzedniej linii wersji: opik-openai żąda opik w zakresie ^1.8.61, a opik-langchain w zakresie ^1.8.75. Żaden z tych zakresów nie obejmuje wersji 2.2.36, więc instalacja rdzenia razem z integracją kończy się konfliktem ERESOLVE w npm 7 i nowszym.

Samo instrumentowanie kodu jest proste. Dekorator @track przyjmuje między innymi name, type, tags, metadata, capture_input, ignore_arguments, capture_output, flush, project_name i environment.

import opik
from opik import Opik

@opik.track(
    name="retrieve_context",
    type="tool",
    tags=["rag", "produkcja"],
    capture_output=False,
    ignore_arguments=["api_key"],
)
def retrieve(query: str, api_key: str) -> list[str]:
    return ["fragment 1", "fragment 2"]

@opik.track(name="answer", type="llm", entrypoint=True)
def answer(question: str) -> str:
    context = retrieve(question, api_key="tajne")
    return f"Odpowiedź na podstawie {len(context)} fragmentów"

client = Opik(project_name="asystent", batching=True)
answer("Jak działa retencja spanów?")
client.flush()

Parametr ignore_arguments jest tu istotny z powodów praktycznych, bo domyślnie capture_input zapisuje wszystkie argumenty funkcji, łącznie z kluczami i danymi osobowymi. Parametr batching jest domyślnie włączony i dokumentacja klasy Opik ostrzega przy nim wprost: operacje aktualizujące, czyli update_span i update_trace, mogą stracić dane, jeśli aktualizacja dotrze do serwera przed opróżnieniem kolejki z żądaniem tworzącym.

Zestawy danych i eksperymenty

Ewaluacja w Opiku opiera się na zestawie danych, funkcji wykonującej zadanie i liście metryk. Funkcja evaluate scala te trzy elementy w eksperyment widoczny w panelu.

import opik
from opik.evaluation import evaluate
from opik.evaluation.metrics import Hallucination, Equals

client = opik.Opik()
dataset = client.get_or_create_dataset(
    name="pytania-produkcyjne",
    description="Zrzut z ruchu, sierpień 2026",
)
dataset.insert(
    [
        {"input": "Ile dni wynosi retencja?", "expected_output": "60 dni"},
        {"input": "Czy jest RBAC w self-host?", "expected_output": "nie"},
    ],
    num_threads=1,
)

def task(item: dict) -> dict:
    return {
        "input": item["input"],
        "output": moj_agent(item["input"]),
        "reference": item["expected_output"],
        "context": [],
    }

result = evaluate(
    dataset=dataset,
    task=task,
    scoring_metrics=[Equals(), Hallucination(model="openai/gpt-4.1-mini")],
    experiment_name="wersja-promptu-7",
    experiment_config={"prompt_version": 7, "temperature": 0.2},
    task_threads=16,
    nb_samples=200,
    trial_count=1,
    experiment_tags=["regresja"],
)

Kilka szczegółów z tej sygnatury ma znaczenie w codziennej pracy. Parametr task_threads domyślnie wynosi 16, więc bez zmiany tej wartości uderzasz w dostawcę modelu szesnastoma równoległymi żądaniami i możesz trafić na limit zapytań. Parametr nb_samples ogranicza liczbę elementów, co jest najtańszym sposobem na przejazd próbny przed pełnym uruchomieniem. Parametr project_name w evaluate jest oznaczony jako przestarzały: jeśli zestaw danych ma ustawione project_name, ten argument jest ignorowany, a użytkownik dostaje ostrzeżenie. Parametr scoring_key_mapping służy do przemapowania kluczy, gdy zadanie zwraca inne nazwy niż te, których oczekuje metoda score metryki.

Metoda dataset.insert tworzy nową wersję zestawu przy każdym wywołaniu. Jej dokumentacja mówi też, że przy num_threads większym niż jeden porcje wysyłane są równolegle, a w razie błędu jednej z nich wyjątek jest podnoszony ponownie i nie ma wycofania, więc porcje już wysłane zostają na serwerze.

Osobna funkcja evaluate_experiment przyjmuje experiment_name, scoring_metrics i scoring_threads i dolicza metryki do istniejącego eksperymentu bez ponownego uruchamiania zadania. To ważne dla kosztów: jeśli dołożyłeś nową metrykę sędziowską, nie musisz ponownie odpalać całej aplikacji, tylko sam etap oceny.

Klient TypeScript ma odpowiednik o tym samym kształcie, z polami w konwencji camelCase.

import { evaluate, Opik } from "opik";

const client = new Opik();
const dataset = await client.getOrCreateDataset("pytania-produkcyjne");

const result = await evaluate({
  dataset,
  task: async (item) => ({ output: await mojAgent(item.input as string) }),
  scoringMetrics: [],
  experimentName: "wersja-promptu-7",
  experimentConfig: { promptVersion: 7 },
  nbSamples: 200,
});

Metryki, czyli co jest deterministyczne, a co płaci za sędziego

To jest najbardziej praktyczna część, bo rachunek za ewaluację potrafi przewyższyć rachunek za samą aplikację. W paczce 2.2.36 katalog opik/evaluation/metrics/heuristics zawiera dwadzieścia modułów, a katalog llm_judges trzynaście podpakietów.

Metryki deterministyczne liczą się lokalnie i nie generują ruchu do dostawcy modelu. Należą do nich Equals, Contains, RegexMatch, IsJson, LevenshteinRatio, SentenceBLEU, CorpusBLEU, ROUGE, GLEU, ChrF, METEOR, Readability, Tone, PromptInjection, SpearmanRanking, Sentiment, VADERSentiment oraz trójka JSDivergence, JSDistance i KLDivergence. Metoda Equals.score przyjmuje output i reference, a PromptInjection działa na liście wyrażeń regularnych i słów kluczowych podawanych w patterns i keywords.

Jest kategoria pośrednia, o której łatwo zapomnieć. BERTScore przyjmuje model_type z domyślną wartością bert-base-uncased i liczy się na modelu transformerowym pobieranym lokalnie, a LanguageAdherenceMetric przyjmuje expected_language i opcjonalne model_path do modelu fastText. To nie są wywołania płatnego interfejsu, ale to też nie jest darmowa arytmetyka: potrzebują pamięci, czasu i pobrania wag.

Część metryk heurystycznych ma zależności spoza podstawowej instalacji. SentenceBLEU i CorpusBLEU wymagają nltk i same podnoszą wyjątek z komunikatem o konieczności instalacji, a Readability korzysta z modułu textstat. Nie są to zależności paczki opik, więc pierwsze uruchomienie na czystym środowisku kończy się błędem.

Metryki sędziowskie wywołują model przy każdym elemencie zestawu. Są to AnswerRelevance, ContextPrecision, ContextRecall, Hallucination, Moderation, Usefulness, TrajectoryAccuracy, SycEval, StructuredOutputCompliance, LLMJuriesJudge oraz GEval z zestawem gotowych ustawień, w tym AgentTaskCompletionJudge, AgentToolCorrectnessJudge, QARelevanceJudge, SummarizationCoherenceJudge, GenderBiasJudge i PoliticalBiasJudge. Osobną grupę tworzą metryki konwersacyjne, na przykład ConversationalCoherenceMetric, UserFrustrationMetric i SessionCompletenessQuality.

Domyślny model sędziego jest zapisany w kodzie i wynosi openai/gpt-5-nano, w polu default_llm klasy OpikConfig. Wywołanie idzie przez LiteLLM, więc nazwa modelu przyjmuje format dostawcy. Warto to znać, bo uruchomienie Hallucination() bez argumentów po cichu wybiera model, za który płacisz Ty, a nie Comet.

from opik.evaluation.metrics import (
    Equals, RegexMatch, IsJson,       # deterministyczne, bez rachunku
    Hallucination, AnswerRelevance,   # sędzia, wywołanie modelu na element
    GEval,
)

tanie = [Equals(), RegexMatch(regex=r"^\d{4}-\d{2}-\d{2}$"), IsJson()]

drogie = [
    Hallucination(model="openai/gpt-4.1-mini", temperature=0.0, seed=42),
    AnswerRelevance(model="openai/gpt-4.1-mini", track=False),
    GEval(
        task_introduction="Oceniasz, czy odpowiedź trzyma się kontekstu.",
        evaluation_criteria="1 oznacza brak związku, 5 pełną zgodność.",
        model="openai/gpt-4.1-mini",
        temperature=0.0,
        reasoning_effort="low",
    ),
]

wynik = Hallucination().score(
    input="Ile dni wynosi retencja?",
    output="Sześćdziesiąt dni.",
    context=["Retencja spanów w planie Free wynosi 60 dni."],
)
print(wynik.value, wynik.reason)

Trzy szczegóły z powyższego kodu. Po pierwsze, każda metryka ma parametr track domyślnie ustawiony na True, co oznacza, że wynik metryki jest zapisywany jako osobny ślad. W usłudze hostowanej rozliczanej za spany ewaluacja podbija więc licznik, od którego zależy rachunek. Po drugie, GEval przyjmuje reasoning_effort i dokumentacja sama pisze, że domyślnie stosuje się wartość dostawcy, zwykle medium, więc ustawienie low jest sposobem na obcięcie tokenów rozumowania. Po trzecie, sygnatury metod score są różne: Hallucination.score i AnswerRelevance.score przyjmują input, output i opcjonalny context, natomiast ContextPrecision.score wymaga dodatkowo expected_output i obowiązkowego context.

Drobna pułapka na koniec tej sekcji: w katalogu llm_judges jest podpakiet factuality, ale import klasy Factuality jest w kodzie zakomentowany i nazwa nie występuje w __all__. Metryki o tej nazwie nie zaimportujesz z opik.evaluation.metrics, mimo że pliki są w paczce.

Self-host kontra chmura, czyli co zostaje w płatnym planie

Wariant do uruchomienia u siebie stawia komplet usług. Z pliku docker-compose.yaml w repozytorium wynika, że są to MySQL 8.4.2, Redis 7.2.4, ClickHouse w wydaniu 26.3.16.16 razem z ZooKeeperem 3.9.4, MinIO jako magazyn obiektów, backend w Javie z migracjami Liquibase, panel oraz kolektor OpenTelemetry. To sześć do ośmiu kontenerów i dwie bazy danych o zupełnie różnej charakterystyce operacyjnej. Jest też karta Helm w deployment/helm_chart/opik. Nazwijmy to wprost: samodzielne hostowanie platformy ewaluacyjnej to kolejna usługa produkcyjna do utrzymania, z kopiami zapasowymi ClickHouse włącznie.

Podział funkcji między warianty odczytałem z tabeli porównawczej na stronie z cennikiem Comet, sprawdzonej 22 sierpnia 2026 roku.

Wnioski z tej tabeli są dwa i idą w przeciwne strony. Pierwszy jest zgodny z przewidywaniem: kontrola dostępu oparta na rolach, logowanie jednokrotne w protokołach OAuth 2.0, SAML i LDAP, konta serwisowe, użytkownicy tylko do odczytu oraz zgodność z SOC 2, ISO 27001, ISO 9001, HIPAA i RODO są zarezerwowane dla planu Enterprise i nie ma ich ani w wariancie u siebie, ani w płatnym planie Pro. Drugi jest odwrotny do przewidywania: guardrails, czyli blokowanie treści na wejściu i wyjściu modelu, ma znacznik dostępności tylko w kolumnie Open Source, a wszystkie trzy plany chmurowe mają w tym wierszu kreskę. W paczce pythonowej odpowiada temu moduł opik.guardrails z klasami Guardrail, Topic, PII, LLMJudge, PromptInjection i CustomGuardrail. Wariantu u siebie brakuje natomiast asystenta OpikAssist i harnessu Opik Connect, czyli funkcji, w których Comet dokłada własne wywołania modelu.

Jednostką rozliczeniową jest span, definiowany na stronie jako pojedyncza para wejście i wyjście: wywołanie modelu, wywołanie narzędzia albo śledzona funkcja. Nie tokeny. Jeden span może zawierać ich wiele.

Dwie rzeczy wymagają zastrzeżenia. Po pierwsze, ta sama strona podaje dwie różne liczby o zespole: karty planów mówią o maksymalnie 10 osobach w planie Free i maksymalnie 50 w planie Pro, a sekcja pytań i odpowiedzi niżej twierdzi, że wszystkie plany mają nieograniczoną liczbę członków zespołu. Podaję obie i oznaczam rozbieżność, bo nie da się jej rozstrzygnić z samej strony. Po drugie, cennik nie mówi, co dzieje się po przekroczeniu 25 tysięcy spanów w planie darmowym. Wiadomo tylko, że w tym planie nie da się dokupić spanów, bo wiersz z dopłatą ma kreskę. Czy ruch jest odrzucany, czy przestrzeń robocza jest blokowana, tego strona nie precyzuje i nie będę zgadywał. Cena roczna nie jest publikowana w ogóle, podana jest wyłącznie kwota miesięczna, więc nie ma tu arytmetyki do sprawdzenia.

Opik na tle Langfuse, Braintrust, Promptfoo i Ragas

W tej kolekcji jest już kilka narzędzi z sąsiedztwa i różnice między nimi są konkretne, a nie kosmetyczne.

Opik mieści się dokładnie pośrodku tej stawki. Ma otwarty kod i wariant do uruchomienia u siebie, jak Langfuse, ale kładzie na ewaluację nacisk podobny do Braintrusta, z zestawami testowymi, asercjami i porównaniami eksperymentów jako pierwszoplanową funkcją, a nie dodatkiem do śladów. Jest przy tym cięższy niż Promptfoo, który nie potrzebuje ani konta, ani serwera, i szerszy niż Ragas, który jest biblioteką metryk dla systemów opartych na wyszukiwaniu, a nie platformą. Opik zresztą Ragasa opakowuje, bo w metrykach jest klasa RagasMetricWrapper.

Jeśli szukasz odpowiedzi jednym zdaniem: Promptfoo bierzesz do szybkiej regresji promptów w repozytorium, Ragasa do liczenia metryk wyszukiwania w notatniku, Langfuse do samych śladów, Braintrusta gdy nie przeszkadza Ci zamknięta platforma, a Opika wtedy, gdy chcesz ślady i ewaluację w jednym miejscu i zależy Ci na możliwości postawienia tego u siebie. Do porównania warto zajrzeć też do LangSmith, który zajmuje podobną niszę po stronie zamkniętej.

Model sędziego jest tu ortogonalny do wyboru platformy. Domyślnie idzie do OpenAI, ale przez LiteLLM podłączysz Claude albo dowolnego innego dostawcę, i to ta decyzja, a nie wybór panelu, zdecyduje o rachunku za ewaluację.

Typowe błędy

Instalacja pakietów integracyjnych obok rdzenia. npm install opik@2.2.36 opik-openai@2.2.36 kończy się konfliktem, bo integracja deklaruje zależność równorzędną opik w zakresie ^1.8.61. Obejściem jest flaga wymuszająca albo pozostanie przy starszej linii rdzenia, ale najpierw sprawdź, czy zakres nie został poprawiony w nowszym wydaniu.

Założenie, że wariant u siebie ma wszystko. Kontroli dostępu opartej na rolach i logowania jednokrotnego tam nie ma i nie ma ich też w płatnym planie Pro. Jeśli potrzebujesz jednego i drugiego, jedyną ścieżką jest rozmowa handlowa.

Uruchomienie metryki sędziowskiej bez podania modelu. Hallucination() bez argumentów sięga po openai/gpt-5-nano z konfiguracji. Na zestawie pięciu tysięcy elementów i trzech metrykach sędziowskich to piętnaście tysięcy wywołań modelu, o których nikt świadomie nie zdecydował.

Zapominanie o track=True w metrykach. Wynik każdej metryki jest domyślnie logowany jako osobny ślad, więc ewaluacja sama podbija licznik spanów, od którego zależy rachunek w chmurze. Przy dużych przejazdach track=False bywa sensownym ustawieniem.

Traktowanie dataset.insert jak operacji idempotentnej. Każde wywołanie tworzy nową wersję zestawu, a przy równoległym wysyłaniu porcji nie ma wycofania, więc częściowa awaria zostawia zestaw w stanie pośrednim.

Poleganie na project_name w evaluate. Argument jest przestarzały i jest ignorowany, jeśli zestaw danych ma własne project_name. Ślady trafią wtedy gdzie indziej, niż się spodziewasz.

Liczenie na to, że metryki tekstowe zadziałają po samym pip install opik. SentenceBLEU wymaga nltk, Readability wymaga textstat, BERTScore wymaga bert_score i pobrania wag modelu. Żadna z tych paczek nie jest zależnością Opika.

FAQ

Czy Opik jest w całości otwarty?

Na podstawie sprawdzonych plików tak. W repozytorium jest jeden plik LICENSE na Apache 2.0, identyczne kopie leżą w katalogach obu bibliotek klienckich, a na sprawdzonych ścieżkach katalogów serwerowych nie ma osobnych plików licencyjnych. Zastrzegam, że sprawdziłem wybrane ścieżki, a nie całe drzewo repozytorium.

Ile kosztuje wersja hostowana i co daje darmowy plan?

Plan darmowy w chmurze daje 25 tysięcy spanów miesięcznie i 60 dni retencji, bez możliwości dokupienia spanów. Plan Pro kosztuje 19 dolarów miesięcznie, daje 100 tysięcy spanów, dopłata to 5 dolarów za każde kolejne 100 tysięcy, a wydłużenie retencji do 400 dni kosztuje 29 dolarów za 100 tysięcy spanów. Co dokładnie dzieje się po przekroczeniu limitu w planie darmowym, cennik nie precyzuje.

Które metryki generują rachunek u dostawcy modelu?

Wszystkie z katalogu llm_judges, czyli między innymi Hallucination, AnswerRelevance, ContextPrecision, Moderation, TrajectoryAccuracy i cała rodzina GEval. Metryki z katalogu heuristics, na przykład Equals, RegexMatch, IsJson, ROUGE czy LevenshteinRatio, liczą się lokalnie. Osobno stoi BERTScore, który nie wywołuje interfejsu płatnego, ale pobiera i uruchamia model transformerowy.

Czy da się używać Opika bez wysyłania danych na zewnątrz?

Panel i bazy danych postawisz u siebie poleceniem ./opik.sh, a klient wskażesz na lokalny adres przez opik.configure(use_local=True). Pamiętaj jednak, że metryki sędziowskie i tak wysyłają treść do dostawcy modelu, chyba że podłączysz model lokalny, oraz że paczka pythonowa ma sentry_sdk wśród zależności obowiązkowych.

Czy warto wybrać Opika zamiast Langfuse?

Zależy od tego, czy ewaluacja jest u Ciebie pierwszoplanowa. Jeśli potrzebujesz głównie śladów, obie platformy je dają. Jeśli potrzebujesz zestawów testowych, biblioteki metryk sędziowskich i porównań eksperymentów w tym samym panelu, Opik ma to gotowe. Za to jest to produkt młody, rozwijany przez jedną firmę, więc ryzyko przywiązania do dostawcy pozostaje realne nawet przy licencji Apache 2.0.