I 15 migliori framework Python per creare applicazioni di AI agentica complete

Creare applicazioni di AI agentica oggi è molto più semplice rispetto a pochi anni fa. Invece di sviluppare da zero loop degli agenti, integrazioni con strumenti, memoria, retrieval e orchestrazione, gli sviluppatori possono usare framework Python che offrono già la maggior parte di questi componenti.

Ho utilizzato molti dei framework citati in questo articolo per creare applicazioni RAG, agenti autonomi, sistemi multi‑agente e strumenti di AI distribuibili.

Uso spesso LangChain per workflow di agenti flessibili, LlamaIndex e Haystack per applicazioni connesse ai dati e l’OpenAI Agents SDK o Google ADK quando voglio un’integrazione più rapida con i modelli del provider.

Alcuni di questi framework sono migliorati così tanto che spesso non serve più creare una soluzione personalizzata. Con una chiave API, qualche credito modello e il framework giusto, puoi creare un agente, collegarlo a strumenti o dati privati, testarlo e distribuirlo tramite un’API o un’interfaccia utente.

Questo articolo confronta 15 framework Python in cinque categorie: framework agent generici, SDK ufficiali per agenti, framework di orchestrazione multi‑agente, framework per dati e RAG, e framework leggeri per modelli open.

Ogni sezione include anche un breve esempio in Python che puoi copiare, incollare e testare per capire rapidamente come funziona il framework.

Framework agent generici

Questi framework offrono blocchi di base per creare agenti, collegare strumenti, gestire lo stato e controllare workflow multi‑step.

1. LangChain

Per molti sviluppatori, lo sviluppo moderno di applicazioni basate su LLM è iniziato con LangChain, un framework Python open‑source progettato per connettere i modelli linguistici a dati esterni, strumenti, API e logica applicativa. È stato uno dei primi framework ampiamente adottati per usare l’API di OpenAI con siti web, documenti, database vettoriali e altre fonti di dati per creare applicazioni più consapevoli del contesto.

Oggi LangChain è diventato un ecosistema completo per creare applicazioni di AI agentica end‑to‑end, inclusi sistemi RAG, agenti che usano strumenti, workflow, integrazioni, monitoraggio e valutazione. Ti consiglio di dare un’occhiata al percorso AI Engineering with LangChain per saperne di più.

L’esempio seguente crea un semplice agente LangChain che può usare uno strumento di ricerca nella documentazione per trovare informazioni pertinenti prima di rispondere a una domanda.

# pip install -U langchain "langchain[openai]"

from langchain.agents import create_agent

def search_docs(query: str) -> str:
    """Search the company documentation."""
    return f"Documentation found for: {query}"

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[search_docs],
    system_prompt="Use the documentation tool when needed.",
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "What is our remote-work policy?"
    }]
})

print(result["messages"][-1].content)

2. LangGraph

Mentre LangChain semplifica la creazione di agenti e strumenti, LangGraph offre un controllo maggiore su come operano quegli agenti. Permette agli sviluppatori di strutturare un’applicazione come un grafo di passaggi collegati, rendendo più semplice controllare loop, chiamate agli strumenti, stato condiviso, approvazioni umane e workflow multi‑agente.

Lo trovo particolarmente utile quando costruisco agenti autonomi che devono decidere ripetutamente cosa fare, scegliere lo strumento giusto, verificare il risultato e continuare finché il compito non è completato. LangGraph supporta anche persistenza, streaming, checkpoint e recovery per applicazioni di lunga durata. Il nostro tutorial su LangGraph offre maggiori dettagli.

L’esempio seguente crea un agente che può chiamare ripetutamente strumenti di calcolo finché non ha informazioni sufficienti per rispondere:

# pip install -U langgraph langchain langchain-openai

from langchain.chat_models import init_chat_model
from langchain.tools import tool
from langgraph.graph import MessagesState, StateGraph, START
from langgraph.prebuilt import ToolNode, tools_condition

