Tutorial di confronto dell’Agent SDK: Costruire applicazioni intelligenti con esempi pratici

Introduzione agli SDK di Agent

Lo spazio dell’intelligenza artificiale sta evolvendo rapidamente, con un crescente focus sugli 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 impegnativo, richiedendo competenze in elaborazione del linguaggio naturale, apprendimento automatico, rappresentazione della conoscenza e molto altro. È qui che entrano in gioco gli SDK di Agent (kit di sviluppo software). Gli SDK di Agent forniscono agli sviluppatori componenti predefiniti, framework e strumenti per accelerare lo sviluppo di agenti intelligenti, astrando gran parte della complessità sottostante.

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

Caratteristiche Chiave da Considerare in un SDK di Agent

• Supporto Linguistico: Supporta il tuo linguaggio di programmazione preferito (Python, JavaScript, Java, ecc.)?
• Facilità d’Uso e Curva di Apprendimento: Quanto velocemente 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 della conversazione e la memoria a lungo termine dell’agente?
• Orchestrazione e Workflow: Fornisce strumenti per definire comportamenti complessi degli agenti, presa di decisione e processi multi-step?
• Scalabilità e Performance: Può gestire un elevato volume di interazioni e calcoli complessi?
• Opzioni di Deployment: Quali sono gli ambienti di deployment supportati (cloud, on-premises, serverless)?
• Comunità e Documentazione: Esiste una comunità attiva e una documentazione completa per assistenza durante lo sviluppo?
• Estensibilità: Qual è la facilità di estensione delle funzionalità dell’SDK con componenti personalizzati?

Confrontare gli SDK di Agent: LangChain vs. LlamaIndex vs. Microsoft Semantic Kernel

Per questo tutorial, ci concentreremo su tre SDK di Agent prominenti e ampiamente utilizzati: LangChain, LlamaIndex e Microsoft Semantic Kernel. Ognuno di essi propone un approccio unico per costruire agenti intelligenti, in particolare quelli che utilizzano modelli di linguaggio di grandi dimensioni (LLMs).

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

LangChain è rapidamente emerso come un framework dominante per sviluppare applicazioni alimentate da grandi modelli di linguaggio. La sua filosofia centrale ruota attorno al ‘chainare’ diversi componenti per creare flussi di lavoro complessi. Fornisce un insieme completo di astrazioni per interagire con gli LLMs, gestire le richieste, 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 richiesta + LLM + analizzatore di output.
• Agenti: Permettere agli LLMs di scegliere una sequenza di azioni da intraprendere, spesso utilizzando strumenti.
• Memoria: Memorizzare e recuperare informazioni sulle interazioni passate.
• Loader: Caricare dati da varie fonti (PDF, siti web, database).
• Vectorstores: Memorizzare e interrogare embeddings per la ricerca semantica.
• Strumenti: Funzionalità esterne che un agente può utilizzare (ad esempio, motori di ricerca, calcolatrici, API personalizzate).

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

Creiamo un agente LangChain capace di rispondere a domande generali e di utilizzare uno strumento di calcolo, 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. Inizializzare il LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")

# 2. Definire gli Strumenti
# Strumento di calcolo
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. Ottenere la richiesta da LangChain Hub (stile ReAct)
# La richiesta ReAct guida l'LLM a pensare, osservare e agire.
prompt = hub.pull("hwchase17/react")

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

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

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

Spiegazione:

• Iniziamo un modello di Chat OpenAI.
• Definiamo uno strumento Calculator utilizzando il LLMMathChain di LangChain.
• Estrarre una richiesta standard ReAct da LangChain Hub. ReAct (Ragionamento e Azione) è un paradigma che consente agli LLMs di effettuare ragionamenti dinamici e pianificare azioni.
• create_react_agent combina l’LLM, gli strumenti e la richiesta per creare un agente.
• AgentExecutor è responsabile dell’esecuzione dell’agente, della gestione del suo processo di riflessione e dell’esecuzione degli strumenti.
• Quando gli viene chiesto della capitale della Francia, l’LLM risponde direttamente. Quando gli viene posta una domanda matematica, riconosce la necessità della calcolatrice, chiama lo strumento e fornisce il risultato.

2. LlamaIndex: Framework di Dati per le Applicazioni LLM

Mentre LangChain si concentra fortemente sull’orchestrazione e sul chaining di chiamate LLM, LlamaIndex (precedentemente GPT Index) si specializza nell’ingestione di dati, indicizzazione e recupero per applicazioni LLM. Il suo obiettivo principale è facilitare la connessione degli LLMs con fonti di dati personalizzate, consentendo potenti applicazioni RAG (Recupero-Augmentato da Generazione). LlamaIndex eccelle nella costruzione di basi di conoscenza e nella loro interrogabilità da parte degli LLMs.

Caratteristiche Chiave di LlamaIndex:

• Connettori di Dati: Ingestione di dati provenienti da diverse fonti (documenti, database, API).
• Indicizzazione dei Dati: Strutturare e memorizzare i dati in modo ottimizzato per le query LLM (ad esempio, negozi di vettori, grafici di conoscenza).
• Motori di Query: Recuperare informazioni pertinenti dagli indici e sintetizzare risposte utilizzando LLMs.
• Agenti: Combinare motori di query con strumenti e LLMs per un ragionamento più complesso sui dati.
• Contesto di Servizio: Gestire l’LLM, il modello di embedding e altre configurazioni di servizio.

Esempio Pratico di LlamaIndex: Interrogare un Documento Personalizzato

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

# Prima di tutto, crea un file fittizio: 'policy.txt'
# Contenuto:
# "La politica delle ferie della nostra azienda concede ai dipendenti 15 giorni di ferie retribuite all'anno. 
# Dopo 5 anni di servizio, i dipendenti ricevono 5 giorni aggiuntivi. 
# I giorni di ferie 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

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

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

# 2. Caricare documenti da una directory
documents = SimpleDirectoryReader("data").load_data() # Supponendo che 'policy.txt' si trovi in una directory 'data'

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

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

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

response = query_engine.query("Cosa succede con i giorni di ferie non utilizzati?")
print(response)

Spiegazione :

• Creiamo prima un file policy.txt in una directory data.
• Configuriamo il LLM e il modello di incarico tramite Settings.
• SimpleDirectoryReader carica il file di testo.
• VectorStoreIndex.from_documents elabora i documenti, li suddivide in pezzi, li incapsula 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 i pezzi di documenti rilevanti in base alla similarità semantica e poi utilizza il LLM per sintetizzare una risposta da questi pezzi.

3. Microsoft Semantic Kernel: L’Orchestratore per le Applicazioni Alimentate dall’IA con Plugin

Microsoft Semantic Kernel (SK) è un SDK open-source che consente agli sviluppatori di integrare grandi modelli di linguaggio (LLMs) e altre capacità di IA nelle loro applicazioni utilizzando linguaggi di programmazione esistenti (C#, Python, Java). Si concentra sull’abilitazione delle applicazioni a orchestrare interazioni con LLMs e codice tradizionale, con un focus su un’architettura di ‘plugin’. SK è particolarmente adatto per gli sviluppatori già presenti nell’ecosistema Microsoft o per coloro che cercano un framework solido e di livello aziendale.

Caratteristiche Chiave del Semantic Kernel:

• Kernel: Il motore centrale di orchestrazione per l’IA e il codice tradizionale.
• Competenze/Plugin: Collezioni di funzioni semantiche (prompt LLM) e di funzioni native (codice tradizionale) che l’IA può invocare.
• Funzioni Semantiche: Prompt che definiscono ciò che il LLM deve fare.
• Funzioni Native: Metodi di codice tradizionale esposti all’IA, permettendo così l’interazione con sistemi esterni.
• Memoria: Memorizzare e recuperare informazioni per il contesto conversazionale.
• Pianificatori: Permettono all’IA di pianificare e attuare una sequenza di competenze per raggiungere un obiettivo.

Esempio Pratico di Kernel Semantico: Un Pianificatore Semplice con un Plugin Personalizzato

Creiamo un’applicazione Kernel Semantico che può salutare l’utente e effettuare una semplice operazione aritmetica usando 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. Inizializzare il Kernel
kernel = sk.Kernel()

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

# 3. Definire un plugin nativo personalizzato (Competenze in SK)
class MathPlugin:
 @kernel_function(description="Aggiunge 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. Importare il plugin nel kernel
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")

# 5. Definire una funzione semantica (per la conversazione generale)
# 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. InvoCare direttamente la funzione di chat
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Ciao, cosa puoi fare per me?"))
 print(f"Risposta della chat: {result}")

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

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

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

Spiegazione :

• Inizializziamo il Kernel e aggiungiamo un servizio di completamento della chat OpenAI.
• Definiamo una classe MathPlugin con decoratori @kernel_function, esponendo add e multiply come funzioni native.
• Importiamo questo plugin nel kernel.
• Una funzione semantica semplice chat_function viene creata per un’interazione diretta con il LLM.
• Nel main(), invochiamo prima la funzione di chat direttamente.
• Successivamente, per l’esempio di pianificazione, creiamo una cronologia di chat con un obiettivo. Utilizzando function_call="auto" nei parametri, 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 metodi reali e restituisce quindi il risultato al LLM.

Scegliere il Giusto SDK Agent

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

• Scegli LangChain se:
  • Hai bisogno di un’orchestrazione LLM estesa, di un comportamento agentico complesso e di una catena flessibile di componenti.
  • Desideri integrare una vasta gamma di LLMs, strumenti e tipi di memoria.
  • Stai costruendo applicazioni che coinvolgono ragionamenti in più fasi, selezioni dinamiche di strumenti e agenti conversationali.
  • Apprezzi una grande comunità attiva e molti esempi.
• Scegli LlamaIndex se:
  • Il tuo obiettivo principale è connettere gli LLMs ai tuoi dati personalizzati (documenti, database, API) per il RAG.
  • Hai bisogno di solide capacità di ingestione di dati, indicizzazione e recupero.
  • Stai costruendo sistemi di domande/risposte per basi di conoscenza, riassunti di documenti o agenti sensibili ai dati.
  • Preferisci una gestione dei dati efficiente e scalabile per gli LLMs.
• Scegli Microsoft Semantic Kernel se:
  • Sei uno sviluppatore C#, Python o Java che cerca di integrare armoniosamente l’IA in applicazioni esistenti.
  • Vuoi un framework solido e pronto per l’azienda di Microsoft.
  • Devi combinare le capacità degli LLM (funzioni semantiche) con il codice tradizionale (funzioni native/plugin) in modo strutturato.
  • Stai costruendo applicazioni che richiedono che l’IA interagisca con i tuoi sistemi interni e API.

Conclusione

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

🕒 Published: April 5, 2026