Vejledninger 12 min læsning

Byg din første AI-agent med LangGraph i Python

Lær at bygge en AI-agent med LangGraph i Python fra bunden. Denne trin-for-trin guide dækker StateGraph, værktøjsintegration, hukommelse og streaming — med kodeeksempler der virker i 2026.

Editorial Team

Hvad er LangGraph, og hvorfor skal du kende det?

Hvis du har fulgt med i AI-verdenen i 2026, har du sikkert bemærket, at alle taler om AI-agenter. Og med god grund — vi er gået fra simple chatbots, der bare svarer på spørgsmål, til autonome systemer, der kan planlægge, ræsonnere og udføre komplekse opgaver helt på egen hånd.

LangGraph er det framework, der gør det praktisk muligt i Python.

Det er et open source-bibliotek bygget oven på LangChain, og det lader dig modellere AI-workflows som grafer med noder og kanter. Det lyder måske abstrakt, men idéen er ret elegant: i modsætning til traditionelle LangChain-kæder, der kun kan køre lineært (fra A til B til C), understøtter LangGraph cykliske grafer. Det betyder, at din agent kan "loope" — den kan tage en beslutning, prøve noget, evaluere resultatet og prøve igen. Og det er præcis den adfærd, der gør en AI-agent til en ægte agent.

Virksomheder som Klarna, Replit og Elastic bruger allerede LangGraph i produktion til alt fra kundeservice til kodegenerering. Så lad os bygge din første agent — trin for trin.

Forudsætninger og opsætning

Før vi går i gang, skal du have et par ting på plads:

  • Python 3.11 eller nyere
  • En API-nøgle fra enten OpenAI eller Anthropic (Claude)
  • Grundlæggende kendskab til Python (du behøver ikke være ekspert)

Installation af pakker

Start med at oprette et virtuelt miljø og installér de nødvendige pakker:

python -m venv langgraph-env
source langgraph-env/bin/activate  # macOS/Linux
# langgraph-env\Scripts\activate   # Windows

pip install langgraph langchain-openai langchain-anthropic langchain-community tavily-python

Konfigurér miljøvariabler

Sæt din API-nøgle som miljøvariabel. Du kan bruge enten OpenAI eller Anthropic — begge fungerer fint:

# For OpenAI:
export OPENAI_API_KEY="din-openai-noegle"

# For Anthropic (Claude):
export ANTHROPIC_API_KEY="din-anthropic-noegle"

# Valgfrit — til websøgning:
export TAVILY_API_KEY="din-tavily-noegle"

LangGraphs kernebegreber (de vigtige fire)

Inden vi kaster os ud i koden, er det værd at bruge et minut på de fire grundlæggende byggesten. Når først du forstår dem, falder resten meget nemmere på plads.

Noder (Nodes)

Noder er de individuelle trin i dit workflow. Hver node udfører én specifik handling — det kan være et LLM-kald, et værktøjsopkald eller bare en almindelig Python-funktion. Tænk på dem som arbejdsstationer i en fabrik, hvor hver station har sin opgave.

Kanter (Edges)

Kanter forbinder noderne og bestemmer, hvordan workflowet bevæger sig fremad. Der er to typer: direkte kanter (fast rute fra A til B) og betingede kanter, hvor den næste destination afhænger af outputtet. Det er de betingede kanter, der virkelig gør det hele interessant.

Tilstand (State)

Tilstanden er grundlæggende et delt hukommelsesobjekt, der flyder gennem hele grafen. Det er her, beskeder, variabler og mellemresultater bliver gemt. LangGraph håndterer tilstanden automatisk, så du ikke selv skal holde styr på alt manuelt.

StateGraph

StateGraph er den centrale klasse, du arbejder med i LangGraph. Du definerer dine noder og kanter, kalder .compile(), og så har du en eksekverbar graf med invoke(), stream() og ainvoke(). Simpelt nok.

Trin 1: Definér tilstanden

Okay, nu til koden. Vi starter med at definere den tilstand, som vores agent skal arbejde med. I LangGraph bruger vi en TypedDict til dette:

from typing import Annotated
from typing_extensions import TypedDict
from langchain_core.messages import AnyMessage
import operator


class AgentState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]

Læg mærke til operator.add som reducer-funktion. Det betyder, at nye beskeder bliver tilføjet til listen i stedet for at overskrive den. Det er vigtigt, fordi det er sådan, vi opbygger en samtalehistorik, som agenten kan referere til.

Trin 2: Definér værktøjer

Værktøjer er ganske enkelt Python-funktioner, som din AI-agent kan kalde. LLM'en bruger funktionens navn, docstring og parametre til at finde ud af, hvornår det giver mening at bruge det. Lad os oprette to simple værktøjer — en beregner og en søgefunktion:

from langchain_core.tools import tool


