LangGraph: praktisk guide för svenska AI-team 2026

Vad är LangGraph? State graph vs sequential chains

LangGraph är LangChains svar på behovet att bygga agent-flöden som har state, grenar och återkomster. LangChains klassiska LCEL (LangChain Expression Language) är utmärkt för raka pipelines – t.ex. prompt-template följt av LLM följt av output-parser – men får svårt när flödet behöver återgå till samma nod eller när state måste hållas mellan turer.

En LangGraph-graf definieras med tre primitiver: StateGraph som håller grafen, nodes (Python-funktioner eller LLM-anrop), och edges (statiska eller villkorliga transitions). State är en TypedDict eller Pydantic-modell som deles mellan alla noder. Varje nod tar in current state, gör sitt jobb, och returnerar en partial update som slås ihop med state.

När använda LangGraph vs LCEL? Regel: om flödet har grenar, cycler eller HITL, använd LangGraph; om det är en rak pipeline, använd LCEL. I praktiken 2026 är majoriteten av Alice Labs produktions-agenter LangGraph-baserade eftersom nästan alla har HITL-gates eller villkorliga grenar. För bredare orientering: AI-agenter: Komplett guide för svenska företag 2026 och pillar-money-sidan AI-agenter.

# Minsta LangGraph-agent (Python)
from langgraph.graph import StateGraph, END
from typing import TypedDict, List

class State(TypedDict):
    messages: List[str]

def agent_node(state: State) -> dict:
    return {"messages": state["messages"] + ["Hej från agenten"]}

graph = StateGraph(State)
graph.add_node("agent", agent_node)
graph.set_entry_point("agent")
graph.add_edge("agent", END)
app = graph.compile()
result = app.invoke({"messages": ["Hej"]})

Checkpointing: replay, time-travel-debug och regressionstester

Sammanfattat

Checkpointing sparar state efter varje transition till en persistent store (MemorySaver för dev, PostgresSaver eller SQLiteSaver för produktion). Detta möjliggör tre kritiska produktionsfunktioner: (1) replay av en trasig körning för debugging, (2) time-travel där ni kan gå tillbaka till en tidigare state och prova en annan kant, (3) deterministiska regressionstester där ni jämför nuvarande state-sekvens mot en gyllene baseline.

Checkpointing är LangGraphs unique-selling-point och den enskilt viktigaste anledningen att välja det över LCEL eller CrewAI för produktionsuse-cases. Varje state-transition sparas i en checkpointer (in-memory för utveckling, Postgres eller SQLite för produktion) med en unik thread_id och checkpoint_id.

Tre kritiska produktionsanvändningar:

• Replay – när en produktions-agent misslyckas kan ni ladda thread och köra om från senaste checkpoint. Ingen behöver reproducera manuellt.
• Time-travel-debug – gå tillbaka till en tidigare state, ändra en variabel och kör vidare för att testa en annan kant. Ovärderligt för att förstå varför en agent fattade ett visst beslut.
• Regressionstester – kör samma input mot nya modellversioner (Claude Sonnet 4.5 vs Opus 4.7) och jämför state-sekvenser mot en baseline. Fångar regressioner som klassiska unit-tests missar.

# Checkpointing i produktion (Postgres)
from langgraph.checkpoint.postgres import PostgresSaver

checkpointer = PostgresSaver.from_conn_string(
    "postgresql://user:pass@db.eu-central-1.rds.amazonaws.com/langgraph"
)
app = graph.compile(checkpointer=checkpointer)

# Kör med thread_id för att hämta senare
config = {"configurable": {"thread_id": "kund-42-arende-1337"}}
result = app.invoke({"messages": ["Boka om ordern"]}, config)

# Time-travel: hämta alla checkpoints
history = list(app.get_state_history(config))
# Rerun från specifik checkpoint
app.invoke(None, {"configurable": {"thread_id": "kund-42-arende-1337", "checkpoint_id": history[3].config["configurable"]["checkpoint_id"]}})

Human-in-the-loop: interrupt-noder och Approvals

Sammanfattat

Human-in-the-loop implementeras med interrupt()-anrop inuti en nod. När grafen når interrupt pausar den, sparar checkpoint och exponerar en pending-status via API:et. Extern tjänst (Slack-bot, Teams-approval, mail) skickar in svaret med Command(resume=<value>) och grafen fortsätter. Alice Labs default för svenska högrisk-agenter i kredit, HR och sjukvård – uppfyller EU AI Act Artikel 14.

Human-in-the-loop är förstaklassare i LangGraph, till skillnad från CrewAI där det måste byggas manuellt. Två primitiver dominerar 2026:

• interrupt() – anropas inuti en nod för att pausa grafen. State sparas i checkpoint; API:et rapporterar status="interrupted". Ni exponerar interrupt-payloaden till er approval-UI (Slack, Teams, custom-web).
• Command(resume=<value>) – skickas in när approver godkänner. Grafen fortsätter från exakt samma state med värdet tillgängligt.