model = init_chat_model("openai:gpt-5.5", temperature=0)

@tool
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

tools = [add, multiply]
model_with_tools = model.bind_tools(tools)

def call_model(state: MessagesState):
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}

builder = StateGraph(MessagesState)
builder.add_node("agent", call_model)
builder.add_node("tools", ToolNode(tools))

builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tools_condition)
builder.add_edge("tools", "agent")

agent = builder.compile()

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "Add 12 and 8, then multiply the result by 3."
    }]
})

print(result["messages"][-1].content)

Il grafo invia la richiesta al modello, esegue gli strumenti necessari e torna al modello finché non produce una risposta finale.

3. Agno

Agno è un framework Python per creare agenti, team multi‑agente e workflow strutturati. Include anche AgentOS, che aiuta gli sviluppatori a esporre agenti tramite API, archiviare sessioni e tracce e gestirli come applicazioni di produzione. Poiché può essere eseguito sulla tua infrastruttura, le organizzazioni mantengono un controllo maggiore su dati e sicurezza.

L’esempio seguente crea un agente di ricerca che può cercare sul web prima di produrre una risposta concisa.

# pip install -U agno ddgs openai

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    name="AI Research Assistant",
    model=OpenAIResponses(id="gpt-5.5"),
    tools=[DuckDuckGoTools()],
    instructions="Search when needed and keep the answer concise.",
)

agent.print_response(
    "Find one recent development in open-source AI and summarize it.",
    stream=True,
)

L’agente usa lo strumento di ricerca per trovare informazioni aggiornate e trasmette in streaming un breve riassunto all’utente.

4. Pydantic AI

Pydantic AI è un framework Python‑native del team di Pydantic per creare agenti e applicazioni di AI generativa. Ricorda il lavoro con i modelli Pydantic o FastAPI perché agenti, strumenti, dipendenze e output sono definiti con funzioni Python standard, type hint, decorator e classi BaseModel. Usa poi la validazione Pydantic per mantenere strutturati e affidabili gli argomenti degli strumenti e gli output del modello.

Posso consigliare il tutorial su Pydantic AI per approfondire il framework.

L’esempio seguente crea un agente che restituisce un piano articolo validato come modello Pydantic.

# pip install -U pydantic-ai

from pydantic import BaseModel, Field
from pydantic_ai import Agent


class ArticlePlan(BaseModel):
    title: str
    key_points: list[str]
    reading_time_minutes: int = Field(ge=1)


agent = Agent(
    "openai:gpt-5.6-sol",
    output_type=ArticlePlan,
    instructions="Create concise article plans for technical readers.",
)

result = agent.run_sync(
    "Create a short article plan about building AI agents in Python."
)

print(result.output)

L’agente genera un oggetto ArticlePlan e verifica che ogni campo rispetti il tipo Python richiesto e le regole prima di restituirlo.

SDK ufficiali per agenti

Gli SDK ufficiali per agenti sono mantenuti dai provider di AI e solitamente offrono l’integrazione più semplice con i loro modelli, API, strumenti, sistemi di deployment e piattaforme di osservabilità.

5. OpenAI Agents SDK

L’OpenAI Agents SDK è un framework leggero, Python‑first per creare applicazioni a singolo agente e multi‑agente. Fornisce un loop agente integrato, function tools, handoff, guardrail, sessioni, approvazioni umane e tracing senza aggiungere troppe astrazioni.

Adoro usare l’OpenAI Agents SDK perché è semplice, veloce da integrare e facile da capire. Ho creato molte applicazioni con esso senza grandi problemi. Crea anche automaticamente tracce visualizzabili nella Dashboard di OpenAI, facilitando l’ispezione delle risposte del modello, delle chiamate agli strumenti, degli handoff e dell’intero flusso di esecuzione.

L’esempio seguente crea un agente di storia che può chiamare una funzione Python per recuperare un fatto storico sorprendente.

# pip install openai-agents

