Bygg ett multi-agentsystem med LangGraph i Python – steg för steg

Varför multi-agentsystem är framtiden för AI-automatisering

Under 2025 byggde de flesta utvecklare enstaka AI-agenter som försökte göra allting själva. Men nu, 2026, har spelplanen förändrats rejält. Gartner rapporterade en ökning på hela 1 445 procent i förfrågningar om multi-agentsystem mellan Q1 2024 och Q2 2025 – och trenden har bara fortsatt uppåt sedan dess. Marknaden för autonoma AI-agenter beräknas nå 8,5 miljarder dollar under 2026.

Anledningen? Den är faktiskt ganska enkel.

Precis som en enda person inte kan driva ett helt företag effektivt, kan en enda AI-agent inte hantera komplexa arbetsflöden på ett pålitligt sätt. Kontextfönstret blir överbelastat, hallucinationer ökar och resultaten blir opålitliga. Multi-agentsystem löser det genom att dela upp arbetet mellan specialiserade agenter som samarbetar – ungefär som ett väloljat team där alla vet sin roll.

I den här guiden bygger vi ett komplett multi-agentsystem i Python med LangGraph, ramverket som nått stabil version 1.0 och som används av företag som Klarna, Replit och Elastic. Du får fungerande kod, förklaringar av arkitekturen och praktiska tips för produktionsmiljöer. Jag har själv kört LangGraph i ett par projekt nu och kan säga att det är ett av de mest genomtänkta ramverken för agent-orkestrering just nu.

Vad är LangGraph och varför välja det?

LangGraph är ett orkestreringsramverk inom LangChain-ekosystemet, byggt specifikt för att skapa tillståndsrika, multi-aktörs-applikationer drivna av stora språkmodeller. Till skillnad från enklare ramverk som CrewAI modellerar LangGraph arbetsflöden som riktade grafer – med noder, kanter och delat tillstånd.

Så, vad gör LangGraph unikt jämfört med alternativen?

• Deterministisk exekvering – Du definierar exakt vilka steg som körs och i vilken ordning, istället för att låta en LLM fatta alla beslut åt dig. Resultatet blir förutsägbart och mycket enklare att felsöka.
• Tillståndshantering – Inbyggd persistens, felåterställning och möjlighet att återuppta arbetsflöden vid avbrott.
• Human-in-the-loop – Pausa exekveringen för mänsklig granskning och godkännande vid kritiska beslutspunkter.
• Streaming – Token-för-token-streaming som visar agenternas resonemang i realtid (otroligt bra vid felsökning).
• Parallell exekvering – Flera agenter kan arbeta samtidigt på olika delar av ett problem.

I benchmarktester visar LangGraph 30–40 procent lägre latens jämfört med alternativa ramverk i komplexa arbetsflöden. Det har passerat 38 miljoner månatliga nedladdningar på PyPI, vilket gör det till det i särklass mest använda ramverket för agent-orkestrering.

LangGraph kontra CrewAI – när ska du välja vad?

Det vanligaste alternativet till LangGraph är CrewAI, som använder en rollbaserad modell istället för grafer. Här är skillnaderna i korthet:

• CrewAI – Perfekt för snabb prototyping. Du definierar agenter med roller och mål, och ramverket sköter koordineringen. Nackdelen? Begränsad kontroll över exekveringsflödet och ofta högre tokenförbrukning.
• LangGraph – Kräver mer kod men ger fullständig kontroll. Bäst för produktionssystem som behöver villkorlig logik, tillståndsrollback och granskningsbarhet.

Ett vanligt mönster jag sett i branschen: team prototypar i CrewAI, validerar konceptet och migrerar sedan till LangGraph när de behöver mer kontroll. Migreringsvägen innebär att varje CrewAI-agent mappas till en LangGraph-nod och den sekventiella processen konverteras till explicita grafkanter. Inte helt smärtfritt, men fullt hanterbart.

Arkitekturen: supervisor-mönstret

Det vanligaste arkitekturmönstret för multi-agentsystem i LangGraph är supervisor-mönstret. En central supervisor-agent fungerar som arbetsledare och delegerar uppgifter till specialiserade sub-agenter. Tänk på supervisorn som en chef vars "verktyg" är andra agenter.

Flödet ser ut så här:

1. Användaren skickar en förfrågan till supervisorn.
2. Supervisorn analyserar förfrågan och bestämmer vilken agent som ska ta sig an den.
3. Den valda agenten utför sitt arbete och skriver resultatet till det delade tillståndet.
4. Supervisorn utvärderar resultatet och bestämmer nästa steg – antingen skicka till en annan agent eller leverera svaret till användaren.