from langgraph.types import interrupt, Command

def approval_node(state: State) -> dict:
    payload = {
        "action": "överföring 500 000 SEK",
        "till": state["recipient"],
        "motivering": state["reason"],
    }
    approval = interrupt(payload)  # pausar grafen här
    if approval["approved"]:
        return {"status": "approved", "actor": approval["actor"]}
    else:
        return {"status": "rejected", "reason": approval["reason"]}

# Resume från extern tjänst
app.invoke(
    Command(resume={"approved": True, "actor": "eric@bank.se"}),
    config={"configurable": {"thread_id": "arende-1337"}}
)

Under EU AI Act Artikel 14 är mänsklig oversight obligatorisk för högrisk-AI-system. interrupt-noder är den tekniska implementationen. Alice Labs standardarkitektur för svensk bank, försäkring och sjukvård har interrupt-gates på alla irreversibla actions (transfer, uppsägning, medicinsk rekommendation). Full compliance-genomgång i vår checklista EU AI Act 2026: checklista för svenska företag.

Subgraphs: kapsla in återanvändbara agent-flöden

Sammanfattat

Subgraph är en LangGraph-graf som kapslas in som en enda nod i föräldragrafen. Rätt val när ett sub-flöde är genuint återanvändbart mellan flera huvudgrafer (t.ex. dokument-parsing, kund-lookup, compliance-check). Skickar och tar emot state via input och output-schemas. Kan även paketera egen checkpointing. Alice Labs använder subgraphs för alla MCP-tool-wrappers och compliance-flöden.

Subgraphs är LangGraphs sätt att bygga återanvändbara agent-moduler. En subgraph är en komplett StateGraph som kompilas och sedan används som en nod i en annan graf. Rätt val i två situationer:

1. Återanvändning mellan huvudgrafer. Ett dokument-parsing-flöde (upload → OCR → structured-extract → validate) återanvänds i tio olika agent-produkter. Bygg det som en subgraph; importera det överallt.
2. Isolation av state. Sub-flödet har sitt eget state-schema som inte ska förorena föräldragrafen. Input- och output-mappers säkerställer att endast relevanta fält passeras in och ut.

# Subgraph för compliance-check
compliance_graph = StateGraph(ComplianceState)
compliance_graph.add_node("check_pii", check_pii_node)
compliance_graph.add_node("check_ai_act", check_ai_act_node)
compliance_graph.add_edge("check_pii", "check_ai_act")
compliance_graph.set_entry_point("check_pii")
compliance_graph.add_edge("check_ai_act", END)
compliance_app = compliance_graph.compile()

# Använd i föräldragraf
parent_graph.add_node("compliance", compliance_app)

Anti-pattern att undvika: bygga subgraph för ett sub-flöde som bara används på ett enda ställe. Overhead i debugging (nested trace-hierarki) blir högre än vinsten. Refaktorisera till subgraph först när återanvändning uppnås två gånger.

Streaming: token, state och event för snabb UX

Sammanfattat

LangGraph stöder streaming i tre lager: (1) token-level för LLM-output i chat-UX, (2) state-level där varje state-transition strömmas för progress-updates, (3) event-level med per-node-diagnostik för debugging. Alla tre används i produktions-UI. Använd astream_events() för moderna React-frontends med Server-Sent Events; astream() räcker för state-level; llm.astream() för ren token-streaming.

Streaming är inte optional i produktions-UX. En agent som tar 20 sekunder på sig utan feedback känns trasig. LangGraph stöder tre streaming-lager:

• Token-level. LLM:ets output streamas token för token till frontend. Rätt för chat-UX. Kräver att modellen stöder streaming (Claude, GPT, Gemini).
• State-level. Varje state-transition (t.ex. "researcher klar", "writer börjar") streamas. Rätt för progress-bars och multi-step-UX.
• Event-level. Per-node-diagnostik: tool-anrop, error, retry. Rätt för debug-panels och observability-vyer.

# Streaming events i FastAPI/React
async for event in app.astream_events(
    {"messages": ["Skriv en rapport"]},
    version="v2",
    config=config,
):
    if event["event"] == "on_chat_model_stream":
        yield f"data: {event['data']['chunk'].content}\n\n"
    elif event["event"] == "on_chain_start":
        yield f"event: node_start\ndata: {event['name']}\n\n"

Production deployment: LangSmith, LangGraph Platform och self-host

Sammanfattat

Tre produktionsalternativ 2026: (1) LangGraph Platform (managed hosting från LangChain, US eller EU), (2) self-host som Docker-container på AWS Frankfurt eller Azure Sweden Central, (3) LangGraph Server on-prem för strikt datakontroll. Alla tre integrerar med LangSmith för tracing, evals, prompt-versionering. Alice Labs default för svensk enterprise: self-host på AWS ECS Frankfurt med LangSmith EU för observability.

