Un asistente de investigación agente impulsado por Groq con LangGraph, llamadas de herramientas, subagentes y memoria agente: vamos a construirlo

En este tutorial, creamos un flujo de trabajo de investigación agente impulsado por Groq que se ejecuta directamente utilizando el punto final de inferencia gratuito compatible con OpenAI de Groq. Configuramos la interfaz ChatOpenAI de LangChain para que funcione con Groq configurando la clave API de Groq y la URL base, lo que nos permite usar modelos alojados rápidos como llama-3.3-70b-versatile para el razonamiento basado en herramientas. Luego conectamos el modelo con herramientas prácticas para búsqueda web, recuperación de páginas web, manejo de archivos, ejecución de Python, carga de habilidades, delegación de subagente y memoria a largo plazo. Al final del tutorial, tenemos un agente de varios pasos basado en Groq que puede investigar un tema, delegar subtareas enfocadas, generar resultados estructurados y guardar información útil para ejecuciones posteriores.

importar subproceso, sys def _pip(*a): subprocess.check_call([sys.executable,"-m","pip","install","-q",*a]) _pip("langgraph>=0.2.50", "langchain>=0.3.0", "langchain-openai>=0.2.0", "langchain-community>=0.3.0", "ddgs", "solicitudes", "beautifulsoup4", "tiktoken", "pydantic>=2.0") importa el sistema operativo, getpass si no os.environ.get("GROQ_API_KEY"): os.environ["GROQ_API_KEY"] = getpass.getpass("GROQ_API_KEY (gratis en console.groq.com/keys): ") os.environ["OPENAI_API_KEY"] = os.environ["GROQ_API_KEY"] os.environ["OPENAI_BASE_URL"] = "https://api.groq.com/openai/v1" MODEL_NAME = "llama-3.3-70b-versatile" import json, re, io, contextlib, pathlib escribiendo import Annotated, TypedDict, Secuencia, Literal, Lista, Dict, Cualquiera desde fecha y hora importar fecha y hora, zona horaria desde langchain_openai importar ChatOpenAI desde langchain_core.messages importar (SystemMessage, HumanMessage, AIMessage, ToolMessage, BaseMessage) desde langchain_core.tools importar herramienta desde langgraph.graph importar StateGraph, END desde langgraph.graph.message importar add_messages de langgraph.prebuild import ToolNode

Instalamos las bibliotecas principales necesarias para crear el flujo de trabajo del agente impulsado por Groq, incluidas las utilidades de búsqueda LangGraph, LangChain, DuckDuckGo y bibliotecas de análisis de soporte. Recopilamos de forma segura la clave API de Groq y configuramos Groq como un punto final compatible con OpenAI configurando la clave API y la URL base. Luego importamos todos los módulos necesarios para mensajes, herramientas, construcción de gráficos, escritura, manejo de sistemas de archivos e inicialización de modelos.

SANDBOX = pathlib.Path("/content/deerflow_sandbox").resolve() para sub en ["uploads","workspace","outputs","skills/public","skills/custom","memory"]: (SANDBOX/sub).mkdir(parents=True, exist_ok=True) def _safe(p: str) -> pathlib.Path: full = (SANDBOX/p.lstrip("/")).resolve() si no str(full).startswith(str(SANDBOX)): elevar ValueError(f"path escapes sandbox: {p}") devolver HABILIDADES completas: Dict[str, Dict[str,str]] = {} def Register_skill(nombre, descripción, contenido, ubicación="public"): d = SANDBOX/"skills"/ubicación/nombre; d.mkdir(parents=True, exist_ok=True) (d/"SKILL.md").write_text(content) SKILLS[name] = {"description": descripción, "content": content, "path": str(d/"SKILL.md")} Register_skill("research", "Realizar una investigación web de múltiples fuentes sobre un tema y producir notas estructuradas.", """# Habilidad de investigación ## Flujo de trabajo 1. Descomponer la pregunta en 3-5 subpreguntas. 2. Para cada subpregunta, llame a `web_search` y elija 2 URL autorizadas. 3. `web_fetch` esas URL; extraiga hechos, números y fechas concretos. ## Mejores prácticas: prefiera fuentes primarias. números.""") Register_skill("generación de informes", "Sintetizar notas de investigación en un informe de rebajas pulido en salidas/.", """# Habilidad de generación de informes ## Flujo de trabajo 1. file_read('workspace/research_notes.md'). 2. Esquema: resumen ejecutivo, hallazgos clave, análisis, conclusión, fuentes. 3. file_write('outputs/report.md', …). ## Estructura – # Título – ## Resumen ejecutivo (3–5 oraciones) – ## Hallazgos clave (viñetas) – ## Análisis detallado (secciones) – ## Conclusión – ## Fuentes (lista de URL numeradas)""") Register_skill("code-execution", "Ejecute Python en el entorno de pruebas para cálculo, procesamiento de datos y gráficos.", """# Habilidad de ejecución de código 1. Planifique primero en lenguaje sencillo. 2. python_exec el código; los artefactos persistentes van a /outputs/. 3. Verifique antes de citar los resultados.""") MEM = SANDBOX/"memory/long_term.json" si no MEM.exists(): MEM.write_text(json.dumps({"facts":[],"preferencias":{}}, sangría=2)) def _load_mem(): devuelve json.loads(MEM.read_text()) def _save_mem(m): MEM.write_text(json.dumps(m, sangría=2))