Det finns andra arkitekturmönster också – decentraliserade system där agenter koordinerar sinsemellan, och hybridmodeller med hierarkiska team. Men ärligt talat ger supervisor-mönstret den bästa balansen mellan kontroll och flexibilitet för de allra flesta användningsfall.

Förutsättningar

Innan du börjar behöver du:

• Python 3.10 eller senare – LangGraph 1.0 kräver minst Python 3.10.
• En OpenAI API-nyckel – Vi använder GPT-4o-mini i exemplen, men du kan byta till Claude eller en annan modell.
• Grundläggande Python-kunskaper – Du bör vara bekväm med funktioner, klasser och typannotationer.

Steg 1: Installera beroenden

Skapa ett nytt projekt och installera de nödvändiga paketen:

mkdir multi-agent-demo
cd multi-agent-demo
python -m venv .venv
source .venv/bin/activate  # Linux/macOS
# .venv\Scripts\activate   # Windows

pip install langgraph langchain-openai langchain-core

Skapa sedan en .env-fil med din API-nyckel:

OPENAI_API_KEY=din-api-nyckel-har

Steg 2: Definiera det delade tillståndet

Tillståndet är kärnan i ett LangGraph-system. Det är en delad datastruktur som skickas mellan alla noder i grafen – tänk på det som ett gemensamt anteckningsblock som varje agent kan läsa från och skriva till.

Skapa en fil som heter state.py:

from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph.message import add_messages

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    next_agent: str
    research_data: str
    draft_content: str
    final_output: str

Funktionen add_messages är en reducer som säkerställer att nya meddelanden läggs till listan istället för att skriva över den. Varje fält i tillståndet har ett specifikt syfte:

• messages – Konversationshistoriken som alla agenter delar.
• next_agent – Avgör vilken nod som ska köras härnäst.
• research_data – Data som forskningsagenten samlar in.
• draft_content – Utkast som skrivagenten producerar.
• final_output – Det slutgiltiga resultatet efter granskning.

Steg 3: Skapa de specialiserade agenterna

Nu definierar vi tre specialiserade agenter: en forskare, en skribent och en granskare. Varje agent är en Python-funktion som tar emot tillståndet, gör sitt jobb och returnerar uppdateringar.

Skapa agents.py:

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from state import AgentState

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)

def research_agent(state: AgentState) -> dict:
    """Forskningsagent som samlar information om ett ämne."""
    messages = state["messages"]
    last_message = messages[-1].content if messages else ""

    system_prompt = SystemMessage(content=(
        "Du är en expert forskningsassistent. "
        "Din uppgift är att analysera förfrågan och samla "
        "relevant information, fakta och nyckelinsikter. "
        "Var noggrann och strukturerad i din research."
    ))

    response = llm.invoke([system_prompt, HumanMessage(content=(
        f"Forskningsförfrågan: {last_message}\n\n"
        "Samla relevant information och presentera den strukturerat."
    ))])

    return {
        "research_data": response.content,
        "messages": [response]
    }

def writing_agent(state: AgentState) -> dict:
    """Skrivagent som skapar innehåll baserat på research."""
    research = state.get("research_data", "")

    system_prompt = SystemMessage(content=(
        "Du är en professionell skribent. "
        "Baserat på den research du får, skriv ett välstrukturerat "
        "och engagerande innehåll. Använd tydliga rubriker "
        "och konkreta exempel."
    ))

    response = llm.invoke([system_prompt, HumanMessage(content=(
        f"Baserat på följande research, skriv ett genomarbetat "
        f"innehåll:\n\n{research}"
    ))])

    return {
        "draft_content": response.content,
        "messages": [response]
    }

def review_agent(state: AgentState) -> dict:
    """Granskningsagent som utvärderar och förbättrar utkastet."""
    draft = state.get("draft_content", "")

    system_prompt = SystemMessage(content=(
        "Du är en erfaren redaktör och kvalitetsgranskare. "
        "Granska texten och förbättra den. Kontrollera att "
        "fakta stämmer, att strukturen är logisk och att "
        "språket är klart och professionellt."
    ))

    response = llm.invoke([system_prompt, HumanMessage(content=(
        f"Granska och förbättra följande utkast:\n\n{draft}"
    ))])

    return {
        "final_output": response.content,
        "messages": [response]
    }

