For at bygge en AI-agent i Python er det første skridt at forstå, hvordan man taler med en stor sprogmodel (LLM). Det handler grundlæggende om at sende en struktureret anmodning til en fjernserver og modtage et svar, men måden kommunikationen foregår på – og hvilke protokoller der bruges – har stor betydning for, hvor responsiv og anvendelig din agent bliver.

Når du kalder en LLM-API, foregår det i praksis som et HTTP-kald. Du sender en POST-anmodning til udbyderens endpoint (for eksempel OpenAI eller Anthropic) med en JSON-payload, der indeholder dine beskeder, modelnavnet og eventuelle parametre som temperatur eller maksimalt antal tokens. Serveren behandler din anmodning og returnerer et svar, typisk også i JSON-format.

I Python findes der flere måder at håndtere denne kommunikation på. Du kan bruge et lav-niveau bibliotek som httpx til selv at bygge anmodningerne, eller du kan vælge et høj-niveau bibliotek som uss-aigent, der abstraherer det meste. Med sidstnævnte kan et kald se så enkelt ud som:

from aigent import Aigent

agent = Aigent(api_type="openai")
with agent.session() as s:
    print(s.chat("Hej!"))

Biblioteket læser automatisk din API-nøgle fra en miljøvariabel og håndterer opsætningen af forbindelsen. Uanset om du vælger en letvægtsløsning eller et mere fuldt udbygget framework, er det centrale princip det samme: Din Python-kode fungerer som mellemled mellem brugeren og LLM'en, og det er her, du har kontrol over, hvilke data der sendes afsted, og hvordan svaret behandles.

Kommunikationsprotokoller

• Standard HTTP (request/response): Den enkleste og mest udbredte protokol. Din agent sender en anmodning og venter på, at hele svaret er genereret, før det returneres. Velegnet til korte svar eller når du har brug for et struktureret output, men det kan føles langsomt.
• Server-Sent Events (SSE): En streamingprotokol bygget oven på HTTP. Serveren holder forbindelsen åben og sender løbende små bidder af svaret (tokens), efterhånden som de genereres. Giver en markant lavere oplevet ventetid, fordi brugeren ser første token næsten med det samme. Kan implementeres med sse-starlette.
• WebSocket: Fuld duplex-kommunikation, hvor både klient og server kan sende beskeder uafhængigt. Relevant for interaktive agenter eller hvor agenten skal kunne udføre værktøjskald i realtid. For simple chat-agenter er SSE dog ofte tilstrækkeligt.

Fælles for alle protokollerne er, at de understøtter den såkaldte function calling eller tool use. Det betyder, at LLM'en ikke bare genererer tekst, men også returnerer en anmodning om at kalde en bestemt funktion i din kode – fx for at hente vejrdata. Din agent udfører funktionen, sender resultatet tilbage, og LLM'en formulerer det endelige svar.

PHP er stadig en af de mest udbredte sprog til webapplikationer, og med de rette værktøjer kan du sagtens bygge en funktionsdygtig AI-agent. Vi gennemgår de centrale byggeklodser: kommunikation med LLM-API'er, brugerinterface og værktøjskald.

I PHP findes der flere modne pakker til at håndtere kommunikationen med store sprogmodeller. En af de mere fleksible er carmelosantana/php-agents, der understøtter både OpenAI, Anthropic, Gemini og lokale modeller via Ollama. Til mere enkle behov kan du bruge swisnl/agents-sdk eller elliotjreed/ai, hvor sidstnævnte understøtter Claude og ChatGPT med indbygget historik.

Uanset hvilken pakke du vælger, følger kommunikationen et grundlæggende mønster. Her er et minimalt eksempel med elliotjreed/ai:

require_once __DIR__ . '/vendor/autoload.php';

$prompt = new ElliotJReed\AI\Claude\Prompt('DIN_API_NØGLE', 'claude-3-5-haiku-latest');
$request = (new ElliotJReed\AI\Entity\Request())
    ->setSystemPrompt('Du er en hjælpsom assistent.')
    ->setTextPrompt('Hvad er vejret i København i morgen?');

