Pydantic AI guide för svenska Python-team 2026

Vad är Pydantic AI och varför skapades det?

Pydantic AI är ett Python-first, type-safe agent-ramverk från Samuel Colvin och Pydantic-teamet (Pydantic Inc), lanserat november 2024. Version 0.0.14 (september 2026) är produktionsstabil med 8 500+ GitHub-stjärnor och växande adoption i FastAPI- och Django-communityn.

Ramverket löser tre problem som Pydantic-teamet såg när de själva byggde agenter i produktion:

1. Boilerplate för structured output. LangChain kräver Runnable-kedjor, output-parsers och verbose config. Pydantic AI: definiera output som Pydantic-modell och skicka in som output_type.
2. Type-safety i tools. Många ramverk kräver JSON-schema handskriven eller genererad separat. Pydantic AI genererar allt från Python type hints.
3. Testbarhet. Enhet-tester utan LLM-anrop är kritiskt i CI/CD. Pydantic AI TestModel gör deterministiska tester triviala.

Filosofin är samma som Pydantic v2 och FastAPI: type hints är kontraktet. Ramverket gör så lite magi som möjligt utöver det.

För bredare ramverks-överblick, se Bästa AI-agent-ramverken 2026 och pillar-guiden AI-agenter: komplett guide 2026.

Arkitektur: Agent, RunContext, tools, deps, output_type

Sammanfattat

Fem kärnkoncept. Agent: ramverkets huvudobjekt, konfigureras med modell, system prompt, tools, deps_type, output_type. RunContext: körnings-kontext med deps, usage, retry-info. Tools: typade Python-funktioner registrerade via @agent.tool-dekorator. Deps: dependencies injicerade per körning (database, API-klienter). Output_type: Pydantic-modell som slutresultat måste matcha.

Fem kärnkoncept räcker för att förstå Pydantic AI:

• Agent. Huvudobjektet. Konfigureras med modell (str eller Model-instans), system prompt (str eller callable), deps_type (Pydantic-modell för dependencies) och output_type (Pydantic-modell för output).
• RunContext. Passeras in i tools och system prompt-callables. Innehåller deps, usage (token counts) och retry-info.
• Tools. Vanliga Python-funktioner dekorerade med @agent.tool. Parametrar är typade; JSON-schema genereras automatiskt.
• Deps. Dependencies injicerade per körning via agent.run(..., deps=...). Perfekt för database-session, API-klienter, config.
• Output_type. Pydantic-modell (eller union av modeller) som slutresultat måste matcha. Automatisk validation och retry vid fel.

Minimal exempel:

from pydantic import BaseModel
from pydantic_ai import Agent, RunContext

class CompanySummary(BaseModel):
    name: str
    size: str  # "small" | "medium" | "large" | "enterprise"
    industry: str
    latest_news: list[str]

class Deps(BaseModel):
    search_client: object

agent = Agent(
    "anthropic:claude-sonnet-4-5",
    deps_type=Deps,
    output_type=CompanySummary,
    system_prompt="Du sammanfattar företag för svenska CIO:er. Använd search-tool.",
)

@agent.tool
async def web_search(ctx: RunContext[Deps], query: str) -> list[dict]:
    """Sök på webben efter företagsinfo."""
    return await ctx.deps.search_client.search(query)

result = agent.run_sync("Sammanfatta Klarna", deps=Deps(search_client=my_client))
print(result.output)  # CompanySummary (garanterat)

Type-safe agent-outputs: Pydantic-modell som output_type

Sammanfattat

Definiera output som Pydantic-modell och passa som output_type. Pydantic AI genererar automatiskt JSON-schema, instruerar LLM:et att returnera enligt schemat, validerar output vid retur och gör retry om validering misslyckas. Union-typer stöds för flera möjliga outputs. Type hints ger autocompletion i IDE och integration med resten av er FastAPI-stack utan boilerplate.

Structured output är Pydantic AI:s klarhetspunkt. Ni definierar en Pydantic-modell, passar som output_type, och ramverket sköter resten:

1. Genererar JSON-schema från Pydantic-modellen.
2. Instruerar LLM:et (via native function-calling eller tool-schema) att returnera enligt schemat.
3. Validerar returen mot Pydantic-modellen.
4. Retry med error-feedback om validering misslyckas (upp till model_settings.max_retries).
5. Returnerar en typad Pydantic-modell till er kod. Autocompletion i IDE fungerar.