Varje agent har en tydligt avgränsad uppgift. Forskaren samlar data, skribenten omvandlar den till text och granskaren polerar slutresultatet. Den här uppdelningen – separation of concerns – är precis det som gör multi-agentsystem överlägsna enskilda agenter. Istället för att en modell ska försöka vara bra på allt samtidigt får varje agent fokusera på det den gör bäst.

Steg 4: Bygg supervisor-agenten

Supervisorn är hjärnan i systemet. Den analyserar det som användaren frågar efter och det aktuella tillståndet för att avgöra vilken agent som bör arbeta härnäst.

Skapa supervisor.py:

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from state import AgentState
import json

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

AGENT_OPTIONS = ["researcher", "writer", "reviewer", "FINISH"]

def supervisor_agent(state: AgentState) -> dict:
    """Supervisor som dirigerar arbetsflödet mellan agenter."""
    messages = state["messages"]
    research = state.get("research_data", "")
    draft = state.get("draft_content", "")
    final = state.get("final_output", "")

    system_prompt = SystemMessage(content=(
        "Du är en projektledare som koordinerar ett team av "
        "AI-agenter. Ditt team består av:\n"
        "- researcher: Samlar information och fakta\n"
        "- writer: Skriver innehåll baserat på research\n"
        "- reviewer: Granskar och förbättrar utkast\n\n"
        "Baserat på konversationen och det aktuella tillståndet, "
        "bestäm vilken agent som ska arbeta härnäst. "
        "Svara ENBART med ett JSON-objekt: "
        "{\"next\": \"agentnamn eller FINISH\"}"
    ))

    context = f"Research: {'finns' if research else 'saknas'}\n"
    context += f"Utkast: {'finns' if draft else 'saknas'}\n"
    context += f"Slutresultat: {'finns' if final else 'saknas'}"

    response = llm.invoke([
        system_prompt,
        HumanMessage(content=(
            f"Aktuellt tillstånd:\n{context}\n\n"
            f"Konversation:\n{messages[-1].content if messages else 'Ingen förfrågan ännu'}"
        ))
    ])

    try:
        result = json.loads(response.content)
        next_agent = result.get("next", "FINISH")
    except json.JSONDecodeError:
        next_agent = "FINISH"

    if next_agent not in AGENT_OPTIONS:
        next_agent = "FINISH"

    return {"next_agent": next_agent}

Supervisorn tar ett medvetet beslut baserat på vad som redan finns i tillståndet. Saknas research? Då skickar den till forskaren. Finns research men inget utkast? Då är det skribentens tur. Enkelt och logiskt. Det fina är att du har full kontroll över den här logiken – inget magiskt under huven.

Steg 5: Koppla ihop allt i grafen

Nu kommer det riktigt intressanta – att bygga den riktade grafen som definierar hela arbetsflödet. Det här steget knyter ihop allt vi gjort hittills.

Skapa graph.py:

from langgraph.graph import StateGraph, START, END
from state import AgentState
from agents import research_agent, writing_agent, review_agent
from supervisor import supervisor_agent

def route_next(state: AgentState) -> str:
    """Villkorlig routing baserat på supervisorns beslut."""
    next_agent = state.get("next_agent", "FINISH")
    if next_agent == "researcher":
        return "researcher"
    elif next_agent == "writer":
        return "writer"
    elif next_agent == "reviewer":
        return "reviewer"
    else:
        return "end"

# Bygg grafen
workflow = StateGraph(AgentState)

# Lägg till noder
workflow.add_node("supervisor", supervisor_agent)
workflow.add_node("researcher", research_agent)
workflow.add_node("writer", writing_agent)
workflow.add_node("reviewer", review_agent)

# Definiera kanter
workflow.add_edge(START, "supervisor")
workflow.add_edge("researcher", "supervisor")
workflow.add_edge("writer", "supervisor")
workflow.add_edge("reviewer", "supervisor")

# Villkorlig routing från supervisorn
workflow.add_conditional_edges(
    "supervisor",
    route_next,
    {
        "researcher": "researcher",
        "writer": "writer",
        "reviewer": "reviewer",
        "end": END
    }
)

# Kompilera grafen
app = workflow.compile()

Grafens struktur är tydlig: varje agent rapporterar tillbaka till supervisorn efter sitt arbete, och supervisorn bestämmer vad som händer härnäst. Den villkorliga routingen via add_conditional_edges gör att systemet kan ta dynamiska beslut baserat på tillståndet. Det påminner lite om en state machine, fast med LLM-baserade beslut i noderna.

