Tutorial di Confronto degli Agent SDK: Costruire Applicazioni Intelligenti con Esempi Pratici

Introduzione agli Agent SDK

Il campo dell’intelligenza artificiale è in rapida evoluzione, con un crescente focus su agenti intelligenti in grado di svolgere compiti complessi, interagire con gli utenti e adattarsi a ambienti dinamici. Costruire tali agenti da zero può essere un compito arduo, che richiede competenze in elaborazione del linguaggio naturale, apprendimento automatico, rappresentazione della conoscenza e altro ancora. Qui entrano in gioco gli Agent SDK (Software Development Kits). Gli Agent SDK forniscono agli sviluppatori componenti, framework e strumenti predefiniti per accelerare lo sviluppo di agenti intelligenti, astrarre gran parte della complessità sottostante.

Un Agent SDK offre tipicamente funzionalità per definire comportamenti degli agenti, gestire flussi conversazionali, integrarsi con strumenti e API esterne, gestire la memoria e il contesto, e spesso include caratteristiche per il deployment e il monitoraggio. Scegliere il giusto Agent SDK è cruciale per il successo del tuo progetto, poiché diversi SDK si rivolgono a vari casi d’uso, linguaggi di programmazione e livelli di astrazione. Questo tutorial mira a fornire un confronto pratico di diversi Agent SDK popolari, illustrando i loro punti di forza e le loro debolezze attraverso esempi concreti.

Caratteristiche Chiave da Considerare in un Agent SDK

• Supporto Linguistico: Supporta il tuo linguaggio di programmazione preferito (Python, JavaScript, Java, ecc.)?
• Facilità d’Uso e Curva di Apprendimento: Quanto rapidamente un nuovo sviluppatore può diventare produttivo con l’SDK?
• Capacità di Integrazione: Può integrarsi facilmente con altri servizi, API, database e sistemi esistenti?
• Gestione dello Stato e Memoria: Come gestisce il contesto conversazionale e la memoria a lungo termine per l’agente?
• Orchestrazione e Workflow: Fornisce strumenti per definire comportamenti complessi degli agenti, decision-making e processi a più fasi?
• Scalabilità e Prestazioni: Può gestire un alto volume di interazioni e calcoli complessi?
• Opzioni di Deployment: Quali sono gli ambienti di deployment supportati (cloud, on-premise, serverless)?
• Comunità e Documentazione: Esiste una comunità attiva e documentazione dettagliata per assistere durante lo sviluppo?
• Estensibilità: Quanto è facile estendere le funzionalità dell’SDK con componenti personalizzati?

Confronto tra Agent SDK: LangChain vs. LlamaIndex vs. Microsoft Semantic Kernel

Per questo tutorial, ci concentreremo su tre agent SDK prominenti e ampiamente utilizzati: LangChain, LlamaIndex e Microsoft Semantic Kernel. Ognuno di essi offre un approccio unico alla costruzione di agenti intelligenti, in particolare quelli che utilizzano modelli di linguaggio di grandi dimensioni (LLM).

1. LangChain: L’Orchestratore per Applicazioni Alimentate da LLM

LangChain è emerso rapidamente come un framework dominante per lo sviluppo di applicazioni alimentate da modelli di linguaggio di grandi dimensioni. La sua filosofia principale ruota attorno al ‘collegare’ diversi componenti per creare flussi di lavoro complessi. Fornisce un set completo di astrazioni per interagire con LLM, gestire prompt, trattare la memoria conversazionale, integrarsi con strumenti esterni (Agenti) e recuperare informazioni da varie fonti di dati (Recupero).

Caratteristiche Chiave di LangChain:

• Catene: Definire sequenze di chiamate, ad esempio, modelli di prompt + LLM + analizzatore di output.
• Agenti: Consentire agli LLM di scegliere una sequenza di azioni da intraprendere, spesso utilizzando strumenti.
• Memoria: Memorizzare e recuperare informazioni su interazioni passate.
• Loader: Caricare dati da diverse fonti (PDF, siti web, database).
• Vectorstore: Memorizzare e interrogare embedding per la ricerca semantica.
• Strumenti: Funzionalità esterne che un agente può utilizzare (ad es. motori di ricerca, calcolatrici, API personalizzate).