@tool
def beregn(udtryk: str) -> str:
    """Beregn et matematisk udtryk og returner resultatet."""
    try:
        resultat = eval(udtryk)
        return f"Resultatet af {udtryk} er {resultat}"
    except Exception as e:
        return f"Fejl ved beregning: {e}"


@tool
def soeg_information(foresporgsel: str) -> str:
    """Søg efter aktuel information på internettet."""
    from tavily import TavilyClient
    import os

    client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
    response = client.search(foresporgsel, max_results=3)
    resultater = []
    for r in response["results"]:
        resultater.append(f"- {r['title']}: {r['content'][:200]}")
    return "\n".join(resultater)

Trin 3: Konfigurér LLM-modellen

Nu skal vi binde værktøjerne til en sprogmodel. Du kan vælge mellem OpenAI og Anthropic Claude — jeg viser begge muligheder her:

from langchain.chat_models import init_chat_model

# Valgmulighed A: OpenAI GPT-4o
model = init_chat_model("gpt-4o", temperature=0)

# Valgmulighed B: Anthropic Claude Sonnet
# model = init_chat_model("claude-sonnet-4-5-20250929", temperature=0)

# Bind værktøjerne til modellen
vaerktoejer = [beregn, soeg_information]
model_med_vaerktoejer = model.bind_tools(vaerktoejer)

Trin 4: Byg selve agentgrafen

Her er det, det hele kommer sammen. Vi definerer to noder — en agent-node og en værktøjs-node — plus en betinget kant, der bestemmer, om agenten skal kalde et værktøj eller afslutte med et svar:

from langgraph.graph import StateGraph, START, END
from langgraph.prebuilt import ToolNode
from langchain_core.messages import HumanMessage


# Agent-noden: kalder LLM med værktøjer
def agent_node(state: AgentState) -> dict:
    response = model_med_vaerktoejer.invoke(state["messages"])
    return {"messages": [response]}


# Betinget routing: tjek om agenten vil kalde et værktøj
def skal_fortsaette(state: AgentState) -> str:
    sidste_besked = state["messages"][-1]
    if hasattr(sidste_besked, "tool_calls") and sidste_besked.tool_calls:
        return "vaerktoejer"
    return END


# Opret grafen
graf = StateGraph(AgentState)

# Tilføj noder
graf.add_node("agent", agent_node)
graf.add_node("vaerktoejer", ToolNode(vaerktoejer))

# Tilføj kanter
graf.add_edge(START, "agent")
graf.add_conditional_edges("agent", skal_fortsaette, {
    "vaerktoejer": "vaerktoejer",
    END: END
})
graf.add_edge("vaerktoejer", "agent")  # Loop tilbage til agenten

# Kompilér grafen
app = graf.compile()

Trin 5: Kør din agent

Nu er det tid til det sjove. Lad os teste agenten med et par forskellige opgaver:

# Test med en beregning
resultat = app.invoke({
    "messages": [HumanMessage(content="Hvad er 2847 * 391?")]
})
print(resultat["messages"][-1].content)

# Test med en søgning
resultat = app.invoke({
    "messages": [HumanMessage(content="Hvad er de seneste trends inden for AI-agenter i 2026?")]
})
print(resultat["messages"][-1].content)

Sådan fungerer agentloopet

Når du kalder app.invoke(), sker der faktisk noget ret smart:

  1. Brugerens besked sendes til agent-noden
  2. LLM'en analyserer beskeden og beslutter, om den skal kalde et værktøj
  3. Hvis ja, sendes kaldet til værktøjs-noden, som udfører funktionen
  4. Resultatet returneres til agent-noden, der kan vælge at kalde flere værktøjer eller give et endeligt svar
  5. Loopet fortsætter, indtil LLM'en vurderer, at den har nok information til at svare

Det er den her "loop-on-failure"-mekanisme, der gør systemet til en ægte agent. Det fejler ikke bare og giver op — det forsøger aktivt at løse problemet på egen hånd. Og ærligt talt, det er ret imponerende at se i praksis.

Tilføj hukommelse med MemorySaver

En af de ting, der virkelig adskiller LangGraph fra simplere frameworks, er den indbyggede støtte til persistent hukommelse. Med en checkpointer kan din agent huske tidligere samtaler på tværs af kald:

from langgraph.checkpoint.memory import MemorySaver

# Tilføj hukommelse
checkpointer = MemorySaver()
app_med_hukommelse = graf.compile(checkpointer=checkpointer)

# Brug et thread_id til at gemme samtalehistorik
config = {"configurable": {"thread_id": "samtale-1"}}

# Første besked
resultat = app_med_hukommelse.invoke(
    {"messages": [HumanMessage(content="Jeg hedder Anders")]},
    config=config
)
print(resultat["messages"][-1].content)

# Anden besked — agenten husker dit navn
resultat = app_med_hukommelse.invoke(
    {"messages": [HumanMessage(content="Hvad hedder jeg?")]},
    config=config
)
print(resultat["messages"][-1].content)