Steg 6: Kör systemet

Dags att testa! Skapa main.py för att köra multi-agentsystemet:

from dotenv import load_dotenv
from langchain_core.messages import HumanMessage
from graph import app

load_dotenv()

def run_multi_agent(query: str) -> str:
    """Kör multi-agentsystemet med en given förfrågan."""
    initial_state = {
        "messages": [HumanMessage(content=query)],
        "next_agent": "",
        "research_data": "",
        "draft_content": "",
        "final_output": ""
    }

    result = app.invoke(initial_state)
    return result.get("final_output", "Inget resultat genererades.")

if __name__ == "__main__":
    query = "Skriv en analys av hur RAG-pipelines utvecklats under 2026"
    print("Startar multi-agentsystem...\n")
    output = run_multi_agent(query)
    print("Slutresultat:")
    print(output)

Kör med:

python main.py

Du bör se hur systemet stegvis delegerar arbetet – först till forskaren, sedan till skribenten och slutligen till granskaren – innan det levererar ett polerat slutresultat. Första gången det fungerar är det genuint tillfredsställande att se agenterna samarbeta.

Steg 7: Lägg till streaming och observabilitet

I produktionsmiljöer vill du kunna se vad som händer i realtid. Ingen vill sitta och vänta på ett svar utan att veta om systemet faktiskt gör något. LangGraph stöder streaming direkt ur lådan:

from dotenv import load_dotenv
from langchain_core.messages import HumanMessage
from graph import app

load_dotenv()

query = "Jämför de tre viktigaste AI-agentramverken 2026"

initial_state = {
    "messages": [HumanMessage(content=query)],
    "next_agent": "",
    "research_data": "",
    "draft_content": "",
    "final_output": ""
}

for event in app.stream(initial_state):
    for node_name, node_output in event.items():
        print(f"\n--- {node_name} ---")
        if "messages" in node_output:
            last_msg = node_output["messages"][-1]
            print(f"Output: {last_msg.content[:200]}...")
        if "next_agent" in node_output:
            print(f"Nästa agent: {node_output['next_agent']}")

Metoden app.stream() ger dig en händelse för varje nod som körs, inklusive vilken agent som just arbetat och vad den producerade. Felsökning blir avsevärt enklare med det här.

För fullskalig observabilitet kan du integrera med LangSmith, som ger visuella spår av hela exekveringsflödet, latenstider per nod och tokenkostnader. Väl värt att sätta upp tidigt i projektet, även om det känns som överkill i början.

Steg 8: Lägg till minne för flerturnskonversationer

En av de riktigt starka sidorna med LangGraph är inbyggt stöd för persistent minne. Genom att lägga till en checkpointer kan systemet komma ihåg tidigare konversationer:

from langgraph.checkpoint.memory import MemorySaver

memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

# Kör med ett tråd-ID för att spara konversationshistorik
config = {"configurable": {"thread_id": "session-001"}}

result = app.invoke(initial_state, config=config)

Checkpointern sparar tillståndet efter varje nod, vilket innebär att du kan återuppta arbetsflöden vid avbrott. I produktionsmiljöer bör du byta till en databasbaserad checkpointer (exempelvis PostgreSQL) för beständig lagring.

Avancerade mönster: parallella agenter och human-in-the-loop

Parallell exekvering

Om du har agenter som kan arbeta oberoende av varandra kan du dra nytta av parallella kanter. Till exempel kan en forskningsagent och en dataagent jobba samtidigt:

# Lägg till parallella kanter från supervisorn
workflow.add_edge("supervisor", "researcher")
workflow.add_edge("supervisor", "data_agent")
# Båda rapporterar tillbaka till en merge-nod
workflow.add_edge("researcher", "merge_results")
workflow.add_edge("data_agent", "merge_results")

LangGraph hanterar parallellismen automatiskt – båda noderna exekveras samtidigt och deras resultat sammanfogas i merge-noden. Snyggt och enkelt.

Human-in-the-loop

För arbetsflöden som kräver mänskligt godkännande (och det gör fler än du tror) kan du använda interrupt_before vid kompileringen:

app = workflow.compile(
    checkpointer=memory,
    interrupt_before=["writer"]
)

# Systemet pausar innan skrivagenten körs
# Användaren kan granska research-data och godkänna
# Sedan fortsätter exekveringen:
app.invoke(None, config=config)  # Återupptar från pausen

