AI-agenter – Sådan bruger du AI-agenter i praksis

17. Den Ultimative Guide til Avancerede RAG-teknikker: Query Rewriting & Reranking

Standard RAG (Retrieval-Augmented Generation) er fantastisk til simple opslag, men i virkelighedens verden formulerer brugere sjældent deres spørgsmål perfekt. De bruger uklart sprog, stiller unøjagtige spørgsmål eller pakker flere spørgsmål ind i én sætning.

For at løse dette bruger professionelle AI-agenter avancerede RAG-teknikker. I denne guide dykker vi dybt ned i to af de vigtigste arkitekturer: Query Rewriting (Query Transformation) og Reranking.

1. Hvad er Query Rewriting? (Optimering af Input)

Query Rewriting handler om at bruge en LLM til at omformulere, udvide eller optimere brugerens oprindelige spørgsmål, før der søges i vektordatabasen.

De tre mest populære Query Transformation-mønstre:

2. Hvad er Reranking? (Optimering af Output)

Hvor Query Rewriting sker før søgningen, sker Reranking efter søgningen, men før dokumenterne sendes til den endelige LLM. Vektordatabaser bruger bi-encodere til at måle grov semantisk lighed. En Reranker er en specialiseret og meget præcis AI-model (en Cross-Encoder, f.eks. fra Cohere eller BGE), der analyserer brugerens spørgsmål og hvert enkelt dokument samtidigt, giver dem en præcis score (0-1), og sorterer dem, så kun de bedste sendes til LLM'en.

3. Arkitekturen: Det Avancerede RAG-Flow

  [Bruger Input: "Hvordan fikser jeg fejlen?"]
                       │
                       ▼
         1. Query Rewriter (LLM)
                       │
                       ▼
  [Optimeret Query: "Fejlfinding af fejlmeddelelse X i Python"]
                       │
                       ▼
       2. Vektordatabase (Henter Top-25 chunks)
                       │
                       ▼
   [25 ustrukturerede og groft sorterede chunks]
                       │
                       ▼
            3. Reranker Model (Cross-Encoder)
                       │
                       ▼
     [Top-3 absolut mest relevante dokumenter]
                       │
                       ▼
         4. Endelig LLM ➔ [Præcist svar]

4. Praktisk eksempel: Implementering i Python

import openai
from sentence_transformers import CrossEncoder

reranker_model = CrossEncoder("BAAI/bge-rerank-large")

def query_rewriter(user_question, chat_history=""):
    system_prompt = "Du er en AI-agent, der optimerer søgespørgsmål til en vektordatabase. Returner KUN det optimerede søgespørgsmål."
    context = f"Chathistorik: {chat_history}\nBrugerinput: {user_question}"
    
    response = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": context}
        ]
    )
    return response.choices[0].message.content.strip()

def mock_vector_search(query):
    return [
        "Dokument 1: Python er et programmeringssprog...",
        "Dokument 4: Hvis du får fejlen 'IndexError: list index out of range', betyder det...",
    ]

def advanced_rag_pipeline(user_input, chat_history=""):
    optimized_query = query_rewriter(user_input, chat_history)
    retrieved_chunks = mock_vector_search(optimized_query)
    
    pairs = [[optimized_query, chunk] for chunk in retrieved_chunks]
    scores = reranker_model.predict(pairs)
    
    reranked_results = sorted(zip(retrieved_chunks, scores), key=lambda x: x[1], reverse=True)
    best_context = reranked_results[0][0]
    
    final_response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "Besvar spørgsmålet sandfærdigt udelukkende baseret på konteksten."},
            {"role": "user", "content": f"Kontekst: {best_context}\nSpørgsmål: {user_input}"}
        ]
    )
    return final_response.choices[0].message.content

5. Fordele ved at bruge avancerede teknikker

• Drastisk reduktion af tokens (Billigere i drift).
• Farvel til hallucinationer.
• Bedre brugeroplevelse (UX).

18. Vektordatabaser i praksis: Fra Embeddings til Semantisk Søgning i Stor Skala

Når man bygger AI-agenter og RAG-systemer, støder man hurtigt på begrebet vektordatabaser (f.eks. ChromaDB, Pinecone, Qdrant eller Milvus). I denne guide går vi ned i materien og ser på den konkrete matematik bag embeddings, hvordan vektordatabaser fungerer i praksis, og hvorfor traditionelle JSON-databaser fejler ved semantisk søgning i stor skala.