import asyncio
from agents import Agent, Runner, function_tool


@function_tool
def history_fun_fact() -> str:
    """Return a surprising historical fact."""
    return "The first computer programmer, Ada Lovelace, lived in the 1800s."


agent = Agent(
    name="History Assistant",
    instructions=(
        "Answer history questions clearly and briefly. "
        "Use history_fun_fact when it is helpful."
    ),
    tools=[history_fun_fact],
)


async def main():
    result = await Runner.run(
        agent,
        "Tell me something surprising about the history of computing.",
    )
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

L’SDK esegue l’agente, chiama lo strumento di storia quando necessario, restituisce il suo risultato al modello e produce la risposta finale. L’intera esecuzione può anche essere ispezionata tramite il visualizzatore di tracce.

7. Google Agent Development Kit

L’Agent Development Kit di Google, o ADK, è un framework open‑source per creare, valutare e distribuire agenti singoli, assistenti che usano strumenti, workflow a grafo e sistemi multi‑agente. Funziona particolarmente bene con i modelli Gemini, pur supportando anche altri provider di modelli.

ADK è diventato uno dei miei framework preferiti perché è semplice e lavora in modo naturale con Gemini.

L’ho usato per creare diverse applicazioni senza grandi problemi. Sebbene trovi ancora l’OpenAI Agents SDK più facile da integrare e più flessibile in termini di controlli e funzionalità integrate, ADK è un’ottima alternativa ed è particolarmente competitivo per applicazioni basate su Gemini.

L’esempio seguente crea un assistente per eventi che può chiamare una funzione Python per recuperare l’orario di inizio di un evento.

# pip install google-adk

from google.adk.agents.llm_agent import Agent


def get_event_time(city: str) -> dict:
    """Return the event starting time for a city."""
    return {
        "status": "success",
        "city": city,
        "time": "6:00 PM",
    }


root_agent = Agent(
    model="gemini-flash-latest",
    name="event_assistant",
    description="Provides information about events in different cities.",
    instruction=(
        "Answer event questions clearly. "
        "Use the get_event_time tool when the starting time is requested."
    ),
    tools=[get_event_time],
)

L’agente usa la funzione come strumento ogni volta che deve recuperare l’orario dell’evento per una città specifica.

8. Claude Agent SDK

Il Claude Agent SDK è il framework Python e TypeScript di Anthropic per creare agenti autonomi usando lo stesso loop, gli strumenti e la gestione del contesto che alimentano Claude Code. È particolarmente utile per agenti che devono leggere file, modificare codice, eseguire comandi, connettersi a strumenti MCP e portare a termine compiti più lunghi.

Anthropic, OpenAI e Google integrano strettamente i loro modelli con i rispettivi framework per agenti, rendendo rapido configurare strumenti, sessioni, tracing e altre funzionalità avanzate.

Tuttavia, il Claude Agent SDK è progettato specificamente per Claude piuttosto che per modelli open‑source arbitrari o ospitati in locale. Puoi saperne di più nel nostro tutorial su Claude Agent SDK.

L’esempio seguente crea un agente di coding che esamina un file Python, identifica bug e li corregge automaticamente.

# pip install claude-agent-sdk

import asyncio
from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ResultMessage,
    query,
)