Tre produktionsalternativ Alice Labs använder för svensk enterprise 2026:

1. LangGraph Platform. LangChains managed hosting-tjänst. Snabbaste vägen till produktion om ni accepterar hosted deployment. Erbjuder auto-scaling, managed checkpointing (Postgres), och integrerad LangSmith-tracing. EU-region tillgänglig sedan Q1 2026.
2. Self-host på AWS eller Azure. LangGraph-appen paketeras som Docker-container och deployas till AWS ECS/EKS Frankfurt eller Azure Sweden Central. PostgresSaver på RDS för checkpointing. Rekommenderas för svensk bank, försäkring och offentlig sektor där datahemvist är strikt.
3. LangGraph Server on-prem. När data absolut inte får lämna er datacenter. Kräver enterprise-licens från LangChain för full support.

LangSmith är LangChains hosted observability-plattform: trace-per-hop, evaluations, prompt-versionering, regression-tests. Alternativ för open source-preferens: Langfuse (self-hostable, EU-region). Alice Labs kör LangSmith för managed-uppdrag och Langfuse för self-hosted enterprise.

Memory-strategier: short-term, long-term, semantic

Sammanfattat

Tre memory-lager i produktions-LangGraph 2026: (1) short-term thread state via checkpointer (håller konversationshistorik inom en thread), (2) long-term store via BaseStore (delas mellan threads, persistent), (3) semantic memory via vector store (embedded historik som återhämtas kontextuellt). Regel: undvik att stoppa allt i konversationshistorik – summarisera aggressivt och lagra fakta strukturerat i long-term store.

Memory är där de flesta produktions-LangGraph-agenter tappar kvalitet efter några veckor. Tre lager är standard 2026:

• Short-term thread state. Konversationshistorik och working memory inom en enskild thread. Sparas i checkpointer.
• Long-term store. Persistenta fakta som återanvänds mellan threads. LangGraph:s BaseStore-interface med Postgres eller Redis backing. Exempel: "kunden har redan avvisat produkt X", "denna user föredrar svenska".
• Semantic memory. Vector-embedded historik som återhämtas via similarity search. Exempel: "vad diskuterade vi med denna kund senast om kredit?" Använd pgvector, Qdrant eller Pinecone.

from langgraph.store.postgres import PostgresStore

store = PostgresStore.from_conn_string(POSTGRES_URL)
app = graph.compile(checkpointer=checkpointer, store=store)

# Skriv långtidsminne
store.put(
    namespace=("kund", "kund-42"),
    key="preferenser",
    value={"sprak": "svenska", "avvisade_produkter": ["X", "Y"]},
)

# Läs i en nod
def preference_node(state, config, *, store):
    prefs = store.get(("kund", state["kund_id"]), "preferenser")
    return {"preferences": prefs.value if prefs else {}}

Praktisk regel för svenska team: varje agent-tur, extrahera 1–3 strukturerade fakta från konversationen och skriv till long-term store istället för att låta history växa. Detta håller kostnad linjär istället för kvadratisk och gör att agenten "kommer ihåg" saker som är verkligt viktiga.

Tool-use patterns: bind_tools, structured output och MCP

Sammanfattat

LangGraph stöder tool-use på tre nivåer 2026: (1) LangChain bind_tools() för klassiska function calls, (2) structured output via with_structured_output() för deterministisk JSON, (3) MCP-integration för att exponera agentens verktyg som en MCP-server eller konsumera externa MCP-servrar. Alice Labs default: MCP från dag 1 för alla externa verktyg – återanvänds över modellskiften och andra ramverk.

Tool-use är kärnan i vad som gör en agent till en agent. LangGraph erbjuder tre patterns:

• bind_tools() – klassisk LangChain function-calling. Modellen ser en lista tools; om den vill anropa ett verktyg returneras ett tool_call som er tool-executor-nod exekverar.
• with_structured_output() – tvinga modellens svar till en Pydantic eller TypedDict-schema. Deterministisk parsing, ingen JSON-parse-panik.
• MCP-integration – LangGraph konsumerar MCP-servrar via langchain-mcp-adapters och kan även exponera egna agenter som MCP-servrar. Investeringen är modell- och ramverks-oberoende.

from langchain_anthropic import ChatAnthropic
from langgraph.prebuilt import create_react_agent
from langchain_mcp_adapters.tools import load_mcp_tools

llm = ChatAnthropic(model="claude-sonnet-4-5")
mcp_tools = await load_mcp_tools(mcp_client)  # från MCP-server
agent = create_react_agent(llm, mcp_tools)
result = await agent.ainvoke({"messages": [{"role": "user", "content": "Sök i Fortnox"}]})