1. Hvad er en Embedding? (AI’ens koordinatsystem)

En embedding er intet andet end en lang række af kommatal (en matematiske vektor), som repræsenterer den betydning og kontekst, et stykke tekst har. Når din AI-agent skal lave semantisk søgning, leder den efter de vektorer i databasen, der har den korteste geometriske afstand (Cosinus-lighed) til brugerens spørgsmål.

2. Hvorfor traditionelle JSON-databaser fejler i stor skala

1. Brute-Force Søgning (O(N) kompleksitet): Din server skal køre en for-løkke igennem samtlige dokumenter og udregne cosinus-lighed.
2. Traditionelle indeks virker ikke: Vektorer kan ikke sorteres alfabetisk. En vektorsøgning leder efter de nærmeste naboer, ikke præcise match.
3. RAM- og hukommelsesproblemer: Data bliver for tunge at have indlæst.

3. Sådan løser Vektordatabaser problemet (ANN-indeksering)

Vektordatabaser udskifter brute-force søgning med Approximate Nearest Neighbor (ANN)-algoritmer som IVF (Inverted File Index) og HNSW (Hierarchical Navigable Small World), der reducerer søgetiden fra sekunder til millisekunder (O(log N) kompleksitet).

4. Praktisk eksempel: Vektorsøgning i Python (ChromaDB)

import chromadb
from chromadb.utils import embedding_functions

chroma_client = chromadb.PersistentClient(path="./min_ai_database")
default_ef = embedding_functions.DefaultEmbeddingFunction()

collection = chroma_client.get_or_create_collection(
    name="virksomheds_faq", 
    embedding_function=default_ef
)

collection.add(
    documents=[
        "Vores support har åbent mandag til fredag fra kl. 08:00 til 16:00.",
        "Du kan opsige dit abonnement under profilindstillingerne på vores hjemmeside.",
        "Vi tilbyder 14 dages fuld returret på alle fysiske produkter."
    ],
    metadatas=[{"kategori": "support"}, {"kategori": "konto"}, {"kategori": "regler"}],
    ids=["id1", "id2", "id3"]
)

bruger_sporgsmal = "Hvornår kan jeg ringe til jer?"

results = collection.query(
    query_texts=[bruger_sporgsmal],
    n_results=1
)

print(f"🤖 Bedste match fra vektordatabasen: {results['documents'][0][0]}")

19. Evaluering af AI-agenter (Agent Benchmarking): Hvordan du måler succesen af dine agenter i produktion

I denne guide gennemgår vi, hvordan du systematisk tester dine agenter over tid ved hjælp af moderne framework-værktøjer som Ragas og TruLens, samt de specifikke målinger (metrics), du skal holde øje med.

1. LLM-as-a-Judge: Den nye test-standard

Da en AI-agents svar er flydende tekst, kan vi ikke sammenligne outputtet tegn for tegn med et facit. I stedet bruger man metoden LLM-as-a-Judge, hvor en uafhængig, avanceret "dommer-model" analyserer agentens svar ud fra stringente kriterier.

2. De 3 vigtigste evalueringsparametre (The RAG Triad)

1. Groundedness / Faithfulness (Sandfærdighed): Hallucinerer agenten, eller baserer den sig kun på konteksten?
2. Answer Relevance (Svars-relevans): Svarer agenten rent faktisk på det, brugeren spurgte om?
3. Context Relevance (Kontekst-relevans): Henter søgemekanismen præcise, relevante dokumenter, eller trækker den "støj" med?

3. Introduktion til Ragas & TruLens

• Ragas (Retrieval Augmented Generation Assessment): Fremragende til offline-evaluering og at køre store benchmark-tests.
• TruLens (TruEra): Fremragende til både offline test-pipelines og live monitorering i produktion (via "TruFeedbacks").

4. Praktisk eksempel: Evaluering af en agent med Ragas i Python

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevance
from datasets import Dataset
import os

os.environ["OPENAI_API_KEY"] = "din-openai-api-nøgle"

