Confronto tra gli SDK degli agenti – Una guida avanzata con esempi pratici

Introduzione agli SDK degli Agenti

L’ascesa degli agenti autonomi alimentati da IA ha trasformato il nostro modo di concepire le applicazioni software. Questi agenti, in grado 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 si trovano i Kit di Sviluppo Software per Agenti (SDK). Un SDK di Agenti fornisce gli strumenti, le librerie e i framework di base necessari per progettare, sviluppare, implementare e gestire agenti di IA. Questa guida avanzata esplorerà un’analisi comparativa dei popolari SDK per Agenti, evidenziando la loro architettura, le funzionalità avanzate, i casi d’uso pratici e fornendo esempi di codice per illustrare punti di forza e debolezza. Esploreremo SDK rinomati come LangChain, AutoGen, LlamaIndex, e discuteremo delle alternative emergenti.

Componenti Essenziali di un SDK di Agente

Prima di esplorare SDK specifici, è cruciale comprendere i componenti architettonici comuni che offrono:

• Integrazione LLM: Facilita la connessione fluida con diversi Modelli di Linguaggio di Grande Dimensione (LLMs) (ad esempio, OpenAI, Anthropic, modelli Hugging Face).
• Gestione dei Prompts: Strumenti per costruire, modellare e gestire i prompt per un’interazione ottimale con i LLM.
• Chiamata di Strumenti/Funzioni: Meccanismi che consentono agli agenti di interagire con API esterne, database o funzioni personalizzate per espandere le loro capacità.
• Gestione della Memoria: Sistemi che consentono agli agenti di mantenere il contesto, la cronologia delle conversazioni e le informazioni acquisite durante le interazioni.
• Pianificazione e Ragionamento: Framework per consentire agli agenti di scomporre compiti complessi, pianificare le fasi di esecuzione e ragionare sui risultati (ad esempio, ReAct, CoT).
• Orchestrazione degli Agenti: Strumenti per definire sistemi multi-agente, gestire la comunicazione e coordinare i compiti tra gli agenti.
• Osservabilità e Debug: Funzionalità per monitorare il comportamento degli agenti, tracciare i percorsi di esecuzione e risolvere i problemi.
• Implementazione e Scalabilità: Considerazioni e strumenti per implementare agenti in ambienti di produzione e farli scalare.

LangChain: Il Coltellino Svizzero per lo Sviluppo di Agenti

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

Architettura e Concetti di Base

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

• LLMs/ChatModels: Interfacce per interagire con vari fornitori di LLM.
• Prompts: Modelli per generare input LLM.
• Chains: Sequenze di chiamate a LLM o ad altri strumenti.
• Agenti: LLM potenziati con strumenti per interagire con il loro ambiente. Usano un “ciclo di ragionamento” (ad esempio, ReAct) per decidere quale strumento utilizzare.
• Strumenti: Funzioni che un agente può chiamare per eseguire azioni specifiche.
• Memoria: Memorizza le interazioni passate per fornire contesto.
• Recuperatori: Componenti per recuperare documenti da una base di conoscenza.
• VectorStores: Database per memorizzare embeddings vettoriali.

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

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

