Confronto tra Agent SDK – Una Guida Avanzata con Esempi Pratici

Introduzione agli Agent SDK

L’emergere di agenti autonomi alimentati dall’IA ha trasformato il nostro modo di pensare alle applicazioni software. Questi agenti, capaci di comprendere, ragionare e agire in modo indipendente o semi-indipendente, promettono un futuro di sistemi altamente intelligenti e automatizzati. Al centro della costruzione di tali agenti ci sono i Kit di Sviluppo Software per Agenti (SDK). Un Agent SDK fornisce gli strumenti fondamentali, le librerie e i framework necessari per progettare, sviluppare, distribuire e gestire agenti IA. Questa guida avanzata esplorerà un’analisi comparativa dei popolari Agent SDK, concentrandosi sulla loro architettura, funzionalità avanzate, casi d’uso pratici e fornendo esempi di codice per illustrare i loro punti di forza e di debolezza. Esploreremo SDK di rilievo come LangChain, AutoGen, LlamaIndex, e discuteremo delle alternative emergenti.

Componenti Fondamentali di un Agent SDK

Prima di esplorare specifici SDK, è fondamentale comprendere i componenti architettonici comuni che forniscono:

• Integrazione LLM: Facilita la connessione fluida con vari Modelli di Linguaggio Ampio (LLM) (ad es., modelli OpenAI, Anthropic, Hugging Face).
• Gestione dei Prompt: Strumenti per costruire, templare e gestire i prompt per un’interazione ottimale con i LLM.
• Chiamata a Strumenti/Funzioni: Meccanismi per consentire agli agenti di interagire con API esterne, database o funzioni personalizzate per estendere le loro capacità.
• Gestione della Memoria: Sistemi per consentire agli agenti di mantenere il contesto, la cronologia delle conversazioni e le informazioni apprese durante le interazioni.
• Pianificazione e Ragionamento: Framework per consentire agli agenti di scomporre compiti complessi, pianificare i passaggi esecutivi e ragionare sugli esiti (ad es., ReAct, CoT).
• Orchestrazione degli Agenti: Strumenti per definire sistemi multi-agente, gestire la comunicazione e coordinare i compiti tra gli agenti.
• Osservabilità e Debugging: Funzionalità per monitorare il comportamento degli agenti, tracciare i percorsi di esecuzione e risolvere problemi.
• Distribuzione e Scalabilità: Considerazioni e strumenti per distribuire agenti in ambienti di produzione e scalarli.

LangChain: Il Coltellino Svizzero dello Sviluppo degli Agenti

LangChain è senza dubbio l’Agent SDK più ampiamente adottato e completo. È noto per la sua modularità e le ampie integrazioni, rendendolo una scelta potente per flussi di lavoro complessi degli agenti.

Architettura e Concetti Fondamentali

L’architettura di LangChain è costruita attorno a diverse astrazioni fondamentali:

• LLM/ChatModels: Interfacce per interagire con vari fornitori di LLM.
• Prompt: Modelli per generare input per i LLM.
• Chains: Sequenze di chiamate a LLM o ad altre utilità.
• Agent: LLM potenziati con strumenti per interagire con il loro ambiente. Utilizzano un ‘loop di ragionamento’ (ad es., ReAct) per decidere quale strumento utilizzare.
• Tools: Funzioni che un agente può chiamare per eseguire azioni specifiche.
• Memory: Memorizza interazioni passate per fornire contesto.
• Retrievers: Componenti per recuperare documenti da una base di conoscenza.
• VectorStores: Database per memorizzare vettori di embedding.

Funzionalità Avanzate e Esempio Pratico (Agente ReAct con Strumento Personalizzato)

LangChain eccelle nella creazione di agenti sofisticati con utilizzo di strumenti personalizzati e ragionamento complesso. Costruiamo un agente LangChain che possa rispondere a domande sui prezzi delle azioni attuali utilizzando uno strumento personalizzato e poi riassumere le notizie relative all’azienda.

Esempio: Agente Prezzo delle Azioni e Notizie

Per prima cosa, definiamo uno strumento personalizzato per recuperare i prezzi delle azioni:

from langchain.tools import BaseTool
from typing import Type
from pydantic import BaseModel, Field
import yfinance as yf

class StockPriceInput(BaseModel):
 ticker: str = Field(description="Il simbolo del ticker azionario (ad es., MSFT per Microsoft).")