test_data = {
    "question": [
        "Hvad er virksomhedens regler for hjemmearbejde?"
    ],
    "contexts": [[
        "Retningslinjer for medarbejdere: Alle ansatte har ret til op mod 2 ugentlige hjemmearbejdsdage efter aftale med deres nærmeste leder."
    ]],
    "answer": [
        "Du må arbejde hjemme 2 dage om ugen, hvis din leder godkender det. Derudover kan du arbejde hjemme lige så tosset du vil i weekenden, og virksomheden betaler for en helt ny MacBook til dit hjemmekontor."
    ]
}

dataset = Dataset.from_dict(test_data)

result = evaluate(
    dataset=dataset,
    metrics=[faithfulness, answer_relevance]
)

print(f"Faithfulness (Sandfærdighed):  {result['faithfulness']:.4f}")
print(f"Answer Relevance (Relevans):    {result['answer_relevance']:.4f}")

20. Overvågning og Sporbarhed (LLM Observability): Sådan tracer du fejl i komplekse agent-kæder

Hvis det endelige svar er forkert, er det umuligt at gennemskue problemet uden de rette værktøjer. Det er her, LLM Observability kommer ind i billedet. Vi gennemgår implementering af Tracing med specialiserede værktøjer som Langfuse, LangSmith og Phoenix.

1. Hvad er Tracing? (Agentens sorte boks)

En "Trace" er en komplet visualisering af hele det kognitive forløb, din agent har gennemgået for at løse en opgave, opbygget af Spans (under-elementer).

2. De 3 vigtigste Observability-værktøjer

• Langfuse: Open-source / Cloud. Meget populær, let at integrere, tracker traces, tokens og latency.
• LangSmith: Kommerciel. Perfekt, hvis agenten er bygget i LangChain-økosystemet.
• Phoenix (Arize): Open-source. Særligt stærk til data science og evaluering.

3. Hvad overvåger vi i praksis?

Den rå Prompt-Historik, Token- og Pris-tracking, Latency (Flaskehalse), og Brugerfeedback (Scores).

4. Praktisk eksempel: Integrering af Tracing med Langfuse i Python

from langfuse.openai import openai
import os

os.environ["LANGFUSE_PUBLIC_KEY"] = "din_public_key"
os.environ["LANGFUSE_SECRET_KEY"] = "din_secret_key"
os.environ["LANGFUSE_HOST"] = "https://langfuse.com"
os.environ["OPENAI_API_KEY"] = "din_openai_api_nøgle"

def stock_checker_tool(product_name):
    if product_name.lower() == "iphone":
        return "Lagerstatus: 0 styk på lager."
    return "Lagerstatus: 50+ styk på lager."

def run_agent_workflow(user_query):
    response = openai.chat.completions.create(
        model="gpt-4o-mini",
        name="Agent_Decision_Trimming",
        messages=[
            {"role": "system", "content": "Du er en lager-agent. Svar med 'CALL_TOOL: [produktnavn]'"},
            {"role": "user", "content": user_query}
        ]
    )
    
    llm_decision = response.choices[0].message.content
    
    if "CALL_TOOL" in llm_decision:
        product = llm_decision.replace("CALL_TOOL:", "").strip()
        tool_result = stock_checker_tool(product)
        
        final_response = openai.chat.completions.create(
            model="gpt-4o",
            name="Final_Agent_Response",
            messages=[
                {"role": "system", "content": "Giv kunden besked om lagerstatus."},
                {"role": "user", "content": f"Værktøjsdata: {tool_result}\nKunde-spørgsmål: {user_query}"}
            ]
        )
        return final_response.choices[0].message.content
    
    return llm_decision

21. Pris- og Token-styring (Rate Limiting): Sådan tæmmer du løbende agenter og undgår gigantiske AI-regninger

Autonomi har en ekstremt mørk bagside kaldet en "indespærret agent" (Infinite Agent Loop). For hvert fejlrettelsesforsøg sendes historikken med tilbage. I denne guide gennemgår vi konkrete forsvarsmekanismer.

Strategier for Token- og Prisstyring

1. Max Iterations (Løkke-loft): En hård grænse for loop iterationer (f.eks. 5-10).
2. Token Budget (Pris-loft): Et maksimalt antal tilladte tokens per session.
3. Sliding Window Memory: Gamle fejllogs slettes fra agentens kontekst-vindue.

