Cómo construir una canalización sólida de múltiples agentes utilizando CAMEL con planificación, razonamiento aumentado en la web, crítica y memoria persistente

En este tutorial, creamos un flujo de trabajo de investigación avanzado de múltiples agentes de un extremo a otro utilizando el marco CAMEL. Diseñamos una sociedad coordinada de agentes, planificador, investigador, escritor, crítico y finalizador, que en colaboración transforman un tema de alto nivel en un informe de investigación pulido y basado en evidencia. Integramos de forma segura la API OpenAI, organizamos las interacciones de los agentes mediante programación y agregamos memoria persistente liviana para retener el conocimiento en todas las ejecuciones. Al estructurar el sistema en torno a roles claros, contratos basados ​​en JSON y refinamiento iterativo, demostramos cómo se puede utilizar CAMEL para construir canales de agentes confiables, controlables y escalables. Consulta los CÓDIGOS COMPLETOS aquí.

!pip -q instalar “camello-ai[all]” “python-dotenv” “rico” importar sistema operativo importar json tiempo de importación desde escribir importar Dict, Cualquiera de importación rica imprimir como rprint def load_openai_key() -> str: clave = Ninguno intentar: desde google.colab importar datos de usuario clave = userdata.get(“OPENAI_API_KEY”) excepto Excepción: clave = Ninguna si no clave: importar clave getpass = getpass.getpass(“Ingrese OPENAI_API_KEY (oculto): “).strip() si no es clave: aumente ValueError(“Se requiere OPENAI_API_KEY.”) clave de retorno os.environ[“OPENAI_API_KEY”] = cargar_openai_key()

Configuramos el entorno de ejecución y cargamos de forma segura la clave API de OpenAI utilizando secretos de Colab o un mensaje oculto. Nos aseguramos de que el tiempo de ejecución esté listo instalando dependencias y configurando la autenticación para que el flujo de trabajo pueda ejecutarse de forma segura sin exponer las credenciales. Consulta los CÓDIGOS COMPLETOS aquí.

de camel.models importar ModelFactory de camel.types importar ModelPlatformType, ModelType de camel.agents importar ChatAgent de camel.toolkits importar SearchToolkit MODEL_CFG = {“temperatura”: 0.2} modelo = ModelFactory.create( model_platform=ModelPlatformType.OPENAI, model_type=ModelType.GPT_4O, model_config_dict=MODEL_CFG,)

Inicializamos la configuración del modelo CAMEL y creamos una instancia de modelo de lenguaje compartido utilizando la abstracción ModelFactory. Estandarizamos el comportamiento del modelo en todos los agentes para garantizar un razonamiento consistente y reproducible en todo el proceso de múltiples agentes. Consulta los CÓDIGOS COMPLETOS aquí.

MEM_PATH = “camel_memory.json” def mem_load() -> Dict[str, Any]: si no os.path.exists(MEM_PATH): devuelve {“ejecuta”: []} con open(MEM_PATH, “r”, encoding=”utf-8″) como f: return json.load(f) def mem_save(mem: Dict[str, Any]) -> Ninguno: con open(MEM_PATH, “w”, encoding=”utf-8″) como f: json.dump(mem, f, sure_ascii=False, indent=2) def mem_add_run(tema: str, artefactos: Dict[str, str]) -> Ninguno: mem = mem_load() mem[“runs”].append({“ts”: int(time.time()), “topic”: topic, “artifacts”: artefactos}) mem_save(mem) def mem_last_summaries(n: int = 3) -> str: mem = mem_load() ejecuta = mem.get(“ejecuta”, [])[-n:]
si no se ejecuta: devuelve “No hay ejecuciones pasadas”. devolver “\n”.unirse([f”{i+1}. topic={r[‘topic’]} | ts={r[‘ts’]}” para i, r en enumerar (ejecuciones)])

Implementamos una capa de memoria persistente liviana respaldada por un archivo JSON. Almacenamos artefactos de cada ejecución y recuperamos resúmenes de ejecuciones anteriores, lo que nos permite introducir continuidad y contexto histórico entre las sesiones. Consulta los CÓDIGOS COMPLETOS aquí.