Det här mönstret är ovärderligt i produktionssystem där kritiska beslut behöver mänsklig översyn – exempelvis innan ett e-postmeddelande skickas eller en databas uppdateras. Det handlar om att bygga förtroende för systemet, steg för steg.

Produktionstips och bästa praxis

Baserat på erfarenheter från team som kört LangGraph i produktion under 2025 och 2026, här är de viktigaste lärdomarna:

• Börja enkelt – Starta med tre agenter och lägg till fler först när du har ett tydligt behov. Fler agenter innebär mer komplexitet och högre tokenförbrukning. Det är frestande att bygga stort direkt, men motstå den impulsen.
• Typade tillstånd – Använd alltid TypedDict för ditt tillstånd. Det ger bättre felmeddelanden och gör koden självdokumenterande.
• Testa varje agent isolerat – Skriv enhetstester för varje agent-funktion innan du kopplar ihop dem i grafen. Det sparar enormt mycket tid vid felsökning.
• Sätt tidsgränser – I produktionsmiljöer bör du sätta en maximal tid för hela arbetsflödet och för varje enskild agent, så att systemet inte fastnar i oändliga loopar.
• Övervaka tokenkostnader – Supervisor-mönstret innebär att LLM:en anropas minst en gång per steg i grafen. Håll koll på tokenförbrukningen, särskilt vid skalning.
• Felhantering – Lägg till try-except i varje agent och låt supervisorn hantera fel genom att omdirigera eller avsluta graciöst. Saker går fel – planera för det.

Koppla till MCP-servrar

Om du har läst vår tidigare artikel om att bygga MCP-servrar med FastMCP kan du kombinera de två teknikerna. LangGraph-agenter kan använda MCP-verktyg genom att registrera dem som LangChain-verktyg:

from langchain_core.tools import tool

@tool
def mcp_weather_tool(city: str) -> str:
    """Hämta väderdata via MCP-servern."""
    # Anropa din MCP-server här
    # Detta kopplar ihop MCP-ekosystemet med multi-agentsystemet
    pass

Den här kombinationen ger dig det bästa av båda världarna: MCP:s standardiserade verktygsintegration och LangGraphs sofistikerade agent-orkestrering. Om du jobbar med externa datakällor eller API:er är det värt att titta närmare på.

Vanliga frågor

Vad är skillnaden mellan ett multi-agentsystem och en vanlig AI-chatbot?

En vanlig chatbot använder en enda LLM-instans som hanterar hela konversationen. Ett multi-agentsystem delar upp arbetet mellan flera specialiserade agenter, var och en med sin egen systemprompt och uppgift. Det leder till bättre resultat på komplexa uppgifter, helt enkelt för att varje agent kan fokusera på ett avgränsat ansvarsområde istället för att försöka lösa allting på egen hand.

Behöver jag betala för flera LLM-anrop i ett multi-agentsystem?

Ja, varje agent som anropar en LLM genererar en separat kostnad. Men du kan optimera genom att använda billigare modeller för enklare agenter och mer kapabla modeller bara där det verkligen behövs. LangGraph ger dig full kontroll över vilken modell varje nod använder, så du kan blanda exempelvis GPT-4o-mini för supervisorn och Claude Sonnet för skrivagenten.

Kan jag använda LangGraph med Claude istället för OpenAI?

Absolut. LangGraph stöder alla LLM-leverantörer via LangChains abstraktionslager. Byt ut ChatOpenAI mot ChatAnthropic från paketet langchain-anthropic och konfigurera din Anthropic API-nyckel. Resten av koden förblir identisk.

Hur skalar jag ett multi-agentsystem för produktion?

LangGraph erbjuder LangSmith Deployment för skalning av agent-arbetsflöden i produktion. Du kan också containerisera varje agent med Docker, använda en databasbaserad checkpointer för beständig tillståndslagring, och implementera köer för att hantera flera samtidiga förfrågningar. Nyckeln är att börja med en robust observabilitetsstack så att du kan identifiera flaskhalsar tidigt.

Hur felsöker jag ett multi-agentsystem som inte ger rätt resultat?

Använd app.stream() för att se exakt vilken agent som körs och vad den producerar i varje steg. Kontrollera att supervisorns routing-logik fungerar korrekt och att varje agents systemprompt är tillräckligt specifik. LangSmith erbjuder visuella exekveringsspår som gör det enkelt att hitta var i kedjan något går snett.