Tutorial di Confronto dell’Agent SDK: Creare Applicazioni Intelligenti con Esempi Pratici

Introduzione agli Agent SDK

Il campo dell’intelligenza artificiale sta evolvendo rapidamente, con un crescente enfasi su agenti intelligenti capaci di svolgere compiti complessi, interagire con gli utenti e adattarsi a ambienti dinamici. Costruire tali agenti da zero può essere un compito arduo, richiedendo competenze in elaborazione del linguaggio naturale, apprendimento automatico, rappresentazione della conoscenza e altro ancora. È qui che 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 tipicamente offre funzionalità per definire i comportamenti degli agenti, gestire i flussi conversazionali, integrarsi con strumenti e API esterni, gestire la memoria e il contesto, e spesso include funzionalità 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 di debolezza attraverso esempi concreti.

Caratteristiche principali da considerare in un Agent SDK

• Supporto per il linguaggio: Supporta il tuo linguaggio di programmazione preferito (Python, JavaScript, Java, ecc.)?
• Facilità d’uso e curva di apprendimento: Quanto velocemente può un nuovo sviluppatore diventare produttivo con l’SDK?
• Capacità di integrazione: Si integra facilmente con altri servizi, API, database e sistemi esistenti?
• Gestione dello stato e memoria: Quanto bene gestisce il contesto conversazionale e la memoria a lungo termine per l’agente?
• Orchestrazione e flusso di lavoro: Fornisce strumenti per definire comportamenti complessi degli agenti, presa di decisione 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 una documentazione completa 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 questi offre un approccio unico per costruire agenti intelligenti, in particolare quelli che utilizzano modelli linguistici di grandi dimensioni (LLM).

1. LangChain: L’orchestratore per applicazioni basate su LLM

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

Caratteristiche principali di LangChain:

• Catene: Definire sequenze di chiamate, ad es., modelli di prompt + LLM + parser 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 varie 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 agente conversazionale semplice con utilizzo di strumenti

Costruiamo un agente LangChain che può rispondere a domande generali e utilizzare anche uno strumento calcolatrice 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 gli strumenti
# Strumento calcolatrice
llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
calculator = Tool(
 name="Calculator",
 func=llm_math_chain.run,
 description="Utile per 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'Agent Executor
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 un modello Chat di OpenAI.
• Definiamo uno strumento Calculator utilizzando LLMMathChain di LangChain.
• Preleviamo un prompt ReAct standard dal 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, della gestione del suo processo di riflessione e dell’esecuzione degli strumenti.
• Quando viene chiesto della capitale della Francia, l’LLM risponde direttamente. Quando viene posta una domanda di matematica, riconosce la necessità della calcolatrice, chiama lo strumento e fornisce il risultato.

2. LlamaIndex: Framework per i dati per applicazioni LLM

Mentre LangChain si concentra fortemente sull’orchestrazione e sulla concatenazione delle chiamate LLM, LlamaIndex (precedentemente GPT Index) si specializza nell’ingestione, indicizzazione e recupero dei dati per le applicazioni LLM. Il suo obiettivo principale è semplificare la connessione tra LLM e fonti di dati personalizzate, abilitando potenti applicazioni RAG (Retrieval-Augmented Generation). LlamaIndex eccelle nella costruzione di basi di conoscenza e nella loro interrogabilità da parte degli LLM.

Caratteristiche principali di LlamaIndex:

• Connettori di dati: Ingestire dati da varie fonti (documenti, database, API).
• Indicizzazione dei dati: Struttura e memorizza i dati in un modo ottimizzato per le query degli LLM (ad es., archivi vettoriali, grafi di conoscenza).
• Motori di query: Recuperare informazioni rilevanti dagli indici e sintetizzare risposte utilizzando gli LLM.
• Agenti: Combinare motori di query con strumenti e LLM per un ragionamento più complesso e articolato 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 semplice di LlamaIndex che possa rispondere a domande basate su un file di testo locale.

# Prima, crea un file fittizio: 'policy.txt'
# Contenuto:
# "La politica delle vacanze della nostra azienda garantisce ai dipendenti 15 giorni di permesso retribuito all'anno. 
# Dopo 5 anni di servizio, i dipendenti ricevono 5 giorni aggiuntivi. 
# I giorni di vacanza non utilizzati non vengono trasferiti all'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 variabili d'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 nella 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 riceveranno i dipendenti all'anno?")
print(response)

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

Spiegazione:

• Iniziamo creando 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 divide in parti, li incorpora e li memorizza in un database vettoriale (in memoria per impostazione predefinita).
• index.as_query_engine() crea un’interfaccia per interrogare l’indice.
• Quando si effettua una query, il motore di query recupera frammenti di documenti rilevanti in base alla similarità semantica e poi utilizza l’LLM per sintetizzare una risposta da quei frammenti.

3. Microsoft Semantic Kernel: L’orchestratore per app AI con plugin

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

Caratteristiche principali di Semantic Kernel:

• Kernel: Il motore centrale di orchestrazione per l’AI e il codice tradizionale.
• Skills/Plugins: Raccolte di funzioni semantiche (prompt LLM) e funzioni native (codice tradizionale) che l’AI può invocare.
• Semantic Functions: Prompt che definiscono cosa dovrebbe fare il LLM.
• Native Functions: Metodi di codice tradizionale esposti all’AI, che permettono di interagire con sistemi esterni.
• Memory: Memorizza e recupera informazioni per il contesto conversazionale.
• Planners: Consentono all’AI di 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 possa salutare l’utente e anche eseguire una semplice operazione aritmetica utilizzando una funzione native 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. Inizializza il Kernel
kernel = sk.Kernel()

# 2. Configura 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. Definisci un plugin native 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. Importa il plugin nel kernel
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")

# 5. Definisci una funzione semantica (per conversazioni generali)
# Questo è un prompt semplice 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. Invoca la funzione di chat direttamente
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Ciao, cosa puoi fare per me?"))
 print(f"Risposta della chat: {result}")

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

 # Il meccanismo di chiamata delle funzioni di SK consente al LLM di scegliere la funzione giusta.
 # Utilizzeremo direttamente un servizio di completamento chat, permettendogli di usare 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 del pianificatore: {response}")

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

Spiegazione:

• Iniziamo 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.
• Creiamo una funzione semantica semplice chat_function per l’interazione diretta con il LLM.
• In main(), prima invochiamo la funzione di chat direttamente.
• Poi, per l’esempio di pianificazione, creiamo una cronologia di chat con un obiettivo. Utilizzando function_call="auto" nelle impostazioni, il LLM è in grado di decidere se rispondere direttamente o chiamare una delle funzioni native registrate (plugin) per raggiungere l’obiettivo. SK gestisce la traduzione della chiamata di funzione del LLM in invocazioni di metodo reali e quindi restituisce il risultato al LLM.

Scegliere il Giusto Agent SDK

La scelta dell’Agent SDK dipende fortemente dalle esigenze specifiche del tuo progetto e dalla tua tecnologia esistente:

• Scegli LangChain se:
  • Hai bisogno di una vasta orchestrazione LLM, comportamento complesso e flessibile delle entità, e concatenazione di componenti.
  • Vuoi integrare una varietà di LLM, strumenti e tipi di memoria.
  • Stai costruendo applicazioni che coinvolgono ragionamento multi-step, selezione dinamica degli strumenti e agenti conversazionali.
  • Dai valore a una comunità ampia e attiva e a esempi estesi.
• Scegli LlamaIndex se:
  • Il tuo obiettivo principale è connettere gli LLM ai tuoi dati personalizzati (documenti, database, API) per il RAG.
  • Hai bisogno di solide capacità di ingestione, indicizzazione e recupero dei dati.
  • Stai costruendo sistemi di domande e risposte per banche dati, riassuntori di documenti o agenti consapevoli dei dati.
  • Prioritizzi una gestione efficiente e scalabile dei dati per gli LLM.
• Scegli Microsoft Semantic Kernel se:
  • Sei uno sviluppatore C#, Python o Java che cerca di integrare senza problemi l’AI nelle applicazioni esistenti.
  • Vuoi un framework solido, pronto per l’impresa, di Microsoft.
  • Hai bisogno di combinare le capacità degli LLM (funzioni semantiche) con il codice tradizionale (funzioni native/plugin) in modo strutturato.
  • Stai costruendo applicazioni che richiedono che l’AI interagisca con i tuoi sistemi interni e API.

Conclusione

Gli Agent SDK sono strumenti indispensabili per costruire applicazioni AI sofisticate. LangChain, LlamaIndex e Microsoft Semantic Kernel offrono ognuno funzionalità potenti adattate a diversi aspetti dello sviluppo AI. LangChain eccelle nell’orchestrare flussi di lavoro LLM complessi e ragionamento basato su entità. LlamaIndex è il riferimento per l’integrazione dei dati e generazione augmentata da recupero. Semantic Kernel fornisce una base solida per integrare l’AI nelle applicazioni esistenti con una solida architettura di plugin, specialmente per casi d’uso aziendali. Comprendendo i loro punti di forza e vedendoli in azione attraverso esempi pratici, sei ora meglio attrezzato per scegliere il giusto SDK per dare vita alle tue idee di agenti intelligenti.

🕒 Published: April 5, 2026