Praktisk eksempel: Sikring af en Agent-løkke i Python

import openai
import os

os.environ["OPENAI_API_KEY"] = "din_openai_api_nøgle"

class SecureAIAgent:
    def __init__(self, max_iterations=5, token_budget=20000):
        self.max_iterations = max_iterations
        self.token_budget = token_budget
        self.total_tokens_used = 0
        self.chat_history = [{"role": "system", "content": "Løs opgaven via loops."}]

    def mock_broken_tool(self):
        return "FEJL: Databaseforbindelse nægtet (Timeout 500)"

    def execute_task(self, user_task):
        self.chat_history.append({"role": "user", "content": user_task})
        
        for iteration in range(1, self.max_iterations + 1):
            if self.total_tokens_used > self.token_budget:
                return "Fejl: Token-budget overskredet!"

            response = openai.chat.completions.create(
                model="gpt-4o-mini",
                messages=self.chat_history
            )
            self.total_tokens_used += response.usage.total_tokens
            
            llm_output = response.choices[0].message.content
            self.chat_history.append({"role": "assistant", "content": llm_output})
            
            error_message = self.mock_broken_tool()
            self.chat_history.append({"role": "user", "content": f"Fejl: {error_message}"})
            
        return "Fejl: Agenten blev stoppet, da den sad fast i et uendeligt loop."

22. Den Ultimative Guide til ReAct-mønstret: Hvordan AI-agenter tænker og handler i praksis

Mønstret ReAct (Reasoning and Acting) er det absolut mest udbredte og fundamentale mønster for, hvordan moderne AI-agenter interagerer med verden. Den tvinger sprogmodellen ind i et asynkront loop, hvor den skiftevis tænker (Thought), handler (Action), observerer (Observation) og afslutter (Final Answer).

Praktisk eksempel: ReAct-agent kodet fra bunden i Python

import openai
import re

SYSTEM_PROMPT = """
Du er en agent. Brug disse format-trin:
Thought: [Tanke]
Action: [Værktøjsnavn]: [Parameter]
Final Answer: [Svar]
"""

def math_calculator(expression):
    try: return str(eval(expression, {"__builtins__": None}, {}))
    except: return "Fejl"

AVAILABLE_TOOLS = {"math_calculator": math_calculator}

def react_agent_loop(user_task):
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": user_task}
    ]
    
    for step in range(5):
        response = openai.chat.completions.create(model="gpt-4o-mini", messages=messages, temperature=0.0)
        llm_output = response.choices[0].message.content
        messages.append({"role": "assistant", "content": llm_output})
        
        if "Final Answer:" in llm_output:
            return llm_output.split("Final Answer:")[-1].strip()
            
        action_match = re.search(r"Action:\s*(\w+):\s*(.*)", llm_output)
        if action_match:
            tool_name = action_match.group(1).strip()
            tool_param = action_match.group(2).strip()
            if tool_name in AVAILABLE_TOOLS:
                obs = AVAILABLE_TOOLS[tool_name](tool_param)
                messages.append({"role": "user", "content": f"Observation: {obs}"})
    return "Fejl: Max trin nået."

23. Avancerede Agent-Mønstre: Plan-and-Solve & Reflection (Kvalitetssikring i Agent-Kæder)

For at løse problemet med agents nærsynethed bruges to kognitive mønstre: Plan-and-Solve (planlæg makroen og udsend til under-agenter) og Reflection (kvalitetssikrings-loop mellem en forfatter-agent og en kritiker-agent).

Praktisk eksempel: Reflection-loop kodet i Python

import openai

def generator_agent(prompt, previous_feedback=""):
    sys = "Generer data." + (f" Ret fejl:\n{previous_feedback}" if previous_feedback else "")
    res = openai.chat.completions.create(model="gpt-4o-mini", messages=[{"role": "system", "content": sys}, {"role": "user", "content": prompt}], temperature=0.7)
    return res.choices[0].message.content

def critic_agent(original_prompt, generated_output):
    sys = "Er outputtet perfekt? Svar med [GODKENDT] eller [AFVIST] med fejl."
    res = openai.chat.completions.create(model="gpt-4o", messages=[{"role": "system", "content": sys}, {"role": "user", "content": f"Krav: {original_prompt}\nData:\n{generated_output}"}], temperature=0.0)
    return res.choices[0].message.content