async def main():
    async for message in query(
        prompt="Review app.py for errors that could cause crashes and fix them.",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Glob"],
            permission_mode="acceptEdits",
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if hasattr(block, "text"):
                    print(block.text)
                elif hasattr(block, "name"):
                    print(f"Tool used: {block.name}")

        elif isinstance(message, ResultMessage):
            print(f"Completed: {message.subtype}")


if __name__ == "__main__":
    asyncio.run(main())

L’SDK esegue il loop dell’agente mentre Claude legge il file, seleziona gli strumenti necessari, modifica il codice e trasmette in streaming l’avanzamento finché il compito non è completo.

Framework di orchestrazione multi‑agente

I framework multi‑agente coordinano diversi agenti specializzati, con a ciascuno assegnato un ruolo, un obiettivo, un set di strumenti o una fase in un workflow più ampio. 

9. CrewAI

CrewAI è un popolare framework Python per creare team multi‑agente. Gli sviluppatori possono creare agenti con ruoli, obiettivi e task differenti, quindi combinarli in una crew che lavora insieme in autonomia. I task possono essere eseguiti in sequenza o tramite un processo gerarchico in cui un manager coordina e delega il lavoro agli agenti più adatti.

Il seguente esempio Python crea un researcher e uno writer che collaborano per produrre un breve report.

# pip install crewai
# Set OPENAI_API_KEY before running

from crewai import Agent, Crew, Process, Task

researcher = Agent(
    role="AI Researcher",
    goal="Find the key facts about {topic}",
    backstory="You research technical topics carefully.",
)

writer = Agent(
    role="Technical Writer",
    goal="Turn research into a clear summary",
    backstory="You explain complex topics simply.",
)

research_task = Task(
    description="Research {topic} and identify three key findings.",
    expected_output="Three concise findings.",
    agent=researcher,
)

writing_task = Task(
    description="Write a short summary using the research findings.",
    expected_output="A clear one-paragraph report.",
    agent=writer,
    context=[research_task],
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
)

result = crew.kickoff(inputs={"topic": "agentic AI"})
print(result.raw)

Il ricercatore completa il primo task e lo scrittore usa il suo output come contesto per creare il report finale.

10. MetaGPT

MetaGPT è un framework multi‑agente che modella un’azienda software usando agenti specializzati come product manager, architect, project manager e engineer. Questi agenti seguono procedure operative strutturate per trasformare un breve requisito in piani, design tecnici, documentazione e codice funzionante. 

L’esempio seguente crea un team software e gli chiede di sviluppare un semplice task manager da riga di comando.

# pip install metagpt
# Configure a supported LLM API before running

import asyncio

from metagpt.roles import (
    Architect,
    Engineer,
    ProductManager,
    ProjectManager,
)
from metagpt.team import Team


async def startup(idea: str):
    company = Team()

    company.hire([
        ProductManager(),
        Architect(),
        ProjectManager(),
        Engineer(),
    ])

    company.invest(investment=3.0)
    company.run_project(idea=idea)

    await company.run(n_round=5)


if __name__ == "__main__":
    asyncio.run(
        startup("Build a simple command-line task manager")
    )

Gli agenti suddividono i requisiti tra i diversi ruoli e collaborano per pianificare e sviluppare il progetto software. 

11. AgentScope

AgentScope è un framework Python per creare agenti e applicazioni multi‑agente controllabili e osservabili. Fornisce agenti pronti all’uso, strumenti, memoria, instradamento dei messaggi, streaming, chiamate a strumenti in parallelo, workflow, tracing e intervento umano. AgentScope Studio può anche essere usato per ispezionare e visualizzare l’esecuzione degli agenti.

L’esempio seguente crea un agente ReAct che può scrivere ed eseguire codice Python per completare un calcolo.

# pip install agentscope
# Set DASHSCOPE_API_KEY before running

import asyncio
import os

from agentscope.agent import ReActAgent
from agentscope.formatter import DashScopeChatFormatter
from agentscope.memory import InMemoryMemory
from agentscope.message import Msg
from agentscope.model import DashScopeChatModel
from agentscope.tool import Toolkit, execute_python_code


async def main():
    toolkit = Toolkit()
    toolkit.register_tool_function(execute_python_code)

    agent = ReActAgent(
        name="Nova",
        sys_prompt="You are a helpful Python assistant named Nova.",
        model=DashScopeChatModel(
            model_name="qwen-max",
            api_key=os.environ["DASHSCOPE_API_KEY"],
            stream=True,
        ),
        formatter=DashScopeChatFormatter(),
        toolkit=toolkit,
        memory=InMemoryMemory(),
    )

    await agent(
        Msg(
            name="user",
            content="Use Python to calculate the sum of numbers from 1 to 100.",
            role="user",
        )
    )


if __name__ == "__main__":
    asyncio.run(main())

L’agente decide di chiamare lo strumento di esecuzione Python, esegue il codice generato e usa il risultato per rispondere all’utente.

12. CAMEL-AI

CAMEL-AI è un framework Python open‑source per creare agenti, società multi‑agente e simulazioni di role‑playing. Ha una forte impronta di ricerca e fornisce componenti per collaborazione tra agenti, strumenti, memoria, retrieval, generazione di dati e simulazione di mondi. Supporta anche modelli cloud e modelli eseguiti in locale tramite piattaforme come Ollama, vLLM e SGLang.

L’esempio seguente crea un agente che può cercare sul web prima di rispondere a una domanda.

# pip install "camel-ai[web_tools]"
# Set OPENAI_API_KEY before running

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.toolkits import SearchToolkit
from camel.types import ModelPlatformType, ModelType

model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_5_5,
    model_config_dict={"temperature": 0.0},
)