Esempio Pratico di LangChain: Un Semplice Agente Conversazionale con Uso di Strumenti

Costruiamo un agente LangChain in grado di rispondere a domande generali e di utilizzare un calcolatore se viene rilevata un’operazione matematica.

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_core.tools import Tool
from langchain.chains import LLMMathChain

# 1. Inizializza l'LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")

# 2. Definisci Strumenti
# Strumento calcolatore
llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
calculator = Tool(
 name="Calculator",
 func=llm_math_chain.run,
 description="Utile quando hai bisogno di rispondere a domande di matematica."
)

tools = [calculator]

# 3. Ottieni il prompt da LangChain Hub (stile ReAct)
# Il prompt ReAct guida l'LLM a pensare, osservare e agire.
prompt = hub.pull("hwchase17/react")

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

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

# 6. Esegui l'agente
print(agent_executor.invoke({"input": "Qual è la capitale della Francia?"}))
print(agent_executor.invoke({"input": "Qual è 1234 * 5678?"}))

Spiegazione:

• Iniziamo con l’inizializzare un modello di chat OpenAI.
• Definiamo uno strumento Calculator utilizzando LLMMathChain di LangChain.
• Estraiamo un prompt ReAct standard da LangChain Hub. ReAct (Reasoning and Acting) è un paradigma che consente agli LLM di eseguire ragionamenti dinamici e pianificazione delle azioni.
• create_react_agent combina l’LLM, gli strumenti e il prompt per creare un agente.
• AgentExecutor è responsabile dell’esecuzione dell’agente, gestendo il suo processo di pensiero e l’esecuzione degli strumenti.
• Quando gli viene chiesto della capitale della Francia, l’LLM risponde direttamente. Quando viene posta una domanda di matematica, riconosce la necessità del calcolatore, chiama lo strumento e fornisce il risultato.

2. LlamaIndex: Framework di Dati per Applicazioni LLM

Mentre LangChain si concentra molto sull’orchestrazione e sulla concatenazione delle chiamate LLM, LlamaIndex (precedentemente noto come GPT Index) si specializza nell’ingestione, indicizzazione e recupero dei dati per applicazioni LLM. Il suo obiettivo principale è semplificare la connessione degli LLM con fonti di dati personalizzate, consentendo applicazioni potenti RAG (Retrieval-Augmented Generation). LlamaIndex eccelle nella costruzione di basi di conoscenza e nel renderle interrogabili dagli LLM.

Caratteristiche Chiave di LlamaIndex:

• Connettori Dati: Ingestire dati da diverse fonti (documenti, database, API).
• Indicizzazione dei Dati: Strutturare e memorizzare i dati in un modo che è ottimizzato per le query LLM (ad es. archivii vettoriali, grafi di conoscenza).
• Motori di Query: Recuperare informazioni pertinenti dagli indici e sintetizzare risposte utilizzando LLM.
• Agenti: Combinare motori di query con strumenti e LLM per ragionamenti più complessi e a più fasi sui dati.
• Contesto di Servizio: Gestire LLM, modello di embedding e altre configurazioni di servizio.

Esempio Pratico di LlamaIndex: Interrogare un Documento Personalizzato

Creiamo un’applicazione LlamaIndex semplice che possa rispondere a domande basate su un file di testo locale.

# Prima, crea un file fittizio: 'policy.txt'
# Contenuto:
# "La politica di vacanza della nostra azienda concede ai dipendenti 15 giorni di ferie retribuite all'anno.
# Dopo 5 anni di servizio, i dipendenti ricevono ulteriori 5 giorni.
# I giorni di vacanza non utilizzati non si accumulano per l'anno successivo."

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
import os

# Imposta la chiave API di OpenAI (assicurati che sia nelle tue variabili di ambiente)
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