Djupdykning i MCP: MCP: Model Context Protocol för svenska AI-team. För multi-agent-mönster (supervisor, subgraphs, konsens): Multi-agent-system: guide för svenska AI-team 2026.

LangGraph vs CrewAI vs AutoGen: när vinner LangGraph?

Sammanfattat

LangGraph vinner när flödet har grenar, cycler, HITL-gates eller behöver checkpointing för replay. CrewAI vinner för snabb roll-baserad prototyp av researcher-writer-reviewer-crews. AutoGen vinner för konversationella multi-agent med code-execution och dev-tooling. Alice Labs default för svensk enterprise är LangGraph; för snabba PoCs där HITL inte behövs kan CrewAI vara snabbare till första körning.

De tre dominerande produktions-ramverken 2026 har olika sweet-spots:

Se head-to-head-djupdykningar: LangGraph vs CrewAI, LangGraph vs AutoGen, LangGraph vs Claude Agent SDK. Full svensk ramverks-jämförelse i Bästa AI-agent-ramverken 2026: svensk jämförelse.

Migration från LangChain AgentExecutor till LangGraph

Sammanfattat

LangChain AgentExecutor är deprecated 2026 – all utveckling flyttas till LangGraph. Migration tar typiskt 2–4 veckor per produktions-use-case. Fem steg: (1) mappa AgentExecutor.invoke till StateGraph.invoke, (2) konvertera intermediate_steps till explicit state, (3) lägg till checkpointer, (4) migrera callback-handlers till LangSmith, (5) skriv regression-tests som jämför output mot gyllene baseline. Alice Labs har migrerat 12 produktionsagenter utan att bryta drift.

LangChain AgentExecutor är deprecated sedan LangChain 0.3 och all utveckling flyttas till LangGraph. Alice Labs har migrerat 12 produktionsagenter från AgentExecutor till LangGraph 2025–2026 utan att bryta drift. Fem konkreta steg:

1. Mappa entry point. AgentExecutor.invoke ersätts av StateGraph med prebuilt create_react_agent för ReAct-mönstret.
2. Konvertera intermediate_steps till explicit state. Där ni tidigare läste callback-events, definiera nu ett TypedDict-state med messages, tool_outputs, iteration_count.
3. Lägg till checkpointer. MemorySaver för dev, PostgresSaver för prod. Nu får ni replay och regression-tests gratis.
4. Migrera callbacks till LangSmith. Ta bort custom CallbackHandler-klasser; LangSmith fångar allt automatiskt när LANGCHAIN_TRACING_V2=true.
5. Skriv regression-tests. Bygg gyllene baseline från era 50 viktigaste input-cases; kör dessa i CI-pipeline vid varje release; jämför state-sekvens.

Vanligaste migrationsfelet: att försöka behålla AgentExecutor:s implicita state. Motsätt frestelsen. Explicit state är hela poängen. Extra investering 1–2 dagar betalar sig inom första månaden i felsökningstid.

Alice Labs learnings från 40+ LangGraph-implementationer i Norden

Sammanfattat

Fem learnings från Alice Labs 40+ LangGraph-produktionsagenter 2024–2026: (1) checkpointing först, features sen; (2) håll noder små och testbara; (3) HITL på irreversibla actions, aldrig på bulk-actions; (4) LangSmith från dag 1, inte som eftertanke; (5) modell-tiering per nod. Genomsnittlig time-to-value 5 månader; genomsnittlig felsökningstid 40–60 procent lägre än på AgentExecutor.

Fem konkreta learnings från Alice Labs 40+ LangGraph-produktionsagenter i Norden 2024–2026:

1. Checkpointing först, features sen. Slå på PostgresSaver innan ni lägger till roliga features. Utan checkpointing är felsökning i produktion omöjlig och alla nya features multiplicerar den kostnaden.
2. Håll noder små och testbara. En nod = en tydlig ansvarsdomän. Om noden är svår att unit-testa isolerat, dela den.
3. HITL på irreversibla actions, aldrig på bulk-actions. Approval per överföring: ja. Approval per rad i en batch: nej – bygg batch-approval på hög nivå istället.
4. LangSmith från dag 1. Inte "vi lägger till det senare". Tracing gäller från första prototyp; annars glöms det bort och ni sitter utan data när produktions-buggen kommer.
5. Modell-tiering per nod. Använd Claude Haiku eller GPT-4o-mini för routing- och classification-noder; reservera Sonnet/Opus eller GPT-4 för resonemangs-tunga steg. Typisk kostnadsbesparing: 60–75 procent.

Fördjupning i multi-agent-mönster där LangGraph används som orkestrator: Multi-agent-system: guide för svenska AI-team 2026. Fullständig ramverks-jämförelse: Bästa AI-agent-ramverken 2026: svensk jämförelse.