aktuelt_udkast = generator_agent("Krav: JSON-profil, 42 år")
for i in range(3):
    kritik = critic_agent("Krav: JSON-profil, 42 år", aktuelt_udkast)
    if "[GODKENDT]" in kritik:
        print("✅ SUCCESS")
        break
    else:
        aktuelt_udkast = generator_agent("Krav: JSON-profil, 42 år", previous_feedback=kritik)

24. State Machines i AI-agenter: Styr komplekse agent-flows med 100% determinisme

I en virksomhed har vi brug for, at AI-intelligens følger faste forretningsregler. En State Machine består af State (Tilstand), Nodes (Knuder) og Edges (Betingede overgange) og implementerer 100% determinisme gennem rammeværker som LangGraph.

class AgentState:
    def __init__(self):
        self.credit_score = 0
        self.current_step = "FETCH_SCORE"
        self.final_decision = ""

def run_state_machine_agent():
    state = AgentState()
    
    while state.current_step != "END":
        if state.current_step == "FETCH_SCORE":
            state.credit_score = 450
            state.current_step = "DECISION_ROUTING"
            
        elif state.current_step == "DECISION_ROUTING":
            if state.credit_score < 500: state.current_step = "REJECT_NODE"
            else: state.current_step = "APPROVE_NODE"
                
        elif state.current_step == "APPROVE_NODE":
            state.final_decision = "GODKENDT"
            state.current_step = "END"
            
        elif state.current_step == "REJECT_NODE":
            state.final_decision = "AFVIST"
            state.current_step = "END"
            
    return state.final_decision

25. Langtids-hukommelse og Sessionsstyring: Sådan husker AI-agenter brugere på tværs af uger og måneder

En produktionsmoden AI-agent har brug for tre lag: Korttidshukommelse, Episodisk hukommelse (ofte i Redis), og Semantisk langtidshukommelse (Vektordatabase). Redis sikrer læse- og skrivehastighed på under 1 millisekund.

MOCK_REDIS_DATABASE = {}

def save_session_to_redis(session_id, chat_history):
    MOCK_REDIS_DATABASE[f"session:{session_id}"] = chat_history

def get_session_from_redis(session_id):
    key = f"session:{session_id}"
    if key in MOCK_REDIS_DATABASE: return MOCK_REDIS_DATABASE[key]
    return [{"role": "system", "content": "Du er en assistent."}]

def chat_with_agent(session_id, user_message):
    chat_history = get_session_from_redis(session_id)
    chat_history.append({"role": "user", "content": user_message})
    # Sprogmodel kald og svar indsættes her
    save_session_to_redis(session_id, chat_history)
    return "Svar genereret"

26. Menneske-i-loopet (Human-in-the-loop) arkitektur: Sådan koder du sikre AI-afbrydelser

For at bygge professionelle og sikre agentsystemer implementerer man et HIL-system. Agenten sættes automatisk på pause, fryser sin tilstand (AWAITING_APPROVAL) og afventer menneskelig godkendelse asynkront via f.eks. webhooks, før den eksekverer kritiske værktøjer.

AGENT_DATABASE = {}

class AgentState:
    def __init__(self, task_id):
        self.task_id = task_id
        self.status = "RUNNING"

def run_agent_engine(task_id):
    state = AGENT_DATABASE.get(task_id, AgentState(task_id))
    
    if state.status == "AWAITING_APPROVAL":
        print("🛑 Agenten afventer menneskelig godkendelse.")
        return state.task_id

    amount_target = 7500
    if amount_target > 5000 and state.status != "APPROVED_BY_HUMAN":
        print("🔒 SIKKERHEDS-BREAKPOINT UDLØST!")
        state.status = "AWAITING_APPROVAL"
        AGENT_DATABASE[task_id] = state
        return task_id

    print("⚡ Udfører handling...")
    state.status = "COMPLETED"
    AGENT_DATABASE[task_id] = state
    return "Opgave fuldført!"

def api_endpoint_approve(task_id):
    state = AGENT_DATABASE[task_id]
    state.status = "APPROVED_BY_HUMAN"
    run_agent_engine(task_id)