agent = ChatAgent(
    system_message="You are a helpful AI research assistant.",
    model=model,
    tools=[SearchToolkit().search_duckduckgo],
)

response = agent.step(
    "What are the main uses of multi-agent AI systems?"
)

print(response.msgs[0].content)

L’agente usa la ricerca DuckDuckGo quando ha bisogno di informazioni aggiornate e poi restituisce la risposta finale.

Framework per dati e RAG

Questi framework aiutano a collegare LLM e agenti a documenti, database, API e altre fonti di dati privati, così da poter recuperare contesto pertinente prima di rispondere.

13. LlamaIndex

LlamaIndex è un framework Python per creare applicazioni consapevoli del contesto su dati privati o specifici di dominio. Fornisce connettori, indici, retriever, motori di query, agenti e workflow per applicazioni come RAG, enterprise search e assistenti ai documenti.

LlamaIndex è stato uno dei miei framework preferiti quando ho iniziato a creare applicazioni RAG. Caricare, indicizzare e interrogare i dati è estremamente semplice, e spesso trovo il suo codice più pulito e breve rispetto a creare la stessa applicazione con LangChain. Puoi seguire il corso LlamaIndex per saperne di più.

L’esempio seguente carica documenti da una cartella, crea un indice ricercabile e risponde a una domanda usando il contesto recuperato.

# pip install llama-index
# Set OPENAI_API_KEY before running

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query(
    "What are the main findings in these documents?"
)

print(response)

LlamaIndex indicizza i file nella cartella data e recupera informazioni pertinenti prima di generare la risposta.

14. Haystack

Haystack è un framework Python open‑source per creare pipeline RAG pronte per la produzione, sistemi di ricerca semantica, agenti e applicazioni di AI orientate ai dati. La sua struttura modulare a pipeline offre un controllo chiaro su come le informazioni vengono recuperate, aggiunte al prompt e inviate a un modello.

Ho usato Haystack per creare applicazioni RAG e multi‑agente senza grandi problemi. Sebbene sia un framework generico, è particolarmente utile per applicazioni che collegano gli LLM a documenti, testo, sistemi di ricerca e altre fonti di dati.

L’esempio seguente archivia alcuni documenti, recupera quello più pertinente e lo usa per rispondere a una domanda.

# pip install -U haystack-ai
# Set OPENAI_API_KEY before running

from haystack import Document, Pipeline
from haystack.components.builders import ChatPromptBuilder
from haystack.components.generators.chat import (
    OpenAIResponsesChatGenerator,
)
from haystack.components.retrievers import InMemoryBM25Retriever
from haystack.dataclasses import ChatMessage
from haystack.document_stores.in_memory import InMemoryDocumentStore

document_store = InMemoryDocumentStore()
document_store.write_documents([
    Document(content="The London AI event starts at 6:00 PM."),
    Document(content="The Berlin AI event starts at 7:00 PM."),
])

