0Pricing
AI Engineering Academy · Lekcja

Langfuse do obserwowalności niezależnej od modelu

Zintegruj Langfuse jako otwartoźródłową alternatywę działającą z dowolnym dostawcą LLM, rejestruj niestandardowe odcinki dla wyszukiwania i wywołań narzędzi oraz skonfiguruj pulpity śledzenia kosztów.

Langfuse do obserwowalności niezależnej od modelu to bezpłatna lekcja AI Engineering Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Engineering Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.

Langfuse: obserwowalność LLM o otwartym kodzie źródłowym

Langfuse to platforma obserwowalności o otwartym kodzie źródłowym dla aplikacji LLM, która działa z dowolnym dostawcą modeli: OpenAI, Anthropic, Mistral, modelami lokalnymi za pośrednictwem Ollama lub własnym dostrojonym modelem. W przeciwieństwie do LangSmith, który wiąże Państwa z LangChain, Langfuse integruje się z dowolnym kodem Pythona za pomocą prostego SDK. Mogą Państwo bezpłatnie hostować Langfuse samodzielnie lub korzystać z zarządzanej chmury pod adresem cloud.langfuse.com.

# pip install langfuse
from langfuse import Langfuse

langfuse = Langfuse(
    public_key='pk-lf-...',
    secret_key='sk-lf-...',
    host='https://cloud.langfuse.com'  # or your self-hosted URL
)

print('Langfuse connected:', langfuse.auth_check())

Ślady, spany i generacje

Langfuse korzysta z hierarchicznego modelu danych obejmującego trzy poziomy. Ślad reprezentuje jedno żądanie użytkownika obsłużone od początku do końca. W ramach śladu spany reprezentują poszczególne kroki przetwarzania (pobieranie danych, wstępne przetwarzanie, wywołania narzędzi). Generacje to specjalny typ spanu przeznaczony do wywołań LLM: w uporządkowany sposób rejestrują model, tokeny promptu, tokeny uzupełnienia oraz koszt, co umożliwia tworzenie pulpitów kosztów i metryk jakości.

from langfuse import Langfuse

langfuse = Langfuse()

# Create a trace for one user request
trace = langfuse.trace(
    name='rag-query',
    user_id='user_123',
    session_id='session_abc',
    tags=['production', 'rag']
)

# Add a retrieval span
retrieval_span = trace.span(
    name='vector-retrieval',
    input={'query': 'What is RAG?'}
)
chunks = vector_db.search('What is RAG?')
retrieval_span.end(output={'chunks': [c['text'][:100] for c in chunks]})

# Add an LLM generation
generation = trace.generation(
    name='answer-generation',
    model='gpt-4o',
    model_parameters={'temperature': 0.0},
    input=[{'role': 'user', 'content': 'Context: ...\nQuestion: What is RAG?'}]
)
response = openai_client.chat.completions.create(model='gpt-4o', messages=[...])
generation.end(
    output=response.choices[0].message.content,
    usage={'input': response.usage.prompt_tokens, 'output': response.usage.completion_tokens}
)

Wzorzec integracji za pomocą dekoratora

Langfuse udostępnia dekoratory funkcji, które automatycznie opakowują funkcje w spany śladów. Dekorator @observe() rejestruje dane wejściowe i wyjściowe, czas wykonania oraz wszelkie wyjątki. To najprostszy sposób na oprzyrządowanie istniejącego kodu bez zmiany jego struktury.

from langfuse.decorators import observe, langfuse_context

# @observe wraps the function as a span automatically
@observe()
def retrieve_chunks(query: str) -> list[dict]:
    return vector_db.search(query, top_k=5)

@observe()
def generate_answer(query: str, context: str) -> str:
    response = openai_client.chat.completions.create(
        model='gpt-4o',
        messages=[
            {'role': 'system', 'content': 'Answer using the context.'},
            {'role': 'user', 'content': f'Context: {context}\nQuestion: {query}'}
        ]
    )
    # Attach LLM usage data to the current span
    langfuse_context.update_current_observation(
        usage={'input': response.usage.prompt_tokens, 'output': response.usage.completion_tokens},
        model='gpt-4o'
    )
    return response.choices[0].message.content

@observe(name='rag-pipeline')  # top-level trace
def rag_pipeline(query: str) -> str:
    chunks = retrieve_chunks(query)  # becomes a nested span
    context = '\n'.join([c['text'] for c in chunks])
    return generate_answer(query, context)  # becomes another nested span

Integracja z dowolnym dostawcą LLM

W przeciwieństwie do głębokiej integracji LangSmith z LangChain, Langfuse działa z dowolnym dostawcą LLM dzięki temu samemu podejściu opartemu na dekoratorach. Niezależnie od tego, czy wywołują Państwo API Anthropic, lokalny model Ollama, punkt końcowy wnioskowania Hugging Face czy niestandardowy model dostrojony przez Państwa, Langfuse śledzi wywołanie w ten sam sposób. Ta neutralność względem dostawcy jest kluczowa, gdy w jednej aplikacji uruchamiają Państwo wiele modeli.

from langfuse.decorators import observe, langfuse_context
import anthropic
from openai import OpenAI

anthropic_client = anthropic.Anthropic()
openai_client = OpenAI()

@observe()
def call_claude(prompt: str) -> str:
    response = anthropic_client.messages.create(
        model='claude-3-5-sonnet-20241022',
        max_tokens=1024,
        messages=[{'role': 'user', 'content': prompt}]
    )
    langfuse_context.update_current_observation(
        model='claude-3-5-sonnet-20241022',
        usage={'input': response.usage.input_tokens, 'output': response.usage.output_tokens}
    )
    return response.content[0].text

@observe()
def call_gpt4(prompt: str) -> str:
    response = openai_client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}]
    )
    langfuse_context.update_current_observation(model='gpt-4o',
        usage={'input': response.usage.prompt_tokens, 'output': response.usage.completion_tokens})
    return response.choices[0].message.content

Pulpity śledzenia kosztów

Langfuse automatycznie oblicza koszt na podstawie nazwy modelu i liczby tokenów, korzystając z wbudowanej tabeli cen obejmującej OpenAI, Anthropic, Mistral i dziesiątki innych dostawców. Pulpit kosztów pokazuje: łączne wydatki w danym okresie, koszty według modelu, koszty według funkcji lub użytkownika (z użyciem tagów i metadanych) oraz dzienne i tygodniowe trendy wydatków. Taka widoczność zapobiega nieoczekiwanie wysokim rachunkom i pomaga identyfikować kosztowne żądania odstające.

# Cost data is automatically computed - no manual config
# Langfuse knows: gpt-4o input = $0.005/1K tokens, output = $0.015/1K tokens

# Add metadata to enable cost breakdown by feature
@observe(name='rag-query')
def handle_rag_query(query: str, feature: str, user_id: str) -> str:
    langfuse_context.update_current_trace(
        user_id=user_id,
        tags=[feature, 'rag'],
        metadata={'feature': feature, 'query_length': len(query)}
    )
    return rag_pipeline(query)

# In Langfuse dashboard you can now filter costs by:
# - feature: 'document_qa', 'chat', 'summarization'
# - user_id: to see which users are your most expensive
# - model: to compare gpt-4o vs gpt-4o-mini costs
# - date range: to see daily/weekly/monthly trends

Dodawanie ocen opinii użytkowników

Langfuse pozwala dołączać opinie użytkowników do śladów po fakcie. Gdy użytkownik kliknie kciuk w górę lub w dół przy odpowiedzi, mogą Państwo zapisać to jako ocenę odpowiedniego śladu. Łączy to rzeczywiste sygnały zadowolenia użytkowników z pełnym kontekstem śladu, umożliwiając analizę różnic między wysoko ocenianymi a słabo ocenianymi odpowiedziami.

from langfuse.decorators import observe, langfuse_context

@observe()
def generate_response(query: str) -> dict:
    answer = rag_pipeline(query)
    # Get the current trace ID to link feedback later
    trace_id = langfuse_context.get_current_trace_id()
    return {'answer': answer, 'trace_id': trace_id}

# Later, when user submits feedback:
def record_user_feedback(trace_id: str, score: int, comment: str):
    langfuse.score(
        trace_id=trace_id,
        name='user_satisfaction',  # score name
        value=score,               # 1 (thumbs up) or 0 (thumbs down)
        comment=comment,
        data_type='BOOLEAN'
    )

# Now in Langfuse: filter traces where user_satisfaction = 0
# to find the exact prompts and contexts that users rated negatively

Automatyczne oceny z użyciem LLM-as-Judge

Oprócz opinii użytkowników Langfuse obsługuje automatyczne ocenianie za pomocą ewaluatorów LLM-as-judge. Mogą Państwo definiować ewaluatory uruchamiane asynchronicznie dla próbkowanych śladów i oceniać je według takich kryteriów jak trafność, wierność, toksyczność czy poprawność formatu. Te automatyczne oceny są wyświetlane na tym samym pulpicie ocen co opinie użytkowników, zapewniając ciągłe monitorowanie jakości bez konieczności ręcznego oznaczania danych na dużą skalę.

from langfuse import Langfuse

langfuse = Langfuse()

def auto_score_traces():
    # Get recent unscored traces
    traces = langfuse.fetch_traces(tags=['production'], limit=50)
    
    for trace in traces.data:
        question = trace.input.get('query', '')
        answer = trace.output.get('answer', '') if trace.output else ''
        
        if not question or not answer:
            continue
        
        # LLM-as-judge scoring
        score = evaluate_relevance(question, answer)  # returns 0.0-1.0
        
        langfuse.score(
            trace_id=trace.id,
            name='auto_relevance',
            value=score,
            data_type='NUMERIC',
            comment='Automated relevance score from LLM judge'
        )

# Run this as a scheduled job every hour

Zarządzanie promptami w Langfuse

Langfuse zawiera funkcję zarządzania promptami, która przechowuje prompty w chmurze Langfuse i umożliwia pobieranie ich w czasie działania. Oddziela to wersje promptów od wdrożeń kodu — mogą Państwo zaktualizować prompt w interfejsie Langfuse, a zmiana zacznie obowiązywać natychmiast, bez wdrażania kodu. Langfuse śledzi również, której wersji promptu użyto w każdym śladzie, dzięki czemu można porównywać wydajność poszczególnych wersji promptów.

from langfuse import Langfuse

langfuse = Langfuse()

# Fetch the current production prompt by name
# The prompt lives in Langfuse UI, not in your code
prompt = langfuse.get_prompt('rag-system-prompt', version='production')

# Use it in your pipeline
messages = [
    {'role': 'system', 'content': prompt.compile(context_limit=4000)},
    {'role': 'user', 'content': query}
]

response = openai_client.chat.completions.create(model='gpt-4o', messages=messages)

# The trace is automatically linked to the prompt version
# In Langfuse you can filter: show me traces using prompt v3 vs v4
# and compare their quality scores

Samodzielne hostowanie Langfuse

Langfuse można hostować samodzielnie za pomocą pojedynczego polecenia Docker Compose, korzystając z PostgreSQL do przechowywania danych. Samodzielne hostowanie oznacza, że dane śladów nigdy nie opuszczają Państwa infrastruktury — ma to kluczowe znaczenie w przypadku aplikacji przetwarzających dane osobowe, dane medyczne lub treści zastrzeżone. Wersja hostowana samodzielnie ma te same funkcje co zarządzana chmura, ale wymaga samodzielnego zarządzania infrastrukturą (kopiami zapasowymi, skalowaniem i aktualizacjami).

# Self-host Langfuse with Docker Compose
# docker-compose.yml (simplified)
# version: '3'
# services:
#   langfuse:
#     image: langfuse/langfuse:2
#     ports:
#       - '3000:3000'
#     environment:
#       - DATABASE_URL=postgresql://langfuse:password@postgres/langfuse
#       - NEXTAUTH_SECRET=your-random-secret
#       - SALT=your-random-salt
#   postgres:
#     image: postgres:15
#     environment:
#       - POSTGRES_DB=langfuse
#       - POSTGRES_PASSWORD=password

# After docker-compose up, point your SDK to:
langfuse = Langfuse(
    public_key='pk-lf-your-key',
    secret_key='sk-lf-your-key',
    host='http://localhost:3000'  # your self-hosted instance
)

Langfuse a LangSmith: kiedy wybrać które rozwiązanie

Proszę wybrać LangSmith, jeśli intensywnie korzystają Państwo z LangChain i zależy Państwu na automatycznym śledzeniu bez konfiguracji, głębokiej integracji z ewaluacjami LangChain oraz akceptują Państwo zależność od dostawcy. Proszę wybrać Langfuse, jeśli korzystają Państwo z wielu dostawców LLM, muszą hostować rozwiązanie samodzielnie ze względu na zgodność z wymogami ochrony danych, chcą przejrzystości zapewnianej przez otwarty kod źródłowy lub tworzą rozwiązania z użyciem frameworków innych niż LangChain. Oba rozwiązania są gotowe do użycia produkcyjnego i oba oferują hojne bezpłatne pakiety.

Integracja OpenTelemetry dla LLM

Zespoły, które już korzystają z OpenTelemetry do rozproszonego śledzenia, mogą używać obsługi OTLP (OpenTelemetry Protocol) w Langfuse. Mogą Państwo wysyłać dane śladów LLM z istniejących eksporterów OTel bezpośrednio do Langfuse, bez zmiany oprzyrządowania. Umożliwia to utworzenie ujednoliconego stosu obserwowalności, w którym ślady LLM, spany zapytań do baz danych i ślady żądań HTTP znajdują się w tym samym systemie oraz korzystają ze spójnych identyfikatorów korelacji.

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor

# Configure OTel to send to Langfuse OTLP endpoint
exporter = OTLPSpanExporter(
    endpoint='https://cloud.langfuse.com/api/public/otel/v1/traces',
    headers={
        'Authorization': 'Basic ' + base64.b64encode(b'pk-lf-xxx:sk-lf-xxx').decode()
    }
)

provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(exporter))
trace.set_tracer_provider(provider)

# Now create spans as usual - they appear in Langfuse automatically
tracer = trace.get_tracer('my-llm-app')
with tracer.start_as_current_span('rag-query') as span:
    span.set_attribute('llm.model', 'gpt-4o')
    span.set_attribute('llm.prompt_tokens', 500)
    result = rag_pipeline(query)

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat niezależnej od modelu obserwowalności z użyciem Langfuse z tego modułu.

Podsumowanie modułu

W tym module dowiedzieli się Państwo, że: Langfuse zapewnia obserwowalność LLM o otwartym kodzie źródłowym, niezależną od modelu, korzystając z hierarchicznego modelu danych: ślady–spany–generacje; dekorator @observe() pozwala oprzyrządować istniejący kod przy minimalnych zmianach; a śledzenie kosztów, oceny opinii użytkowników i automatyczne ocenianie LLM-as-judge czynią z Langfuse kompletną platformę monitorowania jakości. Następnie skonfigurujemy alerty dotyczące opóźnień, kosztów i pogorszenia jakości.

Często zadawane pytania

Czy lekcja „Langfuse do obserwowalności niezależnej od modelu” jest bezpłatna?

Tak — pełny tekst „Langfuse do obserwowalności niezależnej od modelu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Engineering Academy, przejdź na CoddyKit PRO. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Langfuse do obserwowalności niezależnej od modelu”?

Zintegruj Langfuse jako otwartoźródłową alternatywę działającą z dowolnym dostawcą LLM, rejestruj niestandardowe odcinki dla wyszukiwania i wywołań narzędzi oraz skonfiguruj pulpity śledzenia kosztów. Ćwiczysz AI Engineering Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Engineering Academy?

Nie wymagamy żadnego doświadczenia. AI Engineering Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Langfuse do obserwowalności niezależnej od modelu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Engineering Academy?

Tak. Każda lekcja AI Engineering Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Dlaczego aplikacje LLM trudno debugować
  2. Śledzenie za pomocą LangSmith
  3. Langfuse do obserwowalności niezależnej od modelu
  4. Alerty dotyczące opóźnień, kosztów i spadku jakości
← Powrót do AI Engineering Academy