# 1. Configura LLM e Modello di Embedding (opzionale, ma buona pratica)
Settings.llm = OpenAI(model="gpt-4o", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")

# 2. Carica documenti da una directory
documents = SimpleDirectoryReader("data").load_data() # Assumendo che 'policy.txt' sia in una directory 'data'

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

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

# 5. Interroga il motore
response = query_engine.query("Quanti giorni di vacanza ricevono i dipendenti all'anno?")
print(response)

response = query_engine.query("Cosa succede ai giorni di vacanza non utilizzati?")
print(response)

Spiegazione:

• Creiamo prima un file policy.txt in una directory data.
• Configuriamo l’LLM e il modello di embedding tramite Settings.
• SimpleDirectoryReader carica il file di testo.
• VectorStoreIndex.from_documents elabora i documenti, li suddivide in pezzi, li integra e li memorizza in un database vettoriale (in memoria per impostazione predefinita).
• index.as_query_engine() crea un’interfaccia per interrogare l’indice.
• Quando viene effettuata una query, il motore di query recupera chunk di documenti pertinenti sulla base della similarità semantica e poi utilizza l’LLM per sintetizzare una risposta da quei chunk.

3. Microsoft Semantic Kernel: L’Orchestratore per App AI-Powered con Plugin

Microsoft Semantic Kernel (SK) è un SDK open-source che consente agli sviluppatori di integrare modelli di linguaggio di grandi dimensioni (LLM) e altre capacità di intelligenza artificiale nelle loro applicazioni utilizzando linguaggi di programmazione esistenti (C#, Python, Java). Si concentra sulla possibilità di orchestrare interazioni con LLM e codice tradizionale, enfatizzando un’architettura di ‘plugin’. SK è particolarmente forte per gli sviluppatori già impegnati nell’ecosistema Microsoft o per coloro che cercano un framework solido di livello enterprise.

Caratteristiche Chiave di Semantic Kernel:

• Kernel: Il motore centrale di orchestrazione per l’IA e il codice tradizionale.
• Skills/Plugins: Collezioni di funzioni semantiche (LLM prompts) e funzioni native (codice tradizionale) che l’IA può invocare.
• Funzioni Semantiche: Prompt che definiscono cosa dovrebbe fare l’LLM.
• Funzioni Native: Metodi di codice tradizionale esposti all’IA, consentendole di interagire con sistemi esterni.
• Memoria: Memorizzare e recuperare informazioni per il contesto conversazionale.
• Pianificatori: Abilitano l’IA a pianificare ed eseguire una sequenza di competenze per raggiungere un obiettivo.

Esempio Pratico di Semantic Kernel: Un Pianificatore Semplice con Plugin Personalizzato

Creiamo un’applicazione Semantic Kernel che può salutare l’utente e anche eseguire un’operazione aritmetica semplice utilizzando una funzione nativa personalizzata (plugin).

import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function
import asyncio

# 1. Inizializziamo il Kernel
kernel = sk.Kernel()

# 2. Configuriamo il servizio LLM
# Assicurati che la tua OPENAI_API_KEY sia impostata come variabile d'ambiente
kernel.add_service(
 OpenAIChatCompletion(
 service_id="chat_completion",
 ai_model_id="gpt-4o",
 ),
)

# 3. Definiamo un plugin nativo personalizzato (Skills in SK)
class MathPlugin:
 @kernel_function(description="Somma due numeri.", name="Add")
 def add(self, num1: float, num2: float) -> float:
 return num1 + num2

 @kernel_function(description="Moltiplica due numeri.", name="Multiply")
 def multiply(self, num1: float, num2: float) -> float:
 return num1 * num2

# 4. Importiamo il plugin nel kernel
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")

# 5. Definiamo una funzione semantica (per conversazione generale)
# Questo è un semplice prompt che può essere invocato direttamente o utilizzato da un pianificatore
prompt_template = "{{$input}}"
chat_function = kernel.create_function_from_prompt(
 prompt_template=prompt_template,
 plugin_name="ChatPlugin",
 function_name="Chat"
)

async def main():
 # 6. Invochiamo la funzione di chat direttamente
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Ciao, cosa puoi fare per me?"))
 print(f"Risposta chat: {result}")

 # 7. Utilizziamo un pianificatore per orchestrare azioni, incluso il nostro MathPlugin
 # Per una pianificazione complessa, useresti un pianificatore dedicato come SequentialPlanner
 # Per questo semplice esempio, dimostreremo una chiamata diretta tramite prompt con capacità di chiamata di funzione
 
 # L'LLM, quando invocato con il giusto prompt, riconoscerà e utilizzerà i plugin registrati.
 # Creiamo un obiettivo per l'LLM da raggiungere utilizzando i plugin disponibili.
 
goal = "Ho bisogno di conoscere la somma di 10 e 20, e poi moltiplicare quel risultato per 3."

 # Il meccanismo di chiamata delle funzioni di SK consente all'LLM di scegliere la funzione giusta.
 # Utilizzeremo un servizio di completamento della chat direttamente, consentendogli di utilizzare strumenti.
 history = kernel.create_chat_history()
 history.add_user_message(goal)

 response = await kernel.get_service("chat_completion").get_chat_message_content(
 history=history,
 settings=sk.OpenAIChatCompletionSettings(function_call="auto")
 )
 print(f"Risposta pianificatore: {response}")

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

Spiegazione:

• Inizializziamo il Kernel e aggiungiamo un servizio di completamento chat OpenAI.
• Definiamo una classe MathPlugin con decoratori @kernel_function, esponendo add e multiply come funzioni native.
• Importiamo questo plugin nel kernel.
• Viene creata una semplice funzione semantica chat_function per l’interazione diretta con l’LLM.
• In main(), invochiamo prima direttamente la funzione di chat.
• Poi, per l’esempio di pianificazione, creiamo una cronologia di chat con un obiettivo. Utilizzando function_call="auto" nelle impostazioni, l’LLM è abilitato a decidere se rispondere direttamente o chiamare una delle funzioni native registrate (plugin) per raggiungere l’obiettivo. SK gestisce la traduzione della chiamata di funzione dell’LLM in reali invocazioni di metodo e poi restituisce il risultato all’LLM.

Scelta del Giusto Agent SDK

La scelta dell’Agent SDK dipende fortemente dalle specifiche esigenze del tuo progetto e dal tuo stack tecnologico esistente:

• Scegli LangChain se:
  • Hai bisogno di una vasta orchestrazione degli LLM, comportamento agentico complesso e catene flessibili di componenti.
  • Vuoi integrare una varietà di LLM, strumenti e tipi di memoria.
  • Stai costruendo applicazioni che coinvolgono ragionamenti a più passaggi, selezione dinamica degli strumenti e agenti conversazionali.
  • Valuti una comunità ampia e attiva e esempi estesi.
• Scegli LlamaIndex se:
  • Il tuo focus principale è collegare gli LLM ai tuoi dati personalizzati (documenti, database, API) per RAG.
  • Hai bisogno di solide capacità di ingestione dati, indicizzazione e recupero.
  • Stai costruendo sistemi di Q&A basati su conoscenze, riassumitori di documenti o agenti consapevoli dei dati.
  • Prioritizzi una gestione dei dati efficiente e scalabile per gli LLM.
• Scegli Microsoft Semantic Kernel se:
  • Sei uno sviluppatore C#, Python o Java alla ricerca di integrare fluidamente l’IA nelle applicazioni esistenti.
  • Vuoi un framework solido, pronto per le imprese, di Microsoft.
  • Hai bisogno di combinare le capacità degli LLM (funzioni semantiche) con codice tradizionale (funzioni native/plugin) in modo strutturato.
  • Stai costruendo applicazioni che richiedono all’IA di interagire con i tuoi sistemi e API interni.

Conclusione

Gli Agent SDK sono strumenti indispensabili per costruire applicazioni IA sofisticate. LangChain, LlamaIndex e Microsoft Semantic Kernel offrono ciascuno potenti funzionalità specializzate in diversi aspetti dello sviluppo dell’IA. LangChain eccelle nell’orchestrazione di flussi di lavoro complessi degli LLM e nel ragionamento agentico. LlamaIndex è la scelta ideale per l’integrazione dei dati e la generazione aumentata dal recupero. Semantic Kernel fornisce una base solida per integrare l’IA nelle applicazioni esistenti con un’architettura di plugin robusta, specialmente per casi d’uso aziendali. Comprendendo i loro punti di forza fondamentali e vedendoli in azione attraverso esempi pratici, sei ora meglio equipaggiato per scegliere il giusto SDK per dare vita alle tue idee di agenti intelligenti.

🕒 Published: April 5, 2026