def make_agent(role: str, goal: str, extra_rules: str = “”) -> ChatAgent: system = ( f”Usted es {role}.\n” f”Objetivo: {goal}\n” f”{extra_rules}\n” “La salida debe ser nítida, estructurada y utilizable directamente por el siguiente agente.” ) return ChatAgent(model=model, system_message=system) planificador = make_agent( “Planificador”, “Crear un plan compacto y preguntas de investigación con criterios de aceptación.”, “Devolver JSON con claves: plan, preguntas, criterios_de_aceptación.” ) investigador = make_agent( “Investigador”, “Responder preguntas usando resultados de búsqueda web.”, “Devolver JSON con claves: hallazgos, fuentes, preguntas_abiertas.” ) escritor = make_agent( “Escritor”, “Redactar un resumen de investigación estructurado.”, “Devolver solo Markdown”. ) crítico = make_agent( “Crítico”, “Identificar debilidades y sugerir soluciones.”, “Devolver JSON con claves: problemas, correcciones, reescribir_instrucciones.”[search_tool])

Definimos los roles principales de los agentes y sus responsabilidades dentro del flujo de trabajo. Construimos agentes especializados con objetivos claros y contratos de resultados, y mejoramos al Investigador adjuntando una herramienta de búsqueda web para respuestas basadas en evidencia. Consulta los CÓDIGOS COMPLETOS aquí.

def step_json(agente: ChatAgent, mensaje: str) -> Dict[str, Any]: res = agente.paso(mensaje) txt = res.msgs[0].content.strip() intente: devolver json.loads(txt) excepto Excepción: devolver {“raw”: txt} def step_text(agente: ChatAgent, mensaje: cadena) -> cadena: res = agente.step(prompt) devolver res.msgs[0].contenido

Abstraemos los patrones de interacción con los agentes en funciones auxiliares que imponen resultados JSON estructurados o de texto libre. Simplificamos la orquestación manejando el análisis y la lógica alternativa de manera centralizada, lo que hace que la canalización sea más robusta ante la variabilidad de formato. Consulta los CÓDIGOS COMPLETOS aquí.

def run_workflow(tema: str) -> Dict[str, str]: rprint(mem_last_summaries(3)) plan = step_json( planificador, f”Tema: {tema}\nCrea un plan detallado y preguntas de investigación.” ) research = step_json( investigador, f”Investiga el tema usando la búsqueda web.\n{json.dumps(plan)}” ) draft = step_text( escritor, f”Escribe un resumen de investigación usando:\n{json.dumps(research)}” ) critique = step_json( critic, f”Critica el borrador:\n{borrador}” ) final = step_text( finalizer, f”Reescribir usando critique:\n{json.dumps(critique)}\nDraft:\n{draft}” ) artefactos = { “plan_json”: json.dumps(plan, indent=2), “research_json”: json.dumps(research, indent=2), “draft_md”: draft, “critique_json”: json.dumps(critique, indent=2), “final_md”: final, } mem_add_run(topic, artefactos) devuelve artefactos TEMA = “Flujo de trabajo de investigación de agentes múltiples con control de calidad” artefactos = run_workflow(TOPIC) print(artifacts[“final_md”])

Orquestamos el flujo de trabajo completo de múltiples agentes desde la planificación hasta la finalización. Pasamos secuencialmente artefactos entre agentes, aplicamos un refinamiento basado en críticas, conservamos los resultados en la memoria y producimos un resumen de investigación finalizado listo para su uso posterior.

En conclusión, implementamos un práctico sistema multiagente basado en CAMEL que refleja los flujos de trabajo de investigación y revisión del mundo real. Mostramos cómo los roles de los agentes claramente definidos, el razonamiento mejorado con herramientas y el refinamiento impulsado por la crítica conducen a resultados de mayor calidad al tiempo que reducen las alucinaciones y las debilidades estructurales. También establecimos una base para la extensibilidad al conservar los artefactos y permitir la reutilización entre sesiones. Este enfoque nos permite ir más allá de las interacciones de un solo mensaje y hacia sistemas agentes robustos que pueden adaptarse para tareas de investigación, análisis, informes y apoyo a la toma de decisiones a escala.

Consulta los CÓDIGOS COMPLETOS aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 100.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.

Michal Sutter es un profesional de la ciencia de datos con una Maestría en Ciencias de Datos de la Universidad de Padua. Con una base sólida en análisis estadístico, aprendizaje automático e ingeniería de datos, Michal se destaca en transformar conjuntos de datos complejos en conocimientos prácticos.