class StockPriceTool(BaseTool):
 name = "get_stock_price"
 description = "Utile per ottenere il prezzo attuale delle azioni di un'azienda."
 args_schema: Type[BaseModel] = StockPriceInput

 def _run(self, ticker: str) -> str:
 try:
 stock = yf.Ticker(ticker)
 current_price = stock.history(period="1d")["Close"].iloc[-1]
 return f"Il prezzo corrente di {ticker} è ${current_price:.2f}"
 except Exception as e:
 return f"Impossibile recuperare il prezzo delle azioni per {ticker}: {e}"

 async def _arun(self, ticker: str) -> str:
 raise NotImplementedError("Async non implementato per StockPriceTool")

Successivamente, ci integriamo con un’API di notizie (ad es., NewsAPI.org – assicurati di avere una chiave API) come altro strumento. Per brevità, utilizzeremo una funzione segnaposto per il recupero delle notizie:

from langchain.tools import tool

@tool
def get_company_news(company_name: str) -> str:
 """Utile per ottenere i titoli delle notizie recenti per un dato nome di azienda."""
 # In uno scenario reale, questo chiamerebbe un'API di notizie
 if "Microsoft" in company_name:
 return "Notizie recenti su Microsoft: Annuncia una nuova partnership con l'IA, Gli utili superano le aspettative."
 elif "Apple" in company_name:
 return "Notizie recenti su Apple: Vendite di Vision Pro forti, si vocifera di un nuovo lancio di iPhone."
 else:
 return f"Nessuna notizia recente trovata per {company_name}."

Ora creiamo l’agente:

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub

# Inizializza LLM
llm = ChatOpenAI(temperature=0, model="gpt-4-turbo-preview") # oppure gpt-3.5-turbo

# Definisci gli strumenti che l'agente può utilizzare
tools = [StockPriceTool(), get_company_news]

# Ottieni il template prompt ReAct da LangChain Hub
prompt = hub.pull("hwchase17/react")

# Crea l'agente ReAct
agent = create_react_agent(llm, tools, prompt)

# Crea l'Executor dell'Agente
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# Esegui l'agente
print(agent_executor.invoke({"input": "Qual è il prezzo corrente delle azioni di Apple e quali sono le ultime notizie su di loro?"}))
# Output atteso (troncato per brevità):
# > Entrando nella nuova catena AgentExecutor...
# Pensiero: Devo prima trovare il prezzo delle azioni di Apple, poi cercare notizie su di loro.
# Azione: get_stock_price
# Input Azione: AAPL
# Osservazione: Il prezzo corrente di AAPL è $xxx.xx
# Pensiero: Ora ho il prezzo delle azioni. Devo ottenere le notizie per Apple.
# Azione: get_company_news
# Input Azione: Apple
# Osservazione: Notizie recenti su Apple: Vendite di Vision Pro forti, si vocifera di un nuovo lancio di iPhone.
# Pensiero: Ho sia il prezzo delle azioni che le notizie per Apple. Posso ora fornire una risposta dettagliata.
# Risposta Finale: Il prezzo corrente delle azioni di Apple è $xxx.xx. Le notizie recenti su Apple includono vendite forti di Vision Pro e voci su un nuovo lancio di iPhone.

Questo esempio mette in evidenza la capacità di LangChain di orchestrare più strumenti all’interno di un sofisticato loop di ragionamento (ReAct), rendendolo ideale per compiti che richiedono decisioni dinamiche.

Punti di Forza e di Debolezza

• Punti di Forza: Estremamente flessibile e modulare, vasta ecosistema di integrazioni (LLM, vector stores, strumenti), forte supporto della comunità, eccellente per ragionamenti complessi e multi-step.
• Punti di Debolezza: Può avere una curva di apprendimento ripida, il codice boilerplate può accumularsi, il debugging delle prestazioni può essere difficile in catene complesse.

AutoGen: Conversazioni Multi-Agente e Orchestrazione

AutoGen di Microsoft si concentra sulle conversazioni multi-agente, consentendo agli sviluppatori di costruire sistemi in cui più agenti collaborano per risolvere compiti. Sottolinea la flessibilità nella definizione dei ruoli degli agenti e nei modelli di comunicazione.

Architettura e Concetti Fondamentali

I concetti fondamentali di AutoGen ruotano attorno a:

• Agenti: I blocchi fondamentali. Possono essere alimentati da LLM (ConversableAgent) o agire come proxy umani (UserProxyAgent).
• Conversations: Gli agenti comunicano inviando messaggi l’uno all’altro.
• GroupChat: Facilita le conversazioni tra più agenti in modo strutturato.
• Esecuzione di Codice: Gli agenti possono eseguire codice localmente o in un container Docker.

Funzionalità Avanzate e Esempio Pratico (Generazione e Revisione di Codice)

AutoGen eccelle negli scenari in cui un compito si suddivide naturalmente in sotto-compiti che richiedono diverse competenze, simulati da agenti diversi. Creiamo un semplice sistema multi-agente per la generazione e la revisione di codice.

Esempio: Generatore e Revisore di Codice Python

import autogen

# Configura LLM (assicurati di avere OPENAI_API_KEY impostato nelle variabili di ambiente)
config_list = autogen.config_list_openai_aoai(exclude="aoai")

# Crea un UserProxyAgent per agire come interfaccia umana
user_proxy = autogen.UserProxyAgent(
 name="User_Proxy",
 human_input_mode="NEVER", # Imposta su "ALWAYS" per il debug interattivo
 max_consecutive_auto_reply=10,
 is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
 code_execution_config={
 "work_dir": "coding", 
 "use_docker": False # Imposta su True per un'esecuzione isolata
 },
)

# Crea un AssistantAgent per generare codice
coder = autogen.AssistantAgent(
 name="Coder",
 llm_config={"config_list": config_list},
 system_message="Sei un programmatore Python utile. Scrivi codice Python pulito ed efficiente."
)

# Crea un altro AssistantAgent per la revisione e il collaudo del codice
reviewer = autogen.AssistantAgent(
 name="Reviewer",
 llm_config={"config_list": config_list},
 system_message="Sei un revisore di codice. Revisiona il codice Python fornito per correttezza, efficienza e bug. Suggerisci miglioramenti e scrivi casi di test se necessario."
)

# Crea un GroupChat per orchestrare la conversazione
groupchat = autogen.GroupChat(
 agents=[user_proxy, coder, reviewer],
 messages=[],
 max_round=15,
 speaker_selection_method="auto" # Lascia che AutoGen decida chi parla dopo
)

# Crea un GroupChatManager per gestire la chat di gruppo
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config={"config_list": config_list})

# Inizia la conversazione
user_proxy.initiate_chat(
 manager,
 message="Scrivi una funzione Python che calcoli efficientemente il numero di Fibonacci n-esimo. Il revisore lo controllerà e suggerirà test."
)

# Output previsto (semplificato e troncato):
# User_Proxy (a manager): Scrivi una funzione Python...
# Coder (a manager): Ecco il codice:
# ```python
# def fibonacci(n):
# if n <= 0: return 0
# elif n == 1: return 1
# else:
# a, b = 0, 1
# for _ in range(2, n + 1):
# a, b = b, a + b
# return b
# ```
# Reviewer (a manager): Sembra buono, efficiente utilizzando un approccio iterativo. Ecco un caso di test:
# ```python
# # test_fibonacci.py
# import pytest
# from your_module import fibonacci # Supponendo che il codice sia salvato in un modulo

# def test_fibonacci_zero(): assert fibonacci(0) == 0
# def test_fibonacci_one(): assert fibonacci(1) == 1
# def test_fibonacci_small_numbers():
# assert fibonacci(2) == 1
# assert fibonacci(3) == 2
# assert fibonacci(5) == 5
# def test_fibonacci_large_number():
# assert fibonacci(10) == 55
# ```
# User_Proxy (a manager): TERMINATE

Questo esempio dimostra come AutoGen faciliti un flusso di lavoro collaborativo, con agenti che assumono ruoli distinti e scambiano messaggi per raggiungere un obiettivo comune. L'UserProxyAgent può persino eseguire il codice generato se configurato per farlo.

Forze e Debolezze

• Forze: Eccellente per la collaborazione multi-agente, orchestrazione dei compiti guidata dal linguaggio naturale, solide capacità di esecuzione del codice, intuitivo per costruire agenti conversazionali.
• Debolezze: Meno enfasi sul ragionamento interno complesso degli agenti (come ReAct per singolo agente), può essere meno diretto per flussi di lavoro sequenziali profondamente annidati rispetto alle catene di LangChain, gestire flussi di conversazione complessi può diventare complicato.

LlamaIndex: Integrazione dei Dati per LLM