Creamos un directorio de proyectos en espacio aislado en Colab para mantener las cargas, los archivos del espacio de trabajo, los resultados, las habilidades y la memoria organizados en una única ubicación controlada. Definimos habilidades reutilizables para investigación, generación de informes y ejecución de código para que el agente pueda descubrir y seguir flujos de trabajo estructurados. También inicializamos un archivo JSON de memoria a largo plazo simple que almacena datos y preferencias en múltiples ejecuciones dentro del mismo entorno limitado.

@tool def list_skills() -> str: """Enumere todas las habilidades con descripciones de una línea. Llame a esto primero para tareas complejas.""" return "n".join(f"- {n}: {s['description']}" for n,s in SKILLS.items()) @tool def load_skill(name: str) -> str: """Cargue SKILL.md completo para `name`. Llame antes de ejecutar su flujo de trabajo.""" si el nombre no está en HABILIDADES: devuelve f"Desconocido. Disponible: {lista(HABILIDADES)}" devuelve HABILIDADES[nombre]["contenido"] @tool def web_search(query: str, max_results: int = 5) -> str: """Busca en la web (DuckDuckGo). Devuelve títulos, URL, fragmentos.""" de ddgs import DDGS out =[]intente: con DDGS() como d: para r en d.text(consulta, max_results=max_results): out.append(f"- {r.get('title','')}n URL: {r.get('href','')}n " f"{(r.get('body') or '')[:220]}") excepto excepción como e: return f"error de búsqueda: {e}" return "n".join(out) o "sin resultados" @tool def web_fetch(url: str, max_chars: int = 4000) -> str: """Obtener una URL, devolver texto limpio (scripts/nav eliminado).""" solicitudes de importación desde bs4 import BeautifulSoup intente: r = request.get(url, timeout=15, headers={"User-Agent":"Mozilla/5.0 DeerFlow-Lite"}) sopa = BeautifulSoup(r.text, "html.parser") para s en sopa(["script","style","nav","footer","aside","header"]): s.decompose() text = re.sub(r"ns*n", "nn", sopa.get_text("n")).strip() devuelve texto[:max_chars] o "(página vacía)" excepto excepción como e: return f"fetch error: {e}" @tool def file_write(ruta: str, contenido: str) -> str: """Escribe contenido en una ruta de espacio aislado, por ejemplo, 'workspace/notes.md' o 'outputs/x.md'.""" p = _safe(path); p.parent.mkdir(parents=True, exist_ok=True) p.write_text(content) return f"wrote {len(content)} chars → {path}" @tool def file_read(path: str) -> str: """Leer un archivo sandbox (primeros 8 KB).""" p = _safe(path) return p.read_text()[:8000] if p.exists() else f"not found: {ruta}" @tool def file_list(ruta: str = "") -> str: """Lista de archivos en un directorio de zona de pruebas.""" base = _safe(ruta) si la ruta es otra SANDBOX si no base.exists(): devuelve elementos "no encontrados" =[]para c en sorted(base.rglob("*")): si "memoria" en c.relative_to(SANDBOX).parts: continuar items.append(f" {'D' if c.is_dir() else 'F'} {c.relative_to(SANDBOX)}") return "n".join(items[:60]) o "(empty)" @tool def python_exec(code: str) -> str: """Ejecute Python en el sandbox. SANDBOX_ROOT está preestablecido.""" g = {"__name__":"__sb__", "SANDBOX_ROOT": str(SANDBOX)} buf = io.StringIO() intente: con contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf): exec(code, g) return (buf.getvalue() o "(no stdout)")[:4000] excepto Excepción como e: return f"{type(e).__name__}: {e}n{buf.getvalue()[:1500]}" @tool def recuerda(fact: str) -> str: """Persiste un solo hecho en la memoria a largo plazo (sobrevive a través de ejecuciones)."" m = _load_mem() m["facts"].append({"fact": fact, "ts": datetime.now(timezone.utc).isoformat()}) _save_mem(m) return f"remembered ({len(m['facts'])} total)" @tool def souvenir() -> str: """Recuperar todo en la memoria a largo plazo.""" m = _load_mem() if not m["facts"]: return "(memoria vacía)" return "n".join(f"- {f['fact']}" para f en m["hechos"][-20:])

Definimos las principales herramientas que el agente respaldado por Groq puede llamar durante la ejecución, incluidas las habilidades de listado, la carga de instrucciones de habilidades, la búsqueda en la web, la búsqueda de páginas web, la lectura y la escritura de archivos. También proporcionamos al agente un entorno de ejecución de Python en un espacio aislado para que pueda ejecutar cálculos o generar artefactos cuando sea necesario. Agregamos herramientas de memoria que permiten al agente recordar hechos importantes y recuperar información previamente almacenada.

@tool def spawn_subagent(role: str, task: str, Allow_tools: str = "web_search,web_fetch,file_write,file_read") -> str: """Genera un subagente aislado con un rol enfocado y herramientas con alcance. Devuelve su cadena de informe final. Úselo para subtareas paralelizables/enfocadas.""" bag = {t.name: t for t in BASE_TOOLS} sub_tools = [bag[n.strip()] for n in Allow_tools.split(",") if n.strip() in bag] sub_llm = ChatOpenAI(model=MODEL_NAME, Temperature=0.2).bind_tools(sub_tools) sys_msg = SystemMessage(content=( f"Eres un subagente especializado. Rol: {role}.n" f"Operas en un contexto AISLADO, sin acceso para liderar el historial.n" f"Herramientas: {', '.join(t.name for t in sub_tools)}.n" "Termina con un mensaje asistente final que comienza con 'INFORME FINAL:' " "que contiene un resumen estructurado de ≤700 palabras que incluye todas las URL.")) mensajes: Lista[BaseMessage] = [sys_msg, HumanMessage(content=task)] para _ en el rango(8): r = sub_llm.invoke(msgs); msgs.append(r) si no, getattr(r, "tool_calls", Ninguno): devuelve f"[sub-agente: {rol}]n" + (r.content if isinstance(r.content,str) else str(r.content)) para tc en r.tool_calls: t = bag.get(tc["name"]) intenta: res = t.invoke(tc["args"]) si no f"herramienta desconocida {tc['name']}" excepto excepción como e: res = f"error de herramienta: {e}" msgs.append(ToolMessage(content=str(res)[:3000], tool_call_id=tc["id"])) return f"[sub-agente: {role}] límite de pasos alcanzado". BASE_TOOLS = [list_skills, load_skill, web_search, web_fetch, file_write, file_read, file_list, python_exec, recuerda, recuerda] ALL_TOOLS = BASE_TOOLS + [spawn_subagent] LEAD_SYSTEM = f"""Eres DeerFlow-Lite, un arnés de superagente de largo horizonte. Diseño de Sandbox (relativo a {SANDBOX}): cargas/ – espacio de trabajo de archivos de usuario/ – resultados de su bloc de notas/ – habilidades de entregas finales/ – módulos de capacidad (load_skill) Principios: • Para tareas no triviales: list_skills → load_skill → ejecutar. • Utilice spawn_subagent para subtareas enfocadas (el contexto aislado mantiene los intermedios en el espacio de trabajo/, entregables a salidas/). con un breve resumen de lo que se produjo y dónde hoy: {datetime.now(timezone.utc).strftime('%Y-%m-%d')}.""" class AgentState(TypedDict): mensajes: Annotated[Sequence[BaseMessage], add_messages] llm = ChatOpenAI(model=MODEL_NAME, Temperature=0.3).bind_tools(ALL_TOOLS) def. call_model(estado: AgentState): msgs = list(state["messages"]) si no es msgs o no isinstance(msgs[0], SystemMessage): msgs = [SystemMessage(content=LEAD_SYSTEM)] + msgs return {"messages": [llm.invoke(msgs)]} def route(state: AgentState) -> Literal["tools","__end__"]: last = state["messages"][-1] return "tools" if getattr(last, "tool_calls", Ninguno) else FIN g = StateGraph(AgentState) g.add_node("agente", call_model) g.add_node("herramientas", ToolNode(ALL_TOOLS)) g.set_entry_point("agente") g.add_conditional_edges("agente", ruta, {"herramientas":"herramientas", FIN: FIN}) g.add_edge("herramientas", "agente") APP = g.compilar()

Creamos una herramienta de subagente que permite al agente principal impulsado por Groq delegar tareas enfocadas a un asistente aislado con un conjunto limitado de herramientas. Luego recopilamos todas las herramientas disponibles, definimos el mensaje del sistema principal, inicializamos el modelo de chat respaldado por Groq y vinculamos las herramientas a él. Finalmente creamos el flujo de trabajo LangGraph para que el agente pueda alternar entre el razonamiento y la ejecución de la herramienta hasta llegar a una respuesta final.

def ejecutar(tarea: str, max_steps: int = 25): print("="*78); print(f"🦌 TAREA: {tarea}"); print("="*78) state = {"messages":[HumanMessage(content=task)]} n = 0 para ev en APP.stream(state, {"recursion_limit": max_steps*2}, stream_mode="updates"): para nodo, carga útil en ev.items(): para m en payload.get("messages",[]): n += 1 if isinstance(m, AIMessage): if m.tool_calls: for tc in m.tool_calls: args = json.dumps(tc["args"], sure_ascii=False) args = args[:140] + ("…" if len(args)>140 else "") print(f"[{n:02}] 🔧 {tc['nombre']}({args})") else: txt = m.content if isinstance(m.content,str) else str(m.content) print(f"[{n:02}] 🦌 {txt[:800]}") elif isinstance(m, ToolMessage): s = str(m.content).replace("n"," ")[:220] print(f"[{n:02}] 📤 {s}") print("n"+"="*78); print("✅ COMPLETO – estado de la zona de pruebas:"); print("="*78) print(file_list.invoke({"path":""})) print("n🧠 Memoria a largo plazo:"); print(recall.invoke({})) for f in sorted((SANDBOX/"outputs").rglob("*")): if f.is_file(): print(f"n— 📄 {f.relative_to(SANDBOX)} (primeros 800 caracteres) —") print(f.read_text()[:800]) run( "Dame una sesión informativa sobre modelos de lenguajes pequeños (SLM) en 2025. " "(1) descubrir habilidades; (2) generar un subagente investigador para recopilar " "detalles específicos sobre tres SLM notables de 2024-2025 con tamaños, puntos de referencia y " "casos de uso: el subagente guarda en workspace/slm_research.md " "(3) cargar la habilidad de generación de informes y escribir resultados/slm_briefing.md " "(~400 palabras) con Fuentes; sección (4) guardar " "la conclusión más importante en la memoria a largo plazo (5) resumir.", max_steps=25, )

Definimos la función run() que inicia una tarea de usuario, transmite cada paso del agente e imprime llamadas a herramientas, resultados de herramientas y respuestas finales en un formato legible. También mostramos la estructura de archivos de la zona de pruebas, la memoria a largo plazo y los archivos de salida generados una vez que se completa el flujo de trabajo. Terminamos ejecutando una tarea de demostración en la que el agente impulsado por Groq investiga pequeños modelos de lenguaje, prepara una sesión informativa, guarda un informe y almacena una conclusión clave en la memoria.

En conclusión, creamos un marco de agente compacto pero capaz basado en Groq que demuestra cómo la API compatible con OpenAI de Groq puede servir como un backend rápido y accesible para flujos de trabajo avanzados de LLM. Usamos LangGraph para administrar el bucle del agente, LangChain para vincular herramientas al modelo alojado en Groq y utilidades personalizadas de Python para brindarle al sistema acceso controlado a la búsqueda, los archivos, la ejecución de código y la memoria. También demostramos cómo los subagentes aislados pueden ayudar a manejar tareas de investigación enfocadas mientras el agente principal coordina el flujo de trabajo general. Además, terminamos con un práctico sistema de agentes impulsado por Groq que se puede ampliar a asistentes de investigación, generadores de información automatizados y aplicaciones de inteligencia artificial de varios pasos.

Consulte los códigos completos con Notebook aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 130.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.

¿Necesita asociarse con nosotros para promocionar su repositorio de GitHub O su página principal de Hugging O su lanzamiento de producto O seminario web, etc.? Conéctate con nosotros