LangChain / RAG / vektordatabaser · Lektion

Overvågning og logning af RAG-applikationer

Implementer robuste løsninger til overvågning og logning for at følge ydeevnen, identificere problemer og få indsigt i brugerinteraktioner.

Lektion 1 af 411 trin

Overvågning og logning af RAG-applikationer er en gratis LangChain / RAG / vektordatabaser-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i LangChain / RAG / vektordatabaser, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. LangChain / RAG / vektordatabaser-kurset indeholder 4 lektioner i alt.

Hvorfor overvåge RAG-applikationer?

Når du bygger et RAG-system (Retrieval Augmented Generation), er det som at bygge en kompleks maskine. For at sikre, at den kører problemfrit og pålideligt, skal du vide, hvad der foregår indeni!

Overvågning og logning er vigtige værktøjer til at forstå din RAG-applikations ydeevne, identificere problemer og sikre en god brugeroplevelse.

Vigtige RAG-målepunkter at overvåge

Hvad bør du helt præcist holde øje med i et RAG-system? Her er nogle vigtige målepunkter:

Forsinkelse: Hvor lang tid tager det at hente dokumenter? Hvor lang tid tager det for LLM'en at generere et svar?
Hentningssucces: Bliver relevante dokumenter fundet konsekvent?
Kvaliteten af LLM-svar: Genererer LLM'en nøjagtige, sammenhængende og nyttige svar?
Tokenforbrug: Hvor mange tokens bruger LLM'en (til sporing af omkostninger)?
Fejlfrekvenser: Forekommer der hyppige fejl i nogen del af RAG-pipelinen?

Grundlæggende Python-logning

Lad os begynde med enkel logning ved hjælp af Pythons indbyggede logging-modul. Det giver dig mulighed for at registrere meddelelser på forskellige alvorlighedsniveauer (f.eks. INFO, WARNING og ERROR).

Dette kodestykke viser, hvordan du konfigurerer grundlæggende logning og registrerer en meddelelse under en simuleret RAG-proces.

import logging

# Configure basic logging
logging.basicConfig(level=logging.INFO,
                    format='%(asctime)s - %(levelname)s - %(message)s')

def process_query(query):
    logging.info(f"Received query: {query}")
    # Simulate RAG processing steps here
    response = f"Processed '{query}' successfully."
    logging.info(f"Generated response: {response}")
    return response

if __name__ == "__main__":
    print("--- Starting RAG simulation ---")
    result = process_query("What is a vector database?")
    print(f"Final result: {result}")
    print("--- Simulation finished ---")

Styrken ved struktureret logning

Selvom grundlæggende logge er nyttige, går struktureret logning et skridt videre. I stedet for almindelig tekst genereres logge i et struktureret format, ofte JSON.

Hvorfor er det bedre til RAG?

Lettere fortolkning: Maskiner kan nemt læse og udtrække bestemte datapunkter.
Bedre søgning og analyse: Du kan forespørge i logge efter bestemte felter (f.eks. alle logge for et bestemt request_id eller query_type).
Integration: Fungerer problemfrit sammen med systemer til loghåndtering som Elasticsearch.

Logning af brugerforespørgsler i RAG

En af de første ting, du bør logge i din RAG-applikation, er brugerens inputforespørgsel. Det hjælper dig med at forstå, hvad brugerne spørger om, og hvordan dit system fortolker deres anmodninger.

Det er god praksis at knytte et entydigt id til hver brugeranmodning, så den bliver lettere at spore.

import logging
import uuid
import json

logging.basicConfig(level=logging.INFO,
                    format='%(message)s') # We'll format the output ourselves

def log_user_query(query):
    request_id = str(uuid.uuid4())[:8] # Short unique ID
    log_entry = {
        "timestamp": logging.Formatter().formatTime(logging.LogRecord('', 0, '', 0, '', '', '', '')),
        "level": "INFO",
        "event": "user_query",
        "request_id": request_id,
        "query": query
    }
    logging.info(json.dumps(log_entry))
    return request_id

if __name__ == "__main__":
    print("--- Logging user query ---")
    req_id = log_user_query("Tell me about the history of AI.")
    print(f"Query logged with ID: {req_id}")

Logning af hentede dokumenter

Efter en brugerforespørgsel henter dit RAG-system relevante dokumenter. Det er afgørende for fejlfinding at logge, hvilke dokumenter der blev valgt. Hvis LLM'en giver et dårligt svar, kan du kontrollere, om den modtog en dårlig kontekst.

Logning af dokument-id'er eller titler hjælper dig med at finde problemer i din hentningskomponent.

import logging
import json

logging.basicConfig(level=logging.INFO,
                    format='%(message)s')

def retrieve_docs(query, request_id):
    # Simulate document retrieval
    docs = [
        {"id": "doc_101", "title": "Intro to Embeddings"},
        {"id": "doc_105", "title": "Vector DB Architectures"}
    ]
    log_entry = {
        "timestamp": logging.Formatter().formatTime(logging.LogRecord('', 0, '', 0, '', '', '', '')),
        "level": "INFO",
        "event": "documents_retrieved",
        "request_id": request_id,
        "query": query,
        "retrieved_docs": [d['id'] for d in docs]
    }
    logging.info(json.dumps(log_entry))
    return docs

if __name__ == "__main__":
    print("--- Simulating document retrieval ---")
    req_id = "abc123de"
    retrieved = retrieve_docs("What are embeddings?", req_id)
    print(f"Retrieved document IDs for request {req_id}.")

Logning af LLM-svar

Til sidst vil du gerne logge det svar, der genereres af den store sprogmodel. Det hjælper dig med at vurdere svarenes kvalitet og følge, hvordan LLM'en klarer sig over tid.

Det er også nyttigt at logge den nøjagtige prompt, der blev sendt til LLM'en, da promptdesign har stor indflydelse på outputtet.

import logging
import json

logging.basicConfig(level=logging.INFO,
                    format='%(message)s')

def generate_llm_response(query, retrieved_context, request_id):
    # Simulate LLM generating an answer
    prompt_sent = f"Based on: {retrieved_context}, answer: {query}"
    llm_response = f"The LLM generated an answer about '{query}' based on the provided context."

    log_entry = {
        "timestamp": logging.Formatter().formatTime(logging.LogRecord('', 0, '', 0, '', '', '', '')),
        "level": "INFO",
        "event": "llm_response_generated",
        "request_id": request_id,
        "prompt_sent": prompt_sent,
        "llm_output": llm_response
    }
    logging.info(json.dumps(log_entry))
    return llm_response

if __name__ == "__main__":
    print("--- Simulating LLM response ---")
    req_id = "fgh456ij"
    query = "Explain RAG architecture."
    context = "Documents on RAG components."
    final_answer = generate_llm_response(query, context, req_id)
    print(f"LLM response logged for request {req_id}.")

Almindelige værktøjer til overvågning

Selvom Pythons logging-modul håndterer genereringen af logge, har du brug for eksterne værktøjer til at indsamle, gemme, visualisere og udsende alarmer om dem i et produktionsmiljø:

Prometheus: Et open source-system til indsamling og lagring af tidsseriemålepunkter.
Grafana: Et populært værktøj til dashboards og visualisering, der fungerer godt sammen med Prometheus.
ELK Stack: En samling, der omfatter Elasticsearch (til lagring og søgning i logge), Logstash (til behandling af logge) og Kibana (til visualisering).
Cloud-tjenester: AWS CloudWatch, Google Cloud Logging/Monitoring og Azure Monitor tilbyder integrerede løsninger.

Fejlfinding med logge og målepunkter

Logge og målepunkter er dine bedste hjælpere, når noget går galt. De giver dig et spor, som du kan følge for at diagnosticere problemer:

Langsom ydeevne: Kontrollér målepunkter for forsinkelse ved hentning eller LLM-generering.
Irrelevante svar: Undersøg de hentede dokumenter i loggene for at se, om konteksten var passende.
Hallucinationer: Gennemgå LLM-output og prompts for at forstå, hvorfor der kan være blevet genereret ukorrekte oplysninger.
Fejl: Filtrér logge efter niveauerne ERROR eller WARNING for hurtigt at finde ud af, hvor systemet svigter.

Hurtigt tjek: RAG-logning

Det er afgørende at forstå, hvad der skal logges, for at holde et RAG-system sundt. Hvilke af følgende oplysninger er vigtige at logge i en RAG-applikation for at forstå dens adfærd og finde fejl?

Besvar den i den interaktive lektion

Opsummering og næste trin

Godt klaret! I denne lektion har du lært, hvorfor overvågning og logging er uundværlige i RAG-systemer i produktion. Vi gennemgik:

Vigtigheden af at følge vigtige RAG-metrikker som svartid og tokenforbrug.
Hvordan du implementerer grundlæggende og struktureret logging i Python.
Vigtige datapunkter, der skal logges på hvert trin: brugerforespørgsler, hentede dokumenter og LLM-svar.
En oversigt over almindelige værktøjer til overvågning og logging.

Ved at overvåge og logge effektivt kan du sikre, at din RAG-applikation er robust, yder en god indsats og er pålidelig.

Gratis at komme i gang

Lær LangChain / RAG / vektordatabaser med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Overvågning og logning af RAG-applikationer” gratis?

Ja — hele teksten til “Overvågning og logning af RAG-applikationer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af LangChain / RAG / vektordatabaser-kurset, skal du opgradere til CoddyKit PRO. LangChain / RAG / vektordatabaser-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Overvågning og logning af RAG-applikationer”?

Implementer robuste løsninger til overvågning og logning for at følge ydeevnen, identificere problemer og få indsigt i brugerinteraktioner. Du øver dig i LangChain / RAG / vektordatabaser med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på LangChain / RAG / vektordatabaser?

Der kræves ingen tidligere erfaring. LangChain / RAG / vektordatabaser på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Overvågning og logning af RAG-applikationer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne LangChain / RAG / vektordatabaser-lektion?

Ja. Alle LangChain / RAG / vektordatabaser-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Overvågning og logning af RAG-applikationer
Caching og optimering af ydeevne
Implementeringsstrategier for RAG i skyen
Håndtering af samtidighed og rate limits

← Tilbage til LangChain / RAG / vektordatabaser