Union-typer för flera möjliga outputs:

from typing import Union
from pydantic import BaseModel
from pydantic_ai import Agent

class ClassifiedAsUrgent(BaseModel):
    priority: str = "urgent"
    reason: str
    escalate_to: str

class ClassifiedAsRoutine(BaseModel):
    priority: str = "routine"
    reason: str
    suggested_action: str

agent = Agent(
    "openai:gpt-4.1",
    output_type=Union[ClassifiedAsUrgent, ClassifiedAsRoutine],
    system_prompt="Klassificera inkommande kundärenden.",
)

result = agent.run_sync("Betalning misslyckades tre gånger, kunden är frustrerad")
if isinstance(result.output, ClassifiedAsUrgent):
    escalate(result.output.escalate_to)

För svenska team på FastAPI-stack: samma Pydantic-modeller kan användas som request- eller response-body i FastAPI-endpoints. Zero boilerplate mellan agent och API.

Tools som typade Python-funktioner

Sammanfattat

Tools definieras som vanliga Python-funktioner dekorerade med @agent.tool. Parametrar är typade; docstring blir tool-beskrivning; JSON-schema genereras automatiskt från type hints. RunContext (om deklarerad som första parameter) ger access till deps, usage och retry-info. Async-tools stöds native. Minimal boilerplate, maximal type-safety.

Tools är där Pydantic AI:s type-safety-ergonomi lyser. Skriv en Python-funktion med typed parametrar, docstring och (valfritt) RunContext, dekorera med @agent.tool, och ramverket sköter resten:

from pydantic_ai import Agent, RunContext
from decimal import Decimal

class Deps(BaseModel):
    fortnox_client: object
    user_id: str

agent = Agent("anthropic:claude-sonnet-4-5", deps_type=Deps)

@agent.tool
async def lookup_invoice(
    ctx: RunContext[Deps],
    invoice_number: str,
) -> dict:
    """Hämta faktura från Fortnox baserat på fakturanummer."""
    return await ctx.deps.fortnox_client.get_invoice(invoice_number)

@agent.tool
async def credit_customer(
    ctx: RunContext[Deps],
    invoice_number: str,
    amount_sek: Decimal,
    reason: str,
) -> dict:
    """Skapa kreditfaktura mot en existerande faktura.

    Kräver approval från senior handläggare för amount_sek > 10 000.
    """
    if amount_sek > 10000:
        # Trigger HITL-approval via extern service
        await request_approval(ctx.deps.user_id, invoice_number, amount_sek)
    return await ctx.deps.fortnox_client.credit(invoice_number, amount_sek, reason)

Nyanser för produktion:

• Async-tools rekommenderas när tool anropar I/O (databas, HTTP). Sync-tools körs i thread pool.
• Docstrings används som tool-beskrivning skickad till LLM:et. Skriv dem för LLM:et som konsument, inte för människor.
• Type hints ska vara så specifika som möjligt. Literal["a", "b"] slår str när set av tillåtna värden är kända.
• MCP-integration finns via pydantic_ai_mcp-paketet 2026. Låter er adoptera MCP-servers utan att skriva om verktygslagret.

Streaming, dependency injection och testing

Sammanfattat

Streaming: agent.run_stream() ger asynkron token-stream; agent.run_stream_structured() ger partial Pydantic-modeller under strömning. Dependency injection: deps passeras per körning, gör tools testbara utan att mocka globala state. Testing: TestModel för deterministiska unit-tests utan LLM-anrop; AgentTestRun för integration; FunctionModel för scriptade beteenden.

Streaming. Två lägen. Token-stream (agent.run_stream) för chat-UX där ni vill visa svar under generering. Structured stream (agent.run_stream_structured) för complex output där partial Pydantic-modeller uppdateras under strömning – perfekt för produktion-UI som behöver progressiva state-updates.

async with agent.run_stream("Sammanfatta Klarna", deps=deps) as result:
    async for chunk in result.stream_text(delta=True):
        yield chunk  # SSE-endpoint i FastAPI

Dependency injection. Deps passeras per körning, inte konfigureras globalt. Gör tools testbara utan att mocka moduler:

# Produktion
result = agent.run_sync(question, deps=Deps(
    fortnox_client=real_fortnox,
    user_id=user.id,
))

# Test
result = agent.run_sync(question, deps=Deps(
    fortnox_client=FakeFortnox(),
    user_id="test-user",
))