Sebbene non sia strettamente un 'Agent SDK' nello stesso senso di LangChain o AutoGen, LlamaIndex è indispensabile per costruire agenti che devono interagire con e ragionare su grandi quantità di dati privati o specifici del dominio. Si concentra sulla 'R' in RAG (Generazione Arricchita dal Recupero).

Architettura e Concetti Fondamentali

L'architettura di LlamaIndex è incentrata sull'ingestione, l'indicizzazione e la query dei dati:

• Loader: Connettori a varie fonti di dati (PDF, database, API, ecc.).
• Nodi: Pezzi di dati acquisiti, spesso con metadati.
• Indici: Rappresentazioni strutturate dei tuoi dati, ottimizzate per il recupero (ad es., VectorStoreIndex, KeywordTableIndex).
• Motori di Query: Interfacce per interrogare gli indici, spesso utilizzando LLM per sintesi.
• Recuperatori: Componenti che recuperano nodi pertinenti da un indice in base a una query.
• Agenti: LlamaIndex ha anche una propria astrazione di agente, spesso costruita attorno a un motore di query e strumenti, progettata per interagire con le fonti di dati.

Funzionalità Avanzate & Esempio Pratico (Interrogazione di Dati Non Strutturati)

LlamaIndex eccelle nel costruire agenti che possono 'parlare' ai tuoi dati. Creiamo un agente che può rispondere a domande basate su una raccolta di documenti.

Esempio: Agente di Domande e Risposte sui Documenti

Supponiamo di avere una directory data/ contenente diversi file di testo (ad es., appunti delle riunioni, descrizioni dei prodotti).

import os
from llama_index.readers.simple import SimpleDirectoryReader
from llama_index.core import VectorStoreIndex, Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.core.agent import AgentRunner
from llama_index.core.tools import QueryEngineTool, ToolMetadata

# 1. Carica documenti da una directory
# Crea file di dati fittizi per dimostrazione
if not os.path.exists("data"): os.makedirs("data")
with open("data/product_info.txt", "w") as f: f.write("Il nuovo prodotto XYZ dispone di una fotocamera da 12MP, display OLED da 6,1 pollici e 256GB di memoria. Costa 999 dollari.")
with open("data/company_policy.txt", "w") as f: f.write("I dipendenti hanno diritto a 20 giorni di congedo retribuito all'anno. Tutte le spese di viaggio devono essere pre-approvate.")

documents = SimpleDirectoryReader("data").load_data()