$response = $prompt->send($request);
echo $response->getContent();

Det vigtige her er, at du holder API-nøglen på serveren og aldrig eksponerer den i frontend-koden.

Brugerfladen behøver ikke at være kompliceret. Grundprincippet er et HTML-grænseflade med en beskedboble-container, et inputfelt og en send-knap. JavaScript fanger brugerens input, sender det til din PHP-backend via fetch(), og viser svaret, når det ankommer.

En typisk arkitektur ser således ud: Frontend (HTML/CSS/JS) → PHP-backend (API-endpoint) → LLM-API. PHP-backend'en fungerer som mellemled, hvilket skjuler API-nøglen og giver mulighed for at tilføje agent-logik.

Hvis du ønsker streaming – at teksten vises gradvist – kan du implementere Server-Sent Events (SSE) i PHP. Pakken claude-php/agent understøtter SSE-streaming direkte. Et forenklet eksempel på PHP-siden:

header('Content-Type: text/event-stream');
header('Cache-Control: no-cache');

foreach ($executor->streamSSE($agent, $task) as $sseData) {
    echo $sseData;
    flush();
}

På JavaScript-siden lytter du blot til EventSource og tilføjer de indkommende tokens til chat-boksen. Dette giver en langt mere levende oplevelse end at vente på hele svaret på én gang.

Den centrale forskel på en simpel chatbot og en agent er, at agenten kan bruge værktøjer. I PHP kan dette implementeres ved at definere en "tool"-klasse. Med swisnl/agents-sdk opretter du en klasse, der udvider Tool, definerer parametre, og implementerer __invoke-metoden.

Til vejrdata er Open-Meteo et oplagt valg. Det er gratis, kræver ingen registrering, og returnerer JSON med daglige prognoser for 1, 2 eller 5 dage. Her er et eksempel på en tool-klasse (forenklet):

class WeatherTool extends Tool
{
    #[ToolParameter('Byens navn, fx København'), Required]
    public string $city;

    #[ToolParameter('Antal dage: 1, 2 eller 5')]
    public int $days = 1;

    public string $toolDescription = 'Henter vejrudsigt for en by.';

    public function __invoke(): string
    {
        // Trin 1: Geokodning (by → koordinater)
        $geo = json_decode(file_get_contents(
            "https://geocoding-api.open-meteo.com/v1/search?name=" . urlencode($this->city) . "&count=1"
        ), true);
        $lat = $geo['results'][0]['latitude'];
        $lon = $geo['results'][0]['longitude'];

        // Trin 2: Hent vejrdata
        $url = "https://api.open-meteo.com/v1/forecast?latitude={$lat}&longitude={$lon}"
             . "&daily=temperature_2m_max,temperature_2m_min,precipitation_sum,weather_code"
             . "&forecast_days={$this->days}&timezone=auto";
        $weather = json_decode(file_get_contents($url), true);

        return json_encode($weather['daily']);
    }
}

Når agenten kører, sender den brugerens besked til LLM'en sammen med en beskrivelse af værktøjerne. LLM'en returnerer et "tool call", PHP-koden kalder WeatherTool, og resultatet sendes tilbage til LLM'en, der formulerer en prognose på dansk. LLM'en behøver ikke kende vejr-API'ets struktur – blot at værktøjet findes.

I PHP-økosystemet findes der efterhånden en række modne AI-agent-frameworks. Nedenfor er en gennemgang af de mest repræsentative:

• HelgeSverre/agent: Letvægts CLI-agent baseret på OpenAIs Function Calling med indbyggede værktøjer som websøgning, fillæsning og systemkommandoer.
• carmelosantana/php-agents: Multimodel-agentframework (PHP 8.4+) med en "ikke-opinionsbaseret" agentløkke. Understøtter OpenAI, Anthropic, Gemini, Ollama, streaming, struktureret output og MCP.
• Neuron AI: Et "batterier inkluderet" framework med automatisk håndtering af hukommelse, værktøjskald og RAG. Tilbyder eksekveringsovervågning via Inspector.
• swisnl/agents-sdk: SDK der understøtter "handoff"-mekanisme mellem agenter, MCP-klientunderstøttelse og værktøjsdefinition via attributter.
• Pagent: Framework inspireret af Pest-testframeworket. Lægger vægt på udvikleroplevelse med indbygget mock-provider til deterministisk enhedstest og evaluering.
• atlas-php/atlas: "Alt-i-en" AI-SDK til Laravel-applikationer. Giver førsteklasses agentunderstøttelse med parallel fan-out og revisionssporbar eksekveringstræ.
• sugar-crush: En komplet AI-agent (som Claude Code) der kører i terminalen med filoperationer og shell-eksekvering.
• ElliotJReed/AI: Minimalt bibliotek til at kalde LLM-API'er uden et komplet agentframework.

Store sprogmodeller har en velkendt svaghed: de hallucinerer. De finder på fakta og kilder med stor selvsikkerhed, især inden for specialiserede domæner. Heldigvis kan man minimere problemet med Retrieval-Augmented Generation (RAG) kombineret med avanceret prompt engineering og verifikationsmekanismer.

RAG løser et grundlæggende problem ved at give modellen adgang til ekstern, troværdig viden i form af hentede dokumenter. Men RAG er ikke en garanti; modellen kan stadig ignorere konteksten eller lade distraherende kontekst overskygge den korrekte information. Derfor kræver et robust system mere end blot at smide dokumenter ind i prompten.

En effektiv anti-hallucinationsagent arbejder på tre niveauer:

• Første linje: Streng retrieval og kontekstkontrol. Avancerede RAG-systemer kombinerer tæt vektorsøgning med leksikalsk BM25-søgning. Nogle indfører en verifikationsgate: Hver passage vurderes (semantisk relevans, konsistens), og kun passager der består en tærskel får lov at påvirke genereringen.
• Anden linje: Prompt engineering med tvungne citater. Prompten instruerer præcist. En effektiv teknik er at kræve, at hver faktuel påstand efterfølges af en kildehenvisning i parentes, og at modellen kun må svare ud fra de leverede kilder. Dette forankrer hver sætning i noget konkret.
• Tredje linje: Deterministisk verifikation. En efterbehandlingsmekanisme kontrollerer svaret. Agenten opdeler svaret i sætninger og fjerner påstande uden gyldig citation. Avancerede systemer tjekker om tal/årstal optræder i dokumenterne, og sender ellers en ny prompt for at få modellen til at rette fejlen.

Lad os bygge en agent, der besvarer spørgsmål ud fra officielle rapporter og som under ingen omstændigheder må gætte.

• Trin 1: Vidensbasen. DMI-rapporter opdeles i chunks og gemmes i en vektordatabase (fx pgvector). Søgningen kombinerer vektor- og BM25-søgning og fusionerer resultaterne med Reciprocal Rank Fusion.
• Trin 2: Verifikationsgate. Chunks scores på nøgleentiteter og konsistens. Består ingen chunks tærsklen, returneres et ærligt "ved ikke" (native abstention).
• Trin 3: Prompten. Vi tvinger modellen: "Hver faktuel påstand i dit svar skal efterfølges af en kildehenvisning i kantede parenteser... Medtag ingen påstande uden citation."
• Trin 4: Efterbehandling. Svaret opdeles i sætninger. Mangler en sætning en citation, eller optræder de nævnte tal ikke i kilden, flagges sætningen som en hallucination og rettes i en ny generering.

Forskning bekræfter, at verifikationsdrevet RAG kan løfte mindre modeller til at matche større modeller i faktualitet. RAG leverer evidensen, prompt engineering håndhæver reglerne, og deterministisk verifikation fanger fejlene.

Python har et modent økosystem af AI-agent-frameworks. En af de mest ligetil pakker til kommunikation er exagent, der understøtter både OpenAI og Anthropic. Til mere avancerede behov kan air-agent bruges, som understøtter værktøjskald, MCP-servere og streaming.

Et minimalt eksempel med exagent og en @tool-dekoratør ser således ud:

from exagent import Agent, tool