Testing. Tre modell-typer för tester:

• TestModel. Returnerar deterministiska outputs baserat på tool- och output-scheman. Perfekt för snabba unit-tests utan LLM-anrop.
• FunctionModel. Ni definierar en Python-funktion som simulerar LLM-beteendet. Bra för scenarios där ni vill testa specifika tool-anrops-sekvenser.
• AgentTestRun. Riktig körning mot LLM med recording. Bra för integration- och regression-tests.

Alice Labs standardpattern för svenska FastAPI-team: TestModel för unit-tests i pytest, AgentTestRun i CI för nightly regression-run, Langfuse för produktions-observability.

FastAPI- och Django-integration för svenska team

Sammanfattat

Pydantic AI är byggt för att kännas hemma i FastAPI: samma Pydantic-modeller för request/response och agent output_type. Django-integration via Django Ninja (Pydantic-baserat) är smärtfri; klassisk Django DRF kräver adapter-lager. Alice Labs default för svensk fintech och life sciences på FastAPI: Pydantic AI som agent-lager, FastAPI som API-lager, samma Pydantic-modeller genomgående.

Svenska Python-team ligger typiskt på en av tre stackar 2026: FastAPI (växande), Django (etablerat) eller Flask (legacy). Pydantic AI-integration:

• FastAPI (native fit). Samma Pydantic-modeller för request-body, response-body och agent output_type. Zero boilerplate. Perfekt för nya svenska fintech-, life sciences- och SaaS-produkter. Alice Labs default för Pydantic AI-adoptioner 2026.
• Django Ninja (rekommenderat för Django-team). Pydantic-baserat API-lager ovanpå Django. Samma modeller för agenter och endpoints. Fungerar lika bra som FastAPI-integrationen.
• Django REST Framework (klassiskt). Serializers vs Pydantic är olika modeller. Adapter-lager krävs (Pydantic-modell till DRF Serializer eller vice versa). Fungerar men mer boilerplate.
• Flask. Rekommenderat att adoptera FastAPI eller Django Ninja vid nästa större rewrite. Legacy Flask fungerar men saknar naturlig Pydantic-fit.

Typiskt svenskt deployment-mönster: FastAPI (eller Django Ninja) endpoint tar emot request, validerar med Pydantic, anropar Pydantic AI-agent, streamar back över SSE till frontend, loggar per-request i Langfuse med user-id och request-id.

Comparison: Pydantic AI vs LangChain, CrewAI och LangGraph

Sammanfattat

Pydantic AI vinner för type-safety och minimal boilerplate. LangChain vinner för ekosystem-bredd (700+ integrationer). CrewAI vinner för roll-baserade multi-agent-crews. LangGraph vinner för komplex state och HITL i produktion. Pydantic AI är rätt när ni redan har Pydantic v2 och FastAPI eller Django Ninja och type-safety väger tyngst.

Se relaterade jämförelser: CrewAI vs LangGraph vs AutoGen, OpenAI Agents SDK vs CrewAI.

Alice Labs val: när Pydantic AI är rätt för svensk enterprise

Sammanfattat

Pydantic AI är Alice Labs default för svenska Python-team med tre kriterier: (a) existerande FastAPI eller Django Ninja i produktion, (b) starkt team-preferens för type-safety, (c) enkla-till-medelkomplexa agent-flöden utan djup HITL. För enterprise med komplex HITL och multi-agent kvarstår LangGraph som vår default.

Alice Labs val 2026:

1. Pydantic AI för svenska Python-team på FastAPI eller Django Ninja där type-safety och testbarhet väger tyngst. Fintech, life sciences, SaaS-produkter. Typiskt scope: single-agent eller enkelt multi-agent med handoffs.
2. LangGraph för svensk enterprise med komplex HITL, compliance-heavy use-cases (bank-KYC, HR-screening, sjukvård), multi-agent-orkestrering med state och observability-krav. Alice Labs default för enterprise.
3. CrewAI för content-crews och sales-research.
4. OpenAI Agents SDK om GPT-stack är låst av strategiska skäl.

Pydantic AI och LangGraph är inte konkurrenter utan komplement. Många Alice Labs-implementationer 2026 har Pydantic-modeller genomgående (från agent-output till FastAPI-response) och LangGraph som orchestrator för komplexa flöden.

Boka arkitekturmöte via AI-agenter för svenska företag så matchar vi rätt ramverk mot ert team och use-case.