template = [
    ChatMessage.from_system(
        "Answer using the following documents:\n"
        "{% for doc in documents %}{{ doc.content }}{% endfor %}"
    ),
    ChatMessage.from_user("{{ question }}"),
]

pipeline = Pipeline()
pipeline.add_component(
    "retriever",
    InMemoryBM25Retriever(document_store),
)
pipeline.add_component(
    "prompt_builder",
    ChatPromptBuilder(template=template),
)
pipeline.add_component(
    "llm",
    OpenAIResponsesChatGenerator(model="gpt-5.5"),
)

pipeline.connect("retriever", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

question = "When does the London AI event start?"

result = pipeline.run({
    "retriever": {"query": question},
    "prompt_builder": {"question": question},
})

print(result["llm"]["replies"][0].text)

Haystack recupera il documento corrispondente, lo aggiunge al prompt e usa GPT‑5.5 per produrre una risposta fondata sul contesto.

Framework leggeri e per modelli open

Questi framework offrono astrazioni più semplici per creare agenti con modelli open ospitati o in esecuzione locale.

15. Hugging Face smolagents

Hugging Face smolagents è un framework Python leggero per creare agenti con pochissimo codice. Il CodeAgent agisce scrivendo Python, mentre il ToolCallingAgent usa chiamate a strumenti strutturate. Funziona particolarmente bene con i modelli di Hugging Face, gli Inference Provider e i modelli open‑source ospitati in locale.

L’esempio seguente crea un agente di ricerca web e lo affida a un agente manager che decide quando delegare la ricerca.

# pip install -U "smolagents[toolkit]"
# Set HF_TOKEN before running

from smolagents import (
    CodeAgent,
    InferenceClientModel,
    ToolCallingAgent,
    WebSearchTool,
)

model = InferenceClientModel(
    model_id="Qwen/Qwen3-Next-80B-A3B-Thinking"
)

web_agent = ToolCallingAgent(
    tools=[WebSearchTool()],
    model=model,
    name="web_search_agent",
    description="Searches the web and returns useful information.",
)

manager_agent = CodeAgent(
    tools=[],
    model=model,
    managed_agents=[web_agent],
)

result = manager_agent.run(
    "Who created Hugging Face, and when was it founded?"
)

print(result)

Il manager decide quando ha bisogno di informazioni aggiornate, delega la ricerca all’agente web specializzato e poi produce la risposta finale.

Confronto rapido dei framework

La tabella seguente confronta il punto di forza principale di ciascun framework e il tipo di applicazione di AI agentica per cui è più adatto.

Considerazioni finali

Se stai iniziando ora con l’AI agentica, partirei da un SDK ufficiale come l’OpenAI Agents SDK, Google ADK o Claude Agent SDK. Lavorano a stretto contatto con i loro modelli e API, quindi la configurazione è di solito semplice. Aggiungi una chiave API, carichi qualche credito e inizi a costruire.

Mi piacciono questi SDK perché rendono facile creare agenti, collegare strumenti e ispezionare cosa è successo durante un run. Con poche righe di Python puoi costruire un agente utile o persino un piccolo sistema multi‑agente.

Quando mi serve più flessibilità, di solito guardo a LangChain o LangGraph. LangChain è utile quando ho bisogno di molte integrazioni, mentre LangGraph mi dà più controllo su stato, loop e workflow più lunghi.

Per team di agenti con ruoli diversi, CrewAI è una buona opzione. Per RAG, documenti privati e applicazioni connesse ai dati, sceglierei LlamaIndex o Haystack.

Infine, smolagents è una buona scelta quando voglio qualcosa di leggero, semplice e facile da usare con modelli open o locali.

Il mio consiglio è di iniziare con il framework più semplice che si adatta al tuo progetto. Costruisci una versione piccola, testala bene e aggiungi complessità solo quando ne hai davvero bisogno.