@tool
def get_weather(city: str, units: str = "celsius") -> str:
    """Return current weather for a city."""
    return f"{city}: 18°C, sunny"

class WeatherAgent(Agent):
    def __init__(self):
        self.system_description = "You are a helpful weather assistant."
        self.set_model("openai", "gpt-4.1-mini")
        self.add_tool(get_weather)
        super().__init__()

agent = WeatherAgent()
answer = agent.run("What's the weather in Paris?")
print(answer)

Det centrale er, at @tool-dekoratøren automatisk udleder JSON-schemaet fra funktionens type-hints og docstring, hvilket gør det nemt at eksponere funktioner for modellen.

I Python findes der overordnet to tilgange til at bygge en chat-grænseflade. Den ene er at bruge et framework som Chatnificent (bygget på Plotly's Dash), som giver en komplet chat-applikation med få linjer kode og understøtter værktøjskald via PythonTool-pillaren.

Den anden tilgang er en FastAPI-backend med Server-Sent Events (SSE) til streaming. Et forenklet eksempel på serversiden ser således ud:

from fastapi import FastAPI
from sse_starlette.sse import EventSourceResponse
from openai import AsyncOpenAI

app = FastAPI()
client = AsyncOpenAI()

async def stream_tokens(prompt: str):
    stream = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        stream=True
    )
    async for chunk in stream:
        if chunk.choices[0].delta.content:
            yield chunk.choices[0].delta.content

@app.get("/chat/stream")
async def stream_chat(prompt: str):
    async def generate():
        async for token in stream_tokens(prompt):
            yield {"event": "token", "data": token}
        yield {"event": "done", "data": ""}
    return EventSourceResponse(generate())

På JavaScript-siden lytter du til EventSource og tilføjer de indkommende tokens til chat-boksen, hvilket giver en levende oplevelse ligesom i ChatGPT og Gemini.

I Python gøres funktionskald nemt med dekoratører, der registrerer funktioner som værktøjer for LLM'en. Python-klienten openmeteo-py-df giver en typet grænseflade til Open-Meteo uden krav om API-nøgle.

Her er et konkret eksempel implementeret med exagent:

import requests
from exagent import Agent, tool

@tool
def get_weather_forecast(city: str, days: int = 1) -> str:
    """Hent vejrudsigt for en by.
    
    Args:
        city: Byens navn, fx København.
        days: Antal dage (1, 2 eller 5).
    """
    # Trin 1: Geokodning (by → koordinater)
    geo_resp = requests.get(
        "https://geocoding-api.open-meteo.com/v1/search",
        params={"name": city, "count": 1}
    )
    geo = geo_resp.json()
    lat = geo["results"][0]["latitude"]
    lon = geo["results"][0]["longitude"]
    
    # Trin 2: Hent vejrdata
    weather_resp = requests.get(
        "https://api.open-meteo.com/v1/forecast",
        params={
            "latitude": lat,
            "longitude": lon,
            "daily": "temperature_2m_max,temperature_2m_min,precipitation_sum,weather_code",
            "forecast_days": days,
            "timezone": "auto"
        }
    )
    weather = weather_resp.json()
    return str(weather["daily"])

class WeatherForecastAgent(Agent):
    def __init__(self):
        self.system_description = (
            "Du er en vejrassesistent. Når brugeren spørger om vejret, "
            "brug get_weather_forecast-værktøjet og formuler en naturlig prognose på dansk."
        )
        self.set_model("openai", "gpt-4.1-mini")
        self.add_tool(get_weather_forecast)
        super().__init__()

agent = WeatherForecastAgent()
result = agent.run("Hvordan bliver vejret i København de næste 3 dage?")
print(result)

Python-koden kalder get_weather_forecast og sender resultatet tilbage til LLM'en, som derefter formulerer en naturlig prognose på dansk.

Både PHP og Python tilbyder et rigt økosystem af frameworks til at bygge AI-agenter. Ved at få styr på LLM-kommunikation, chat-grænseflader og værktøjskald skaber du et solidt fundament, som kan udvides med mere kompleks logik efter behov.