Vigtigt at vide: MemorySaver gemmer alt i RAM, så den er kun til udvikling og test. Når du skal i produktion, bør du skifte til SqliteSaver eller PostgresSaver for at sikre, at data overlever genstart.

Streaming af svar i realtid

Ingen har lyst til at sidde og stirre på en tom skærm, mens agenten tænker. Med streaming kan du vise svaret token for token, efterhånden som det genereres:

from langchain_core.messages import HumanMessage

for event in app.stream(
    {"messages": [HumanMessage(content="Forklar kvantemekanik kort")]},
    stream_mode="values"
):
    if event["messages"]:
        sidste = event["messages"][-1]
        print(sidste.content, end="", flush=True)

Fra prototype til produktion

Når din agent fungerer lokalt, er næste skridt at gøre den klar til den virkelige verden. Her er nogle retninger, du kan tage:

  • Flere værktøjer: Database-forespørgsler, API-kald, filhåndtering — mulighederne er nærmest uendelige
  • Multi-agent-systemer: Brug LangGraph til at orkestrere flere specialiserede agenter, der samarbejder om en opgave
  • Agentic RAG: Kombinér din agent med en RAG-pipeline, så den kan søge i dine egne dokumenter og vidensbaser
  • Node-level caching: LangGraphs nye caching-funktionalitet reducerer redundante beregninger og sparer API-kald
  • LangGraph Platform: Deploy din agent som en skalerbar API med LangGraph Cloud

LangGraph vs. CrewAI vs. AutoGen

Hvis du overvejer, hvilket agent-framework du skal vælge, er det værd at kende de tre store spillere i 2026:

  • LangGraph — Grafbaseret arkitektur med fuld kontrol over hvert eneste trin. Det er det bedste valg til enterprise-systemer, hvor compliance og auditérbarhed er vigtigt. Indlæringskurven er højere, men til gengæld er det det mest kraftfulde framework af de tre.
  • CrewAI — Rollebaseret teamstruktur, der afspejler menneskelige organisationer. Hurtigere eksekvering i mange scenarier og markant lavere indlæringskurve. Rigtig godt til hurtig prototyping og business-automatisering.
  • AutoGen (Microsoft) — Samtalebaseret agent-arkitektur, hvor agenter kommunikerer via dialog. Stærkt til iterativ problemløsning og kodegenerering.

Min anbefaling? Hvis du har brug for præcis kontrol og skalerbarhed, er LangGraph det rigtige valg. Hvis du bare vil komme hurtigt i gang, er CrewAI et solidt alternativ. Det handler om at vælge det rigtige værktøj til opgaven.

Ofte stillede spørgsmål

Hvad er forskellen mellem LangChain og LangGraph?

LangChain er et high-level framework til at bygge LLM-applikationer med lineære kæder. LangGraph er bygget oven på LangChain, men tilføjer det, der virkelig gør forskellen: cykliske grafer, persistent tilstand og betinget routing. Det er de funktioner, der er nødvendige for at bygge AI-agenter, der kan ræsonnere og handle i loops — noget LangChain alene ikke kan.

Kan jeg bruge LangGraph med Claude i stedet for OpenAI?

Ja, helt sikkert. LangGraph er modeluafhængigt. Installér langchain-anthropic-pakken og initialiser din model med init_chat_model("claude-sonnet-4-5-20250929"). Faktisk bruger LangGraphs officielle dokumentation Claude Sonnet som standardmodel i sine quickstart-eksempler.

Er LangGraph egnet til produktion?

Ja. Virksomheder som Klarna og Elastic kører LangGraph i produktion allerede. Til produktionsmiljøer bør du erstatte MemorySaver med PostgresSaver for persistent tilstandslagring, og overvej LangGraph Platform til skalerbar deployment.

Hvor mange værktøjer kan en LangGraph-agent have?

Der er ingen hård grænse, men erfaringen viser, at 5-15 værktøjer fungerer bedst. Med for mange værktøjer kan LLM'en have svært ved at vælge det rigtige. Til systemer med mange værktøjer er en multi-agent-arkitektur (hvor hver agent har et fokuseret sæt) ofte en bedre tilgang.

Hvad er agentic RAG, og hvordan relaterer det sig til LangGraph?

Agentic RAG kombinerer Retrieval-Augmented Generation med agentbaseret beslutningstagning. I stedet for bare at søge og svare, kan en agentic RAG-pipeline vurdere retrieval-kvaliteten, omskrive forespørgsler og prøve alternative strategier. LangGraphs cykliske grafer gør det muligt at bygge de "retry-loops", der er kernen i denne tilgang — og det er derfor, LangGraph er det foretrukne framework til agentic RAG.

Om Forfatteren Editorial Team

Our team of expert writers and editors.