# 2. Configura LLM e Modello di Embedding (assicurati che OPENAI_API_KEY sia impostato)
Settings.llm = OpenAI(model="gpt-3.5-turbo", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-ada-002")

# 3. Crea un VectorStoreIndex dai documenti
index = VectorStoreIndex.from_documents(documents)

# 4. Crea un motore di query dall’indice
query_engine = index.as_query_engine()

# 5. Definisci il motore di query come uno strumento per l'agente
query_engine_tool = QueryEngineTool(
 query_engine=query_engine,
 metadata=ToolMetadata(
 name="document_qa_tool",
 description="Può rispondere a domande sui documenti aziendali, informazioni sui prodotti e politiche."
 ),
)

# 6. Crea l'Agente LlamaIndex (usa OpenAI LLM per impostazione predefinita se configurato)
agent = AgentRunner(tools=[query_engine_tool], llm=Settings.llm, verbose=True)

# 7. Esegui l'agente
response = agent.chat("Quali sono le specifiche del nuovo prodotto XYZ?")
print(response)
# Output previsto:
# > Entrando nel ciclo dell'agente.
# Pensiero: L'utente sta chiedendo informazioni sulle specifiche del prodotto. Dovrei usare il `document_qa_tool` per interrogare i documenti caricati.
# Chiamata allo strumento: document_qa_tool con argomenti: {"query": "specifiche del nuovo prodotto XYZ"}
# Risposta: Il nuovo prodotto XYZ dispone di una fotocamera da 12MP, display OLED da 6,1 pollici e 256GB di memoria.
# > Ciclo dell'agente terminato.
# Il nuovo prodotto XYZ dispone di una fotocamera da 12MP, display OLED da 6,1 pollici e 256GB di memoria.

response = agent.chat("Quanti giorni di congedo retribuito hanno diritto i dipendenti?")
print(response)
# Output previsto:
# > Entrando nel ciclo dell'agente.
# Pensiero: L'utente sta chiedendo informazioni sulla politica aziendale riguardo al congedo retribuito. Dovrei usare il `document_qa_tool` per interrogare i documenti caricati.
# Chiamata allo strumento: document_qa_tool con argomenti: {"query": "politica di congedo retribuito"}
# Risposta: I dipendenti hanno diritto a 20 giorni di congedo retribuito all'anno.
# > Ciclo dell'agente terminato.
# I dipendenti hanno diritto a 20 giorni di congedo retribuito all'anno.

Questo esempio evidenzia la forza di LlamaIndex nel rendere interrogabile i dati non strutturati da parte degli LLM. L'agente decide dinamicamente di utilizzare il document_qa_tool quando si trova di fronte a domande che possono essere risposte dai documenti acquisiti.

Forze e Debolezze

• Forze: Incomparabile per RAG, solide capacità di ingestione e indicizzazione dei dati, forte supporto per varie fonti di dati e archivi vettoriali, buono per costruire agenti arricchiti di conoscenza.
• Debolezze: Meno focalizzato su conversazioni complesse tra più agenti o su catene di ragionamento profonde e multi-passaggio rispetto a LangChain/AutoGen (anche se può integrarsi con essi), la sua astrazione di agente è principalmente per interagire con i dati.

Alternative Emergenti e SDK di Nicchia

Lo spazio agentico è in rapida evoluzione, con nuovi SDK e framework che emergono costantemente:

• CrewAI: Si basa sui concetti di LangChain e AutoGen, fornendo un framework più orientato per definire ruoli, compiti e processi per team multi-agente. Semplifica l'orchestrazione di flussi di lavoro complessi con un focus su responsabilità chiare degli agenti.
• Haystack (Deepset): Sebbene sia principalmente un framework per costruire sistemi di ricerca, Haystack supporta anche RAG e capacità agentiche. È noto per il suo approccio modulare ai pipe e il forte focus sulla prontezza alla produzione.
• Semantic Kernel (Microsoft): Uno SDK leggero che consente agli sviluppatori di integrare LLM con linguaggi di programmazione tradizionali. Si concentra su 'plugin' e 'skill' per estendere le capacità degli LLM, offrendo un approccio più incentrato sul codice allo sviluppo degli agenti.

Scegliere il Giusto SDK per Agenti per il Tuo Progetto

Il miglior SDK per agenti dipende pesantemente dai requisiti specifici del tuo progetto:

• Per ragionamenti complessi e a agente singolo con strumenti personalizzati e flussi di lavoro flessibili: LangChain è un'eccellente scelta grazie alla sua modularità e alle sue ampie integrazioni. È il punto di riferimento per costruire agenti sofisticati e autonomi.
• Per la collaborazione tra più agenti, interfacce conversazionali e l'esecuzione automatizzata di compiti (specialmente se coinvolgono codice): AutoGen brilla. Se il tuo problema si decompone naturalmente in ruoli che possono conversare e agire, AutoGen fornisce un potente framework.
• Per agenti che devono interrogare e sintetizzare informazioni da vasti dataset proprietari o non strutturati in modo efficiente: LlamaIndex è indispensabile. È il tuo strumento principale per costruire agenti potenziati da RAG. Spesso, LlamaIndex viene utilizzato in concomitanza con LangChain o AutoGen per fornire capacità di recupero dati ai loro agenti.
• Per flussi di lavoro multi-agente con ruoli e compiti chiari: Considera CrewAI per un approccio più strutturato agli agenti basati su team.
• Per integrare le capacità LLM in applicazioni esistenti con un focus su 'abilità' e plugin: Semantic Kernel potrebbe essere una scelta più adatta, specialmente per gli sviluppatori .NET.

Conclusione

Il settore degli SDK per agenti è dinamico e potente, offrendo una varietà di strumenti per dare vita agli agenti AI. LangChain, AutoGen e LlamaIndex rappresentano la frontiera, ognuno con punti di forza distintivi adattati a diversi aspetti dello sviluppo degli agenti. Comprendendo le loro architetture fondamentali, funzionalità avanzate e applicazioni pratiche, gli sviluppatori possono prendere decisioni informate, combinare i loro punti di forza e costruire sistemi di agenti AI altamente intelligenti, solidi e scalabili in grado di affrontare sfide complesse del mondo reale. Il futuro dell'AI è sempre più agentico e padroneggiare questi SDK è la chiave per sbloccare il suo pieno potenziale.

🕒 Published: April 5, 2026