Puoi creare workflow agentici senza dover ricorrere a [modelli linguistici di grandi dimensioni (LLM)] estremamente grandi e costosi (https://www.ibm.com/it-it/think/topics/large-language-models)? La risposta è sì. In questo tutorial, dimostreremo come creare un sistema RAG multiagente localmente con AutoGen utilizzando IBM [Granite] (https://www.ibm.com/it-it/granite).
La Retrieval-augmented generation (RAG) è un modo efficace per fornire a un LLM dataset aggiuntivi da varie fonti di dati senza la necessità di costose ottimizzazioni. Allo stesso modo, il RAG agente utilizza la capacità di un agente AI di pianificare ed eseguire attività secondarie insieme al recupero di informazioni rilevanti per integrare la base di conoscenze di un LLM. Questa capacità consente l'ottimizzazione e una maggiore scalabilità delle applicazioni RAG rispetto ai chatbot tradizionali. Non è più necessario scrivere complesse query SQL per estrarre dati rilevanti da una base di conoscenza.
Il futuro del RAG agentico è il RAG multi-agente, in cui diversi agenti specializzati collaborano per ottenere una latenza e un'efficienza ottimali. Dimostreremo questa collaborazione utilizzando un modello piccolo ed efficiente come Granite 3.2 e combinandolo con un'architettura di agenti modulare. Utilizzeremo diversi "mini agenti" specializzati che collaborano per portare a termine le attività attraverso una pianificazione adattiva e la chiamata di strumenti o funzioni. Come gli esseri umani, un team di agenti, o un sistema multiagente, spesso supera gli sforzi eroici di un individuo, soprattutto quando ha dei ruoli chiaramente definiti e una comunicazione efficace.
Per l' orchestrazione di questa collaborazione, possiamo usare AutoGen (AG2) come framework principale per gestire i workflow e il processo decisionale, insieme ad altri strumenti come Ollama per il servizio LLM locale e Open WebUI per l'interazione. AutoGen è un framework per la creazione di applicazioni AI multiagente sviluppato da Microsoft.1 In particolare, ogni componente utilizzato in questo tutorial è open source. Insieme, questi strumenti ti consentono di creare un sistema AI potente e attento alla privacy, senza lasciare il tuo laptop.
Il nostro agente di recupero Granite si basa su un'architettura modulare in cui ogni agente ha un ruolo specializzato. Come gli umani, gli agenti ottengono i risultati migliori quando hanno istruzioni mirate e un contesto sufficiente per prendere una decisione informata. Troppe informazioni estranee, come una cronologia chat non filtrata, possono creare un problema del tipo "ago nel pagliaio", in cui diventa sempre più difficile distinguere il segnale dal rumore.
In questa architettura agentic AI, gli agenti collaborano in sequenza per raggiungere l'obiettivo. Ecco come è organizzato il sistema di AI generativa:
Agente di pianificazione: crea il piano iniziale di alto livello, una volta all'inizio del workflow. Ad esempio, se un utente chiede: "Quali sono i progetti open source paragonabili a quelli utilizzati dal mio team?" quindi, l'agente metterà insieme un piano in più passaggi che potrebbe assomigliare a questo: "1. Cerca nei documenti del team le tecnologie open source. 2. Cerca sul web progetti open source simili a quelli trovati nel passaggio 1." Se uno di questi passaggi non riesce o fornisce risultati insufficienti, può essere successivamente adattato dall'agente riflettente.
Assistente alla ricerca: l'assistente alla ricerca è il cavallo di battaglia del sistema. Accetta ed esegue istruzioni come "Cerca nei documenti del team tecnologie open source". Per la fase 1 del piano utilizza le istruzioni iniziali dell'agente di pianificazione. Per le fasi successive, riceve anche un contesto curato dai risultati delle fasi precedenti.
Ad esempio, se viene chiesto "Cerca nel Web progetti open source simili", riceverà anche l'output della precedente fase di ricerca del documento. A seconda dell'istruzione, l'assistente di ricerca può utilizzare strumenti come la ricerca sul web o la ricerca di documenti, o entrambi, per svolgere il proprio compito.
Critico del passaggio: il critico del passaggio è responsabile di decidere se l'output della fase precedente ha risposto in modo soddisfacente alle istruzioni impartite. Riceve due informazioni: l'istruzione in un solo passaggio appena eseguita e l'output di quell'istruzione. La presenza di un critico nella conversazione porta a chiarire se l'obiettivo è stato raggiunto, un requisito necessario per la pianificazione della fase successiva.
Giudice dell'obiettivo: il giudice dell'obiettivo determina se l'obiettivo finale è stato raggiunto, in base a tutti i requisiti dell'obiettivo fornito, ai piani elaborati per raggiungerlo e alle informazioni raccolte finora. L'output del giudice è " YES " o " NOT YET " seguito da una breve spiegazione che non è più lunga di una o due frasi.
Agente di riflessione: l'agente di riflessione è il nostro decisore esecutivo. Decide quale passo intraprendere, che si tratti di intervenire nel passo successivo pianificato, di cambiare rotta per rimediare agli imprevisti o di confermare il raggiungimento dell'obiettivo. Come un vero CEO, prende le migliori decisioni quando ha un obiettivo chiaro in mente e gli vengono presentati risultati concisi sui progressi compiuti o meno per raggiungerlo. L'output dell'agente di riflessione è il prossimo passo da compiere o le istruzioni per terminare se l'obiettivo è stato raggiunto. Presentiamo l'agente di riflessione con i seguenti elementi:
- L'obiettivo
- Il piano originale
- L'ultimo passaggio eseguito
- Il risultato dell'ultimo passaggio che indica il successo o l'insuccesso
- Una sequenza concisa di istruzioni eseguite in precedenza (solo le istruzioni, non il loro output)
Presentare questi elementi in un formato strutturato rende chiaro al nostro decisore cosa è stato fatto in modo che possa decidere cosa deve accadere dopo.
Generatore di report: una volta raggiunto l'obiettivo, il generatore di report sintetizza tutti i risultati in un output coerente che risponde direttamente alla domanda originale. Sebbene ogni fase del processo generi output mirati, il generatore di report collega tutto in un report finale.
Per i principianti, può essere difficile creare un'applicazione di agentic AI da zero. Per questo motivo utilizzeremo una serie di strumenti open source. Granite Retrieval Agent integra più strumenti per il RAG agentico.
Open WebUI: l'utente interagisce con il sistema attraverso un'interfaccia di chat intuitiva ospitata in Open WebUI. Questa interfaccia funge da punto principale per l'invio di query (come ad esempio "Recupera gli ultimi articoli di notizie relativi alle note del mio progetto") e per la visualizzazione degli output.
Agente basato su Python (framework AG2): al centro del sistema c'è un agente basato su Python creato utilizzando AutoGen (AG2). Questo agente coordina il workflow suddividendo le attività e chiamando dinamicamente gli strumenti per eseguire i passaggi.
L'agente ha accesso a due strumenti principali:
Strumento di ricerca di documenti: recupera le informazioni pertinenti da un database vettoriale contenente note di progetto caricate o documenti memorizzati come embedding. Questa ricerca vettoriale utilizza le API integrate per il recupero dei documenti all'interno di Open WebUI, anziché configurare uno storage dei dati completamente separato.
Strumento di ricerca web: esegue ricerche basate sul web per raccogliere conoscenze esterne e informazioni in tempo reale. In questo caso, stiamo utilizzando SearXNG come nostro metamotore di ricerca.
Ollama: L'LLM IBM Granite 3.2 funge da modello linguistico su cui si basa il sistema. È ospitato localmente utilizzando Ollama, garantendo inferenza rapida, efficienza dei costi e privacy dei dati. Se ti interessa eseguire questo progetto con modelli più grandi, l'accesso all'API tramite IBM watsonx.ai o OpenAI, ad esempio, è preferito. Questo approccio, tuttavia, richiede una chiave API watsonx.ai o OpenAI. In questo tutorial, invece, usiamo Ollama ospitato localmente.
Altri framework open source comuni per agenti non trattati in questo tutorial comprendono LangChain, LangGraph e crewAI.
Le istruzioni dettagliate di configurazione e l'intero progetto possono essere visualizzati sulla IBM Granite Community GitHub. La versione Jupyter Notebook di questo tutorial è disponibile anche su GitHub.
I passaggi seguenti forniscono una configurazione rapida per l'agente di recupero Granite.
Passaggio 1: installa Ollama
Installare Ollama è semplice come scaricare il client dal sito ufficiale di Ollama. Dopo aver installato Ollama, esegui il seguente comando per estrarre Granite 3.2 LLM.
Ora sei operativo con Ollama e Granite.
Passaggio 2. Crea un agente semplice (facoltativo)
Una soluzione a uso limitato di codice per la creazione di workflow è AutoGen Studio. Tuttavia, creare noi stessi un semplice agente può aiutarci a comprendere meglio la configurazione di questo progetto RAG multiagente completo. Per continuare, configura un Jupyter Notebook nel tuo ambiente di sviluppo integrato (IDE) preferito e attiva un ambiente virtuale eseguendo i seguenti comandi nel tuo terminale.
python3.11 -m venv venv
source venv/bin/activate
Avremo bisogno di alcune librerie e moduli per questo semplice agente. Assicurati di installare e importare i seguenti.
!pip install -qU langchain chromadb tf-keras pyautogen "ag2[ollama]" sentence_transformers
import getpass
from autogen.agentchat.contrib.retrieve_assistant_agent import AssistantAgent
from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
Ci sono diversi parametri di configurazione da impostare localmente per richiamare l'LLM corretto che abbiamo ottenuto utilizzando Ollama.
ollama_llm_config = {
"config_list": [
{
"model": "granite3.2:8b",
"api_type": "ollama",
}
],
}
Possiamo passare questi parametri di configurazione nel parametro llm_config della classe AssistantAgent per creare un'istanza del nostro primo agente AI.
assistant = AssistantAgent(
name="assistant",
system_message="You are a helpful assistant.",
llm_config=ollama_llm_config,
)
Questo agente utilizza Granite 3.2 per sintetizzare le informazioni restituite dall'agente ragproxyagent. Il documento che forniamo all'agente RAG come contesto aggiuntivo è il file README Markdown non elaborato che si trova nel repository AutoGen su GitHub. Inoltre, possiamo passare un nuovo dizionario di configurazioni specifiche per l'agente di recupero. Alcune chiavi aggiuntive che potresti trovare utili sono vector_db, chunk_token_size e embedding_model.
Per un elenco completo delle chiavi di configurazione, consulta la documentazione ufficiale.
ragproxyagent = RetrieveUserProxyAgent(
name="ragproxyagent",
max_consecutive_auto_reply=3,
is_termination_msg=lambda msg: msg.get("content") is not None or "TERMINATE" in msg["content"],
system_message = "Context retrieval assistant.",
retrieve_config={
"task": "qa",
"docs_path": "https://raw.githubusercontent.com/microsoft/autogen/main/README.md",
"get_or_create": True,
"collection_name": "autogen_docs",
"overwrite": True
},
code_execution_config=False,
human_input_mode="NEVER",
)
Ora possiamo avviare una chat con il nostro agente RAG per porre una domanda relativa al documento fornito come contesto.
qs = "What languages does AutoGen support?"
result = ragproxyagent.initiate_chat(
assistant, message=ragproxyagent.message_generator, problem=qs
)
print(result)
Nota che il contenuto Markdown del file README è stato rimosso dall'output per brevità.
Output:
Trying to create collection.
2025-07-21 12:20:36,125 - autogen.agentchat.contrib.retrieve_user_proxy_agent - INFO - Found 1 chunks.
2025-07-21 12:20:36,129 - autogen.agentchat.contrib.vectordb.chromadb - INFO - No content embedding is provided. Will use the VectorDB's embedding function to generate the content embedding.
VectorDB returns doc_ids: [['8e9131c7']]
Adding content of doc 8e9131c7 to context.
ragproxyagent (to assistant):
You're a retrieve augmented chatbot. You answer user's questions based on your own knowledge and the context provided by the user.
If you can't answer the question with or without the current context, you should reply exactly `UPDATE CONTEXT`.
You must give as short an answer as possible.
User's question is: What languages does AutoGen support?
Context is:
[REDACTED]
assistant (to ragproxyagent):
The provided text appears to be a README file for the AutoGen project, an open-source initiative by Microsoft. Here's a summary of its content:
- Project Overview: AutoGen is a system for creating and managing complex, distributed applications. It supports multiple languages (C#, Python) and provides a runtime environment for deploying and scaling these applications.
- Key Components: - AutoGen Core: The core library containing the fundamental classes and interfaces for building AutoGen applications. - AutoGen Agent: A runtime component responsible for managing the lifecycle of AutoGen applications. - AutoGen Runtime Gateway: A service that facilitates communication between agents and enables load balancing, scaling, and fault tolerance.
- Languages Supported: C# and Python are currently supported.
- Getting Started: The README provides instructions on how to install the necessary packages, create a new project, and build/run an AutoGen application.
- Documentation: Links to detailed documentation for reference, including API references, guides, and tutorials.
- Community & Contribution: Guidelines for contributing to the project, including information on issue tracking, pull requests, and coding standards.
- Legal Notices: Licensing information and trademark notices.
- Support & FAQ: Information on how to ask questions, report issues, and find answers to common queries.
The README also includes a table summarizing the available packages for each supported language (C# and Python) and their respective package managers (NuGet and PyPI). This makes it easy for developers to quickly identify the necessary components for getting started with AutoGen in their preferred language.
>>>>>>>> TERMINATING RUN (601a53dc-8a5d-4e19-8503-1517fe3c7634): Termination message condition on agent 'ragproxyagent' met
Fantastico! Il nostro assistente e agente RAG hanno sintetizzato con successo il contesto aggiuntivo per rispondere correttamente alla richiesta dell'utente con i linguaggi di programmazione attualmente supportati da AutoGen. Puoi pensare a questo scambio come a una chat di gruppo tra agenti che si scambiano informazioni. Questo esempio è una semplice dimostrazione dell'implementazione di agentic RAG in locale con AutoGen.
Fase 3. Installa Open WebUI
Passiamo ora alla creazione di un sistema RAG agentico più avanzato. Nel terminale, installa ed esegui Open WebUI.
pip install open-webui
open-webui serve
Passaggio 4. Imposta la ricerca web
Per la ricerca sul web, utilizzeremo le funzionalità di ricerca web integrate in Open WebUI.
Open WebUI supporta una serie di provider di ricerca. In generale, può utilizzare un servizio application programming interface (API) di terze parti, per il quale dovrà ottenere una chiave API, oppure può configurare localmente un container Docker SearXNG. In entrambi i casi, sarà necessario configurare il provider di ricerca nella console Open WebUI.
Questa configurazione, che può essere un puntatore a SearXNG o l'input della chiave API, si trova in Pannello di amministrazione > Impostazioni > Ricerca Web nella console Open WebUI.
Consulta le istruzioni nella documentazione di Open WebUI per informazioni più dettagliate.
Passaggio 5. Importa l'agente in Open WebUI
1. Nel tuo browser, vai su http://localhost:8080/ per accedere a Open WebUI. Se è la prima volta che la apri, registra un nome utente e una password. Queste informazioni sono mantenute interamente locali nel tuo computer.
2. Dopo aver effettuato la registrazione, fai clic sull'icona in basso a sinistra dove si trova il tuo nome utente. Dal menu, fai clic su Pannello di amministrazione.
3. Nella scheda Funzioni , fai clic su + per aggiungere una nuova funzione.
4. Assegna un nome alla funzione, ad esempio "Granite RAG Agent," e una descrizione, entrambe di tipo
5. Incolla lo script Python granite_autogen_rag.py nella casella di testo fornita, sostituendo qualsiasi contenuto esistente.
6. Fai clic su Salva nella parte inferiore dello schermo.
7. Tornando alla pagina Funzioni , assicurati che l'agente sia impostato su Abilitato.
8. Fai clic sull'icona a forma di ingranaggio accanto all'interruttore di abilitazione per personalizzare qualsiasi impostazione come l'endpoint di inferenza, l'endpoint SearXNG o l'ID del modello.
Ora, il tuo nuovo agente AutoGen viene visualizzato come modello nell'interfaccia Open WebUI. È possibile selezionarlo e fornirgli le query degli utenti.
Passaggio 6. Carica documenti in Open WebUI
- In Open WebUI, vai su Area di lavoro > Conoscenza.
- Fai clic su + per creare una nuova raccolta.
- Carica i documenti affinché l'agente di recupero Granite possa interrogarli.
Passaggio 7. Configura la ricerca Web in Open WebUI
Per impostare un provider di ricerca (ad esempio, SearXNG), segui questa guida.
I parametri di configurazione sono i seguenti:
| Parametro | Descrizione | Valore predefinito |
|---|---|---|
| task_model_id | Modello primario per l'esecuzione delle attività | granito3.2:8b |
| vision_model_id | Modello di visione per l'analisi delle immagini | granite-vision3.2:2b |
| openai_api_url | Endpoint API per chiamate al modello in stile OpenAI | http://localhost:11434 |
| openai_api_key | Chiave API per l'autenticazione | ollama |
| vision_api_url | Endpoint per attività legate alla visione | http://localhost:11434 |
| model_temperature | Controlla la casualità della risposta | 0 |
| max_plan_steps | Numero massimo di passaggi nella pianificazione degli agenti | 6 |
Nota: questi parametri possono essere configurati tramite l'icona a forma di ingranaggio nella sezione "Funzioni" del pannello di amministrazione Open WebUI dopo aver aggiunto la funzione.
Fase 8. Interroga il sistema agentico
L'agente di recupero Granite esegue RAG basato su AG2 interrogando documenti locali e fonti web, eseguendo la pianificazione delle attività multiagente e applicando l'esecuzione adattiva. Avvia una chat e fornisci al tuo sistema di agenti una domanda relativa ai documenti forniti per vedere la catena RAG in azione.
Una configurazione multiagente consente la creazione di strumenti pratici e utilizzabili ottenendo il massimo da modelli open source di dimensioni moderate come Granite 3.2. Questa architettura RAG agentica, costruita con strumenti open source, può fungere da punto di partenza per progettare e personalizzare gli agenti di risposta alle domande e gli algoritmi di AI. Può essere utilizzato anche subito per un'ampia gamma di casi d'uso. In questo tutorial, hai avuto l'opportunità di approfondire sistemi agentici semplici e complessi, sfruttando le funzionalità di AutoGen. L'LLM Granite è stato richiamato utilizzando Ollama, che ha consentito un'esplorazione completamente locale di questi sistemi. Come passo successivo, considera l'integrazione di altri strumenti personalizzati nel tuo sistema agentico.
Risorse
Metti l'AI al servizio della tua azienda grazie all'esperienza leader di settore e alla gamma di soluzioni di IBM nel campo dell'AI.
Reinventa i flussi di lavoro e le operazioni critiche aggiungendo l'AI per massimizzare le esperienze, il processo decisionale in tempo reale e il valore di business.
Note a piè di pagina
[1] Wu, Qingyun, et al. “AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework.” GitHub, 2023, github.com/microsoft/autogen.