Esempio: Agente di 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 borsistico (ad esempio, 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 attuale di {ticker} è di ${current_price:.2f}"
 except Exception as e:
 return f"Impossibile recuperare il prezzo dell'azione per {ticker} : {e}"

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

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

from langchain.tools import tool

@tool
def get_company_news(company_name: str) -> str:
 """Utile per ottenere i titoli recenti delle notizie riguardanti un nome d'azienda dato."""
 # In uno scenario reale, ciò chiamerebbe un'API di notizie
 if "Microsoft" in company_name:
 return "Notizie recenti di Microsoft: Annuncio di una nuova partnership in IA, profitti superiori alle attese."
 elif "Apple" in company_name:
 return "Notizie recenti di Apple: Vendite del Vision Pro solide, voci di lancio di un nuovo 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

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

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

# Ottenere il modello di prompt ReAct da LangChain Hub
prompt = hub.pull("hwchase17/react")

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

# Creare l'Agent Executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# Eseguire l'agente
print(agent_executor.invoke({"input": "Qual è il prezzo attuale dell'azione di Apple e quali sono le ultime notizie su di loro?"}))
# Uscita Attesa (troncata per brevità):
# > Inserimento in una nuova catena AgentExecutor...
# Pensiero: Devo prima trovare il prezzo delle azioni di Apple, poi cercare le notizie su di loro.
# Azione: get_stock_price
# Input dell'Azione: AAPL
# Osservazione: Il prezzo attuale di AAPL è di $xxx.xx
# Pensiero: Ora ho il prezzo delle azioni. Devo ottenere le notizie per Apple.
# Azione: get_company_news
# Input dell'Azione: Apple
# Osservazione: Notizie recenti di Apple: Vendite del Vision Pro solide, voci di lancio di un nuovo iPhone.
# Pensiero: Ho sia il prezzo delle azioni che le notizie su Apple. Posso ora fornire una risposta dettagliata.
# Risposta Finale: Il prezzo attuale dell'azione di Apple è di $xxx.xx. Le notizie recenti su Apple includono solide vendite del Vision Pro e voci sul lancio di un nuovo iPhone.

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

Punti di Forza e Debolezza

• Punti di Forza: Estremamente flessibile e modulare, vasto ecosistema di integrazioni (LLMs, negozi di vettori, strumenti), forte supporto della comunità, eccellente per ragionamenti complessi in più fasi.
• Punti di Debolezza: Potrebbe avere una curva di apprendimento ripida, il codice standard può accumularsi, il debug delle prestazioni può essere difficile in catene complesse.

AutoGen: Conversazioni Multi-Agent e Orchestrazione

AutoGen di Microsoft si concentra sulle conversazioni tra più agenti, consentendo ai programmatori di creare sistemi in cui più agenti collaborano per risolvere compiti. Sottolinea la flessibilità nella definizione dei ruoli degli agenti e dei modelli di comunicazione.

Architettura e Concetti di Base

I concetti fondamentali di AutoGen ruotano attorno a:

• Agenti : Gli elementi di base. Possono essere alimentati da LLM (ConversableAgent) o fungere da proxy umani (UserProxyAgent).
• Conversazioni : Gli agenti comunicano inviandosi messaggi.
• GroupChat : Facilita le conversazioni tra più agenti in modo strutturato.
• Esecuzione di Codice : Gli agenti possono eseguire codice localmente o in un contenitore Docker.

Funzionalità Avanzate ed 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, simulate da diversi agenti. Creiamo un semplice sistema multi-agenti per la generazione e la revisione di codice.

Esempio: Generatore e Revisore di Codice Python

import autogen

# Configura LLM (assicurati che OPENAI_API_KEY sia definita nelle variabili d'ambiente)
config_list = autogen.config_list_openai_aoai(exclude="aoai")

# Crea un UserProxyAgent per fungere da 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 la generazione di codice
coder = autogen.AssistantAgent(
 name="Coder",
 llm_config={"config_list": config_list},
 system_message="Sei un programmatore Python utile. Scrivi un codice Python pulito ed efficiente."
)

# Crea un altro AssistantAgent per la revisione e il test di codice
reviewer = autogen.AssistantAgent(
 name="Reviewer",
 llm_config={"config_list": config_list},
 system_message="Sei un revisore di codice. Esamina il codice Python fornito per verificarne 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 in modo efficiente il numero di Fibonacci n-esimo. Il revisore verificherà e suggerirà dei test."
)

# Uscita attesa (semplificata e troncata):
# User_Proxy (al manager): Scrivi una funzione Python...
# Coder (al 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 (al manager): Sembra buono, efficiente usando un approccio iterativo. Ecco un caso di test :
# ```python
# # test_fibonacci.py
# import pytest
# from your_module import fibonacci # Supponiamo che il codice sia registrato 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 (al 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. Il UserProxyAgent può persino eseguire il codice generato se configurato in tal senso.

Punti di Forza e Debolezza

• Punti di Forza : Eccellente per la collaborazione multi-agente, orchestrazione di compiti basati su linguaggio naturale, buone capacità di esecuzione di codice, intuitivo per creare agenti conversazionali.
• Punti di Debolezza : Meno enfasi sul ragionamento interno complesso degli agenti (come ReAct per un singolo agente), può essere meno evidente per flussi di lavoro profondamente annidati e sequenziali rispetto alle catene di LangChain, gestire flussi di conversazione complessi può diventare delicato.

LlamaIndex : Aumento dei Dati per i LLM

Sebbene non sia strettamente un 'Agent SDK' nello stesso senso di LangChain o AutoGen, LlamaIndex è indispensabile per costruire agenti che devono interagire e ragionare su enormi quantità di dati privati o specifici di un dominio. Si concentra sul 'R' di RAG (Generazione Aumentata da Recupero).

Architettura e Concetti Fondamentali

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

• Caricamento : Connettori verso diverse fonti di dati (PDF, database, API, ecc.).
• Nodi : Porzioni di dati ingeriti, spesso con metadati.
• Indice : Rappresentazioni strutturate dei tuoi dati, ottimizzate per il recupero (ad esempio, VectorStoreIndex, KeywordTableIndex).
• Motori di query : Interfacce per interrogare gli indici, spesso utilizzando LLM per la sintesi.
• Recuperatori : Componenti che estraggono nodi pertinenti da un indice in base a una query.
• Agenti : LlamaIndex ha anche la propria astrazione di agente, spesso costruita attorno a un motore di query e a strumenti, progettata per interagire con fonti di dati.

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

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

Esempio: Agente Q&R Documenti

Supponiamo di avere una cartella data/ contenente diversi file di testo (ad esempio, appunti di riunioni, descrizioni di 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 i documenti da una cartella
# Crea file di dati fittizi per la 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 ha una fotocamera da 12MP, uno schermo OLED da 6,1 pollici e 256 GB di storage. Costa 999 $.")
with open("data/company_policy.txt", "w") as f: f.write("I dipendenti hanno diritto a 20 giorni di ferie retribuite all'anno. Tutte le spese di viaggio devono essere approvate in anticipo.")

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

# 2. Configura il LLM e il modello di integrazione (assicurati che OPENAI_API_KEY sia definito)
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 (utilizza per impostazione predefinita OpenAI LLM 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)
# Uscita attesa :
# > Entrata nel ciclo dell'agente.
# Pensiero : L'utente richiede specifiche del prodotto. Dovrei usare lo strumento `document_qa_tool` per interrogare i documenti caricati.
# Chiamata dello strumento: document_qa_tool con gli argomenti : {"query": "specifiche del nuovo prodotto XYZ"}
# Risposta : Il nuovo prodotto XYZ ha una fotocamera da 12MP, uno schermo OLED da 6,1 pollici e 256 GB di storage.
# > Ciclo dell'agente completato.
# Il nuovo prodotto XYZ ha una fotocamera da 12MP, uno schermo OLED da 6,1 pollici e 256 GB di storage.

response = agent.chat("Quanti giorni di ferie retribuite hanno diritto i dipendenti?")
print(response)
# Uscita attesa :
# > Entrata nel ciclo dell'agente.
# Pensiero : L'utente richiede la politica aziendale riguardo alle ferie retribuite. Dovrei usare lo strumento `document_qa_tool` per interrogare i documenti caricati.
# Chiamata dello strumento: document_qa_tool con gli argomenti : {"query": "politica delle ferie retribuite"}
# Risposta : I dipendenti hanno diritto a 20 giorni di ferie retribuite all'anno.
# > Ciclo dell'agente completato.
# I dipendenti hanno diritto a 20 giorni di ferie retribuite all'anno.

Questo esempio mette in evidenza la capacità di LlamaIndex di rendere i dati non strutturati interrogabili dai LLMs. L'agente decide dinamicamente di utilizzare il document_qa_tool quando si trova di fronte a domande che possono essere risposte dai documenti ingeriti.

Punti di Forza e Debolezza

• Forze : Incomparabile per RAG, buone capacità di ingestione e indicizzazione dei dati, un eccellente supporto per diverse fonti di dati e archivi di vettori, ideale per costruire agenti potenziati dalla conoscenza.
• Debolezze : Meno focalizzato su conversazioni complesse tra più agenti o catene di ragionamento profonde e multi-step rispetto a LangChain/AutoGen (anche se può integrarsi con essi), la sua astrazione di agente è principalmente destinata a interagire con i dati.

Alternativa Emergenti e SDK di Nicchia

Il campo degli agenti evolve rapidamente, 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-agenti. 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à di agenti. È noto per il suo approccio modulare al pipeline e il suo forte focus sulla preparazione alla produzione.
• Semantic Kernel (Microsoft) : Un SDK leggero che consente agli sviluppatori di integrare LLM con linguaggi di programmazione tradizionali. Si concentra su 'plugin' e 'abilità' per estendere le capacità degli LLM, offrendo un approccio più incentrato sul codice per lo sviluppo di agenti.

Scegliere il Giusto Agent SDK per il Tuo Progetto

Il miglior Agent SDK dipende fortemente dalle esigenze specifiche del tuo progetto:

• Per un ragionamento complesso con un solo agente che utilizza strumenti personalizzati e flussi di lavoro flessibili : LangChain è un'ottima scelta grazie alla sua modularità e alle sue numerose integrazioni. È il riferimento per costruire agenti autonomi e sofisticati.
• Per la collaborazione multi-agenti, le interfacce conversazionali e l'esecuzione automatica dei compiti (soprattutto coinvolgendo codice) : AutoGen si distingue. Se il tuo problema si suddivide naturalmente in ruoli in grado di conversare e agire, AutoGen offre un framework potente.
• Per agenti che devono interrogare e sintetizzare efficacemente informazioni provenienti da vasti set di dati proprietari o non strutturati : LlamaIndex è indispensabile. È il tuo strumento principale per costruire agenti alimentati da RAG. Spesso, LlamaIndex è usato in associazione con LangChain o AutoGen per fornire capacità di recupero dati ai loro agenti.
• Per flussi di lavoro multi-agenti strutturati con ruoli e compiti chiari : Prendi in considerazione CrewAI per un approccio più organizzato agli agenti basati su team.
• Per integrare le capacità LLM in applicazioni esistenti con focus su "abilità" e plugin : Semantic Kernel potrebbe essere una scelta migliore, in particolare per gli sviluppatori .NET.

Conclusione

Il campo degli SDK per agenti è dinamico e potente, offrendo un insieme diversificato di strumenti per dare vita agli agenti IA. LangChain, AutoGen e LlamaIndex rappresentano l'avanguardia, ognuno con vantaggi distinti adatti a differenti aspetti dello sviluppo di agenti. Comprendendo le loro architetture fondamentali, le funzionalità avanzate e le applicazioni pratiche, gli sviluppatori possono prendere decisioni informate, combinare le loro forze e creare sistemi di agenti IA altamente intelligenti, solidi e scalabili, capaci di affrontare sfide complesse del mondo reale. Il futuro dell'IA è sempre più agentico, e padroneggiare questi SDK è la chiave per sbloccare il suo pieno potenziale.

🕒 Published: April 5, 2026