Introduzione agli SDK per Agenti
La diffusione degli agenti autonomi alimentati dall’IA ha trasformato il nostro modo di concepire le 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 SDK per Agent fornisce gli strumenti, le librerie e le strutture di base necessarie per progettare, sviluppare, implementare e gestire agenti di IA. Questa guida avanzata esplorerà un’analisi comparativa dei SDK per Agenti più popolari, mettendo in evidenza la loro architettura, le funzionalità avanzate, i casi d’uso pratici e fornirà esempi di codice per illustrare i loro punti di forza e di debolezza. Esploreremo SDK rinomati come LangChain, AutoGen, LlamaIndex, e discuteremo delle alternative emergenti.
Componenti Essenziali di un SDK per Agenti
Prima di esplorare SDK specifici, è cruciale comprendere i componenti architettonici comuni che offrono:
- Integrazione LLM: Facilita la connessione fluida con vari Modelli di Linguaggio di Grande Dimensione (LLMs) (ad esempio, OpenAI, Anthropic, modelli Hugging Face).
- Gestione dei Prompt: Strumenti per costruire, modellare e gestire i prompt per un’interazione ottimale con i LLM.
- Chiamata a Strumenti/Funzioni: Meccanismi che consentono agli agenti di interagire con API esterne, database o funzioni personalizzate per estendere le loro capacità.
- Gestione della Memoria: Sistemi che consentono agli agenti di conservare il contesto, la cronologia delle conversazioni e le informazioni acquisite durante le interazioni.
- Pianificazione e Ragionamento: Strutture 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 Debugging: Funzionalità per monitorare il comportamento degli agenti, tracciare i percorsi di esecuzione e risolvere problemi.
- Deploy e Scalabilità: Considerazioni e strumenti per implementare agenti in ambienti di produzione e farli scalare.
LangChain: Il Coltellino Svizzero dello Sviluppo di Agenti
LangChain è senza dubbio lo SDK per Agenti più ampiamente adottato e completo. È noto per la sua modularità e le sue integrazioni estese, che lo rendono una scelta potente per flussi di lavoro agentici complessi.
Architettura e Concetti di Base
L’architettura di LangChain è costruita attorno a diverse astrazioni fondamentali:
- LLMs/ChatModels: Interfacce per interagire con vari fornitori di LLM.
- Prompt: 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. Utilizzano 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.
- Retriever: Componenti per recuperare documenti da un database di conoscenze.
- 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 ragionamenti complessi. Costruiamo un agente LangChain che può rispondere a 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} è ${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")
Successivamente, ci integriamo con un’API di notizie (ad esempio, NewsAPI.org – assicurati di avere una chiave API) come un altro strumento. Per motivi di brevità, utilizzeremo una funzione sostitutiva 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 di azienda dato."""
# In uno scenario reale, 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 su 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
# Inizializzare LLM
llm = ChatOpenAI(temperature=0, model="gpt-4-turbo-preview") # o gpt-3.5-turbo
# Definire gli strumenti che l'agente può utilizzare
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 a riguardo?"}))
# Output Atteso (troncato per brevità):
# > Ingresso in una nuova catena AgentExecutor...
# Pensiero: Devo prima trovare il prezzo delle azioni di Apple, poi cercare le notizie a riguardo.
# Azione: get_stock_price
# Input dell'Azione: AAPL
# Osservazione: Il prezzo attuale di AAPL è $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 su un nuovo lancio di 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 è $xxx.xx. Le notizie recenti riguardanti Apple includono solide vendite del Vision Pro e voci sul lancio di un nuovo iPhone.
Questo esempio dimostra la capacità di LangChain di orchestrare diversi strumenti all’interno di un ciclo di ragionamento sofisticato (ReAct), rendendolo ideale per compiti che richiedono una decisione dinamica.
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: Può presentare una curva di apprendimento ripida, il codice standard 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 tra più agenti, consentendo agli sviluppatori di creare sistemi in cui più agenti collaborano per risolvere compiti. Mette in evidenza 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 agire come 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 e Esempio Pratico (Generazione e Revisione di Codice)
AutoGen eccelle negli scenari in cui un compito si suddivide naturalmente in sottocompiti che richiedono diverse competenze, simulate 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 che OPENAI_API_KEY sia definito 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 codice Python pulito ed efficiente."
)
# Crea un altro AssistantAgent per la revisione e il test del 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 la correttezza, l'efficienza e i 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})
# Iniziare la conversazione
user_proxy.initiate_chat(
manager,
message="Scrivi una funzione Python che calcola in modo efficiente il numero di Fibonacci n-esimo. Il revisore controllerà questo e suggerirà dei test."
)
# Output atteso (semplificato e troncato):
# 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, efficace 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 si scambiano messaggi per raggiungere un obiettivo comune. Il UserProxyAgent può anche eseguire il codice generato se configurato per farlo.
Forze e Debolezze
- Forze : Eccellente per la collaborazione multi-agente, orchestrazione di compiti basata su linguaggio naturale, buone capacità di esecuzione di codice, intuitivo per creare agenti conversazionali.
- Debolezze : Meno enfasi sul ragionamento interno complesso degli agenti (come ReAct per un singolo agente), potrebbe 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: Incremento dei Dati per i LLM
Sebbene non sia strettamente un 'Agent SDK' nel senso di LangChain o AutoGen, LlamaIndex è indispensabile per costruire agenti che devono interagire con e ragionare su enormi quantità di dati privati o specifici per un settore. Si concentra sul 'R' di RAG (Retrieval Augmented Generation).
Architettura e Concetti Fondamentali
L'architettura di LlamaIndex è incentrata sull'ingestione dei dati, sull'indicizzazione e sulle query:
- Caricamento : Connettori verso diverse fonti di dati (PDF, database, API, ecc.).
- Nodi : Pezzi 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 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 Documento
Supponiamo di avere una directory data/ contenente diversi file di testo (ad esempio, note di riunione, 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. Caricare i documenti da una directory
# Creare 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 dispone di una fotocamera 12MP, uno schermo OLED da 6,1 pollici e 256 GB di spazio di archiviazione. Costa 999 $.")
with open("data/company_policy.txt", "w") as f: f.write("I dipendenti hanno diritto a 20 giorni di ferie pagate all'anno. Tutte le spese di viaggio devono essere approvate in anticipo.")
documents = SimpleDirectoryReader("data").load_data()
# 2. Configurare 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. Creare un VectorStoreIndex a partire dai documenti
index = VectorStoreIndex.from_documents(documents)
# 4. Creare un motore di query a partire dall'indice
query_engine = index.as_query_engine()
# 5. Definire il motore di query come 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 dell'azienda, informazioni sui prodotti e politiche."
),
)
# 6. Creare l'agente LlamaIndex (utilizza per impostazione predefinita OpenAI LLM se configurato)
agent = AgentRunner(tools=[query_engine_tool], llm=Settings.llm, verbose=True)
# 7. Eseguire l'agente
response = agent.chat("Quali sono le specifiche del nuovo prodotto XYZ?")
print(response)
# Output atteso :
# > In ingresso nel ciclo dell'agente.
# Pensiero: L'utente chiede le 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 dispone di una fotocamera 12MP, uno schermo OLED da 6,1 pollici e 256 GB di spazio di archiviazione.
# > Ciclo dell'agente completato.
# Il nuovo prodotto XYZ dispone di una fotocamera 12MP, uno schermo OLED da 6,1 pollici e 256 GB di spazio di archiviazione.
response = agent.chat("Quanti giorni di ferie pagate hanno diritto i dipendenti?")
print(response)
# Output atteso :
# > In ingresso nel ciclo dell'agente.
# Pensiero: L'utente chiede la politica dell'azienda riguardo alle ferie pagate. Dovrei usare lo strumento `document_qa_tool` per interrogare i documenti caricati.
# Chiamata dello strumento: document_qa_tool con gli argomenti : {"query": "politica di ferie pagate"}
# Risposta: I dipendenti hanno diritto a 20 giorni di ferie pagate all'anno.
# > Ciclo dell'agente completato.
# I dipendenti hanno diritto a 20 giorni di ferie pagate all'anno.
Questo esempio evidenzia la capacità di LlamaIndex di rendere i dati non strutturati interrogabili dai LLM. L'agente decide dinamicamente di utilizzare lo document_qa_tool quando si trova di fronte a domande che possono essere risposte dai documenti ingeriti.
Forze e Debolezze
- Forze : Incomparabile per RAG, buone capacità di ingestione e indicizzazione dei dati, un ottimo 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 dell'agente è principalmente destinata a interagire con i dati.
Alternative Emergenti e SDK di Nicchia
Il campo degli agenti si sta evolvendo 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) : Anche se è principalmente un framework per costruire sistemi di ricerca, Haystack supporta anche RAG e capacità di agenti. È noto per il suo approccio modulare ai 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à dei LLM, offrendo un approccio più orientato al codice per lo sviluppo di agenti.
Scegliere il Giusto Agent SDK per il Vostro Progetto
Il miglior Agent SDK dipende fortemente dai requisiti specifici del vostro 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 punto di 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 vostro problema si scompone naturalmente in ruoli che possono conversare e agire, AutoGen offre un framework potente.
- Per agenti che devono interrogare e sintetizzare efficacemente informazioni provenienti da vasti insiemi di dati proprietari o non strutturati : LlamaIndex è indispensabile. È il vostro strumento principale per costruire agenti alimentati da RAG. Spesso, LlamaIndex viene utilizzato in combinazione 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 : Considerate CrewAI per un approccio più organizzato agli agenti basati sul team.
- Per integrare le capacità LLM in applicazioni esistenti con un 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 set diversificato di strumenti per dare vita agli agenti IA. LangChain, AutoGen e LlamaIndex rappresentano l'avanguardia, ognuno con punti di forza distinti adatti a diversi aspetti dello sviluppo di agenti. Comprendendo le loro architetture fondamentali, le funzionalità avanzate e le applicazioni pratiche, gli sviluppatori possono prendere decisioni informate, combinare i loro punti di forza 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: