¿Puede crear flujos de trabajo agénticos sin necesidad de modelos de lenguaje grandes (LLM) extremadamente grandes y costosos? La respuesta es sí. En este tutorial, demostraremos cómo crear un sistema RAG multiagente localmente con AutoGen mediante IBM® Granite.
La generación aumentada por recuperación (RAG, por sus siglas en inglés) es una forma eficaz de proporcionar a un LLM conjuntos de datos adicionales de varias fuentes de datos sin necesidad de costosos ajustes. Del mismo modo, la RAG agéntica aprovecha la capacidad de un agente de IA para planificar y ejecutar subtareas junto con la recuperación de información relevante para complementar la base de conocimientos de un LLM. Esta capacidad permite la optimización y una mayor escalabilidad de las aplicaciones RAG en comparación con los chatbots tradicionales. Ya no necesitamos escribir consultas SQL complejas para extraer datos relevantes de una base de conocimientos.
El futuro de la RAG agéntica es la RAG multiagente, donde varios agentes especializados colaboran para lograr una latencia y eficiencia óptimas. Demostraremos esta colaboración utilizando un modelo pequeño y eficiente como Granite 3.2 y combinándolo con una arquitectura de agente modular. Utilizaremos múltiples "mini agentes" especializados que colaboran para lograr tareas a través de la planificación adaptativa y la llamada a herramientas o funciones. Al igual que los humanos, un equipo de agentes, o un sistema multiagente, a menudo supera los esfuerzos heroicos de una persona, especialmente cuando tienen roles claramente definidos y una comunicación efectiva.
Para la orquestación de esta colaboración, podemos utilizar AutoGen (AG2) como infraestructura para gestionar los flujos de trabajo y la toma de decisiones, junto con otras herramientas como Ollama para el servicio local de LLM y Open WebUI para la interacción. AutoGen es un marco para crear aplicaciones de IA multiagente desarrollada por Microsoft.1 En particular, todos los componentes aprovechados en este tutorial son de código abierto. Juntas, estas herramientas le permiten crear un sistema de IA potente y consciente de la privacidad, sin salir de su computadora portátil.
Nuestro agente de recuperación Granite se basa en una arquitectura modular en la que cada agente tiene una función especializada. Al igual que los humanos, los agentes se desempeñan mejor cuando tienen instrucciones específicas y el contexto suficiente para tomar una decisión informada. Demasiada información superflua, como un historial de chat sin filtrar, puede crear un problema de "aguja en el pajar", donde se vuelve cada vez más difícil descifrar la señal del ruido.
En esta arquitectura de IA agéntica, los agentes trabajan juntos de forma secuencial para lograr el objetivo. Así es como se organiza el sistema de IA generativa:
Agente planificador: crea el plan inicial de alto nivel, una vez al comienzo del flujo de trabajo. Por ejemplo, si un usuario pregunta: "¿Cuáles son los proyectos de código abierto comparables a los que está usando mi equipo?", el agente elaborará un plan paso a paso que podría verse así: “1. Busque documentos del equipo para tecnologías de código abierto. 2. Busque en la web proyectos de código abierto similares a los que se encuentran en el paso 1”. Si alguno de estos pasos falla o proporciona resultados insuficientes, el agente de reflexión puede adaptarlos posteriormente.
Asistente de investigación: el asistente de investigación es el caballo de batalla del sistema. Toma y ejecuta instrucciones como "Buscar documentos del equipo para tecnologías de código abierto". Para el paso 1 del plan, utiliza las instrucciones iniciales del agente planificador. Para los pasos posteriores, también recibe un contexto curado de los resultados de los pasos anteriores.
Por ejemplo, si se le pide "Buscar en la web proyectos de código abierto similares", también recibirá el resultado del paso anterior de búsqueda de documentos. Dependiendo de la instrucción, el asistente de investigación puede usar herramientas como la búsqueda web o de documentos, o ambas, para cumplir con su tarea.
Crítico de pasos: el crítico de pasos es responsable de decidir si el resultado del paso anterior cumplió satisfactoriamente con la instrucción que se le dio. Recibe dos conjuntos de información: la instrucción de un solo paso que se acaba de ejecutar y la salida de esa instrucción. Tener un crítico de pasos que intervenga en la conversación aporta claridad sobre si se logró el objetivo, lo cual es necesario para la planificación del siguiente paso.
Juez de objetivos: el juez de objetivos determina si se ha cumplido el objetivo final, en función de todos los requisitos del objetivo proporcionado, los planes redactados para lograrlo y la información recopilada hasta el momento. El resultado del juez es "SÍ" o "AÚN NO", seguido de una breve explicación que no tiene más de una o dos oraciones.
Agente de reflexión: el agente de reflexión es nuestro responsable ejecutivo de la toma de decisiones. Decide qué paso tomar a continuación, ya sea invadir el siguiente paso planificado, cambiar el rumbo para compensar contratiempos o confirmar que el objetivo se ha completado. Al igual que un director ejecutivo (CEO) de la vida real, realiza su mejor toma de decisiones cuando tiene un objetivo claro en mente y se le presentan hallazgos concisos sobre el progreso que se ha hecho o no para alcanzar ese objetivo. El resultado del agente de reflexión es el siguiente paso a seguir o las instrucciones para terminar si se ha alcanzado el objetivo. Presentamos el agente de reflexión con los siguientes elementos:
- El objetivo
- El plan original
- El último paso que se ejecutó
- El resultado del último paso que indica éxito o fracaso
- Una secuencia concisa de instrucciones ejecutadas previamente (solo las instrucciones, no su salida)
Presentar estos elementos en un formato estructurado deja claro a nuestro responsable de la toma de decisiones lo que se ha hecho para que pueda decidir qué debe suceder a continuación.
Generador de informes: una vez que se logra el objetivo, el generador de informes sintetiza todos los hallazgos en un resultado cohesivo que responde directamente a la consulta original. Si bien cada paso del proceso genera resultados específicos, el generador de informes une todo en un informe final.
Para los principiantes, puede ser difícil crear una aplicación de IA agéntica desde cero. Por lo tanto, utilizaremos un conjunto de herramientas de código abierto. El agente de recuperación Granite integra múltiples herramientas para la RAG agéntica.
Open WebUI: el usuario interactúa con el sistema a través de una interfaz de chat intuitiva alojada en Open WebUI. Esta interfaz actúa como el punto principal para enviar consultas (como "Buscarme los últimos artículos de noticias relacionados con las notas de mi proyecto") y ver los resultados.
Agente basado en Python (infraestructura AG2): en el núcleo del sistema hay un agente basado en Python creado mediante AutoGen (AG2). Este agente coordina el flujo de trabajo desglosando tareas y llamando dinámicamente a herramientas para ejecutar pasos.
El agente tiene acceso a dos herramientas principales:
Herramienta de búsqueda de documentos: obtiene información relevante de una base de datos vectorial que contiene notas de proyectos cargadas o documentos almacenados como incorporaciones. Esta búsqueda vectorial aprovecha las API de recuperación de documentos integradas dentro de Open WebUI, en lugar de configurar un almacén de datos completamente separado.
Herramienta de búsqueda web: realiza búsquedas basadas en la web para recopilar conocimientos externos e información en tiempo real. En este caso, estamos utilizando SearXNG como nuestro metabuscador.
Ollama: El LLM IBM® Granite 3.2 sirve como modelo de lenguaje que impulsa el sistema. Se aloja localmente mediante Ollama, lo que garantiza una inferencia rápida, rentabilidad y privacidad de datos. Si está interesado en ejecutar este proyecto con modelos más grandes, se prefiere al acceso a la API a través de IBM® watsonx.ai u OpenAI, por ejemplo. Sin embargo, este enfoque requiere una clave de API watsonx.ai u OpenAI. En su lugar, utilizamos Ollama alojado localmente en este tutorial.
Otros marcos de agente de código abierto comunes que no se tratan en este tutorial incluyen LangChain, LangGraph y crewAI.
Las instrucciones detalladas de configuración, así como todo el proyecto, se pueden ver en IBM® Granite Community GitHub. La versión para Jupyter Notebook de este tutorial también se puede encontrar en GitHub.
Los siguientes pasos proporcionan una configuración rápida para el agente de recuperación de Granite.
Paso 1: Instalar Ollama
Instalar Ollama es tan simple como descargar el cliente del sitio oficial de Ollama. Después de instalar Ollama, ejecute el siguiente comando para extraer el LLM Granite 3.2.
Ya está en marcha con Ollama y Granite.
Paso 2. Crear un agente simple (opcional)
Una solución de código bajo para crear flujos de trabajo agénticos es AutoGen Studio. Sin embargo, crear un agente simple nosotros mismos puede ayudarnos a comprender mejor la configuración de este proyecto completo de RAG multiagente. Para continuar, configure un Jupyter Notebook en su entorno de desarrollo integrado (IDE) preferido y active un entorno virtual ejecutando los siguientes comandos en su terminal.
python3.11 -m venv venv
source venv/bin/activate
Necesitaremos algunas bibliotecas y módulos para este sencillo agente. Asegúrese de instalar e importar los siguientes.
!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
Hay hay varios parámetros de configuración para establecer localmente para invocar el LLM correcto que extrajimos mediante Ollama.
ollama_llm_config = {
"config_list": [
{
"model": "granite3.2:8b",
"api_type": "ollama",
}
],
}
Podemos pasar estos parámetros de configuración en el parámetro llm_config de la clase AssistantAgent para crear una instancia de nuestro primer agente de IA.
assistant = AssistantAgent(
name="assistant",
system_message="You are a helpful assistant.",
llm_config=ollama_llm_config,
)
Este agente utiliza Granite 3.2 para sintetizar la información devuelta por el agente ragproxyagent. El documento que proporcionamos al agente RAG como contexto adicional es el archivo README Markdown sin procesar que se encuentra en el repositorio de AutoGen en GitHub. Además, podemos pasar un nuevo diccionario de configuraciones específicas para el agente de recuperación. Algunas claves adicionales que pueden resultarle útiles son vector_db, chunk_token_size e embedding_model.
Para obtener una lista completa de las claves de configuración, consulte la documentación oficial.
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",
)
Ahora, podemos iniciar un chat con nuestro agente de RAG para hacerle una pregunta relacionada con el documento proporcionado como contexto.
qs = "What languages does AutoGen support?"
result = ragproxyagent.initiate_chat(
assistant, message=ragproxyagent.message_generator, problem=qs
)
print(result)
Tenga en cuenta que el contenido del archivo README Markdown se ha eliminado del resultado por brevedad.
Resultado:
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 (al asistente):
Eres un chatbot aumentado de recuperación. Responde a las preguntas del usuario en función de tus propios conocimientos y del contexto proporcionado por el usuario.
Si no puedes responder a la pregunta con o sin el contexto actual, debes responder exactamente `UPDATE CONTEXT`.
Debes dar una respuesta lo más breve posible.
La pregunta del usuario es: ¿Qué lenguajes admite AutoGen?
El contexto es:
[ELIMINADO]
----------------------------------------------- --------------------------------- asistente (a ragproxyagent):
El texto proporcionado parece ser un Archivo README para el proyecto AutoGen, una iniciativa de código abierto de Microsoft. Este un resumen de su contenido:
- Descripción general del proyecto: AutoGen es un sistema para crear y gestionar aplicaciones complejas y distribuidas. Admite varios lenguajes (C#, Python) y proporciona un entorno de tiempo de ejecución para desplegar y escalar estas aplicaciones.
- Componentes clave:
- AutoGen Core: la biblioteca central que contiene las clases e interfaces fundamentales para crear aplicaciones de AutoGen. - AutoGen Agent: un componente de tiempo de ejecución responsable de gestionar el ciclo de vida de las aplicaciones de AutoGen. - AutoGen Runtime Gateway: un servicio que facilita la comunicación entre agentes y permite el equilibrio de carga, el escalado y la tolerancia a fallas.
- Lenguajes admitidos: actualmente se admiten C# y Python.
- Primeros pasos: El archivo README proporciona instrucciones sobre cómo instalar los paquetes necesarios, crear un nuevo proyecto y crear/ejecutar una aplicación AutoGen.
- Documentación: enlaces a documentación detallada para referencia, incluidas referencias de API, guías y tutoriales.
- Comunidad y contribución: pautas para contribuir al proyecto, incluida información sobre el seguimiento de problemas, solicitudes de extracción y estándares de programación.
- Avisos legales: información sobre licencias y avisos de marca registrada.
- Soporte y preguntas frecuentes: información sobre cómo hacer preguntas, informar problemas y encontrar respuestas a consultas comunes.
El archivo README también incluye una tabla que resume los paquetes disponibles para cada lenguaje compatible (C# y Python) y sus respectivos administradores de paquetes (NuGet y PyPI). Esto facilita que los desarrolladores identifiquen rápidamente los componentes necesarios para comenzar con AutoGen en su lenguaje preferido.
>>>>>>>> TERMINATING RUN (601a53dc-8a5d-4e19-8503-1517fe3c7634): Termination message condition on agent 'ragproxyagent' met
¡Excelente! Nuestro agente asistente y el agente RAG sintetizaron con éxito el contexto adicional para responder correctamente a la consulta del usuario con los lenguajes de programación actualmente compatibles con AutoGen. Puede pensar en esto como un chat grupal entre agentes que intercambian información. Este ejemplo es una demostración sencilla de la implementación local de RAG agéntica con AutoGen.
Paso 3. Instalar Open WebUI
Ahora, pasemos a construir un sistema RAG agéntico más avanzado. En su terminal, instale y ejecute Open WebUI.
pip install open-webui
open-webui serve
Paso 4. Configurar la búsqueda web
Para la búsqueda web, aprovecharemos las capacidades de búsqueda web integradas en Open WebUI.
Open WebUI admite varios proveedores de búsqueda. En términos generales, puede emplear un servicio de interfaz de programación de aplicaciones (API) de terceros, para el que deberá obtener una clave API, o puede configurar localmente un contenedor Docker SearXNG. En cualquier caso, deberá configurar su proveedor de búsqueda en la consola Open WebUI.
Esta configuración, ya sea un puntero a SearXNG o la entrada de su clave API, se encuentra en Admin Panel > Settings > Web Search en la consola Open WebUI.
Consulte las instrucciones en la documentación de Open WebUI para obtener instrucciones más detalladas.
Paso 5. Importar el agente a Open WebUI
1. En su navegador, vaya a http://localhost:8080/ para acceder a la interfaz de usuario (IU) Open Web. Si es la primera vez que abre la interfaz Open WebUI, registre un nombre de usuario y una contraseña. Esta información se mantiene completamente local en su máquina.
2. Después de iniciar sesión, haga clic en el ícono en la parte inferior izquierda donde se encuentra su nombre de usuario. En el menú, haga clic en el panel Admin.
3. En la pestaña Functions, haga clic en + para agregar una nueva función.
4. Asigne un nombre a la función, como "Granite RAG Agent", y una descripción, de ambos
5. Pegue el script granite_autogen_rag.py de Python en el cuadro de texto provisto, reemplazando cualquier contenido existente.
6. Haga clic en Save en la parte inferior de la pantalla.
7. De vuelta en la página Functions, verifique que el agente esté activado.
8. Haga clic en el ícono de engranaje junto al interruptor de habilitación para personalizar cualquier configuración, como el endpoint de inferencia, el endpoint SearXNG o el ID del modelo.
Ahora, su nuevo agente AutoGen aparece como modelo en la interfaz Open WebUI. Puede seleccionarlo y proporcionarle consultas de los usuarios.
Paso 6. Cargar documentos en Open WebUI 1. En Open WebUI, vaya a Workspace > Knowledge.
- Haga clic en *+ para crear una nueva colección.
- Cargue documentos para que el agente de recuperación de Granite los consulte.
Paso 7. Configurar la búsqueda web en Open WebUI
Para configurar un proveedor de búsqueda (por ejemplo, SearXNG), siga esta guía.
Los parámetros de configuración son los siguientes:
| Parámetro | Descripción | Valor predeterminado |
|---|---|---|
| task_model_id | Modelo principal para la ejecución de tareas | granito3.2:8b |
| vision_model_id | Modelo de visión para análisis de imágenes | granite-vision3.2:2b |
| openai_api_url | Endpoint de API para llamadas de modelo de estilo OpenAI | http://localhost:11434 |
| openai_api_key | Clave de API para autenticación | ollama |
| vision_api_url | Endpoint para tareas relacionadas con la visión | http://localhost:11434 |
| model_temperature | Controla la aleatoriedad de la respuesta | 0 |
| Max_plan_steps | Pasos máximos en la planificación de agentes | 6 |
Nota: Estos parámetros se pueden configurar a través del ícono de ajustes en la sección "Functions" del panel Admin de Open WebUI después de agregar la función.
Paso 8. Consultar el sistema agentic
El agente de recuperación Granite realiza RAG basada en AG2 consultando documentos locales y fuentes web, realizando planificación de tareas multiagente y aplicando la ejecución adaptativa. Inicie un chat y proporcione a su sistema de agentes una consulta relacionada con los documentos proporcionados para ver la cadena RAG en acción.
Una configuración multiagente permite la creación de herramientas prácticas y utilizables aprovechando al máximo los modelos de código abierto de tamaño moderado como Granite 3.2. Esta arquitectura RAG agéntica, creada con herramientas de código abierto, puede servir como punto de partida para diseñar y personalizar sus agentes de respuesta a preguntas y algoritmos de IA. También se puede usar de otras maneras para una amplia gama de casos de uso. En este tutorial, tuvo la oportunidad de profundizar en sistemas agentivos simples y complejos, aprovechando las capacidades de AutoGen. El LLM Granite se invocó mediante el uso de Ollama, lo que permitió una exploración totalmente local de estos sistemas. Como siguiente paso, considere integrar más herramientas personalizadas en su sistema agentivo.
Recursos
Ponga la IA a trabajar en su negocio con la experiencia en IA líder en la industria y la cartera de soluciones de IBM a su lado.
Reinvente los flujos de trabajo y las operaciones críticas añadiendo IA para maximizar las experiencias, la toma de decisiones en tiempo real y el valor empresarial.
Notas de pie de página
[1] Wu, Qingyun, et al. “AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework.” GitHub, 2023, github.com/microsoft/autogen.