Differences

This shows you the differences between two versions of the page.

--- informatica:inteligencia_artificial:agentes [2025/10/14 21:44] – [ollama] jose
+++ informatica:inteligencia_artificial:agentes [2025/10/14 22:26] (current) – jose
@@ Line 24: / Line 24: @@
   ollama run llama3.1:8b
+Instalamos las tools:
+  pip install langchain langchain-ollama langchain_community
+. Código para usar el agente:
+Configuración Inicial y Modelo
+Asegúrate de que Ollama esté ejecutándose (ollama serve) y luego define el modelo que usarás.
+<code>
+from langchain_community.chat_models import ChatOllama
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+# 1. Definir el modelo que usará el agente
+MODELO_OLLAMA = "llama3.1:8b"
+# 2. Inicializar el LLM
+# Esto crea una conexión con tu modelo local de Ollama
+llm = ChatOllama(model=MODELO_OLLAMA)
+</code>
+. Definición de la Herramienta (Tool)
+En este paso, defines qué acciones puede tomar tu agente. Para que el modelo pueda ejecutar comandos en la terminal (como pediste antes), adaptaremos la función en el formato de LangChain.
+<code>
+from langchain_core.tools import tool
+import subprocess
+# Usamos el decorador @tool de LangChain para convertir la función Python
+# en una herramienta que el LLM puede entender.
+@tool
+def ejecutar_comando_terminal(comando: str) -> str:
+    """
+    Ejecuta un comando en la terminal (shell) del sistema operativo.
+    Usa esta herramienta para probar código o scripts como Playwright.
+    """
+    try:
+        resultado = subprocess.run(
+            comando,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        if resultado.returncode == 0:
+            return f"Comando ejecutado con éxito. Salida:\n{resultado.stdout}"
+        else:
+            # Devuelve el error al LLM para que pueda intentar depurarlo
+            return f"Error en el comando (código: {resultado.returncode}). Error:\n{resultado.stderr}\nSalida:\n{resultado.stdout}"
+    except Exception as e:
+        return f"Excepción al ejecutar el comando: {e}"
+# Lista de herramientas disponibles para el agente
+tools = [ejecutar_comando_terminal]
+</code>
+. Unir y Ejecutar el Agente (El Bucle de Tools Calling)
+Aquí es donde se produce la magia. LangChain usa el método .bind_tools() para informar al modelo de Ollama sobre las funciones que tiene disponibles. LangChain se encarga automáticamente del bucle de "solicitar herramienta → ejecutarla → enviar el resultado de vuelta al modelo".
+<code>
+# 1. Unir el LLM con las herramientas
+# LangChain usa las descripciones de las funciones (docstrings) para crear el JSON Schema
+# que Ollama necesita.
+llm_with_tools = llm.bind_tools(tools)
+# 2. Definir la pregunta para el agente
+user_question = "Asumiendo que tengo un archivo llamado 'test_playwright.js', ejecuta el comando 'node test_playwright.js' en la terminal y dame el resumen del resultado."
+# 3. Primer paso: El modelo decide si usa la herramienta
+print("--- Paso 1: Agente decidiendo la acción ---")
+response = llm_with_tools.invoke(user_question)
+# 4. Comprobar si hay llamadas a herramientas
+if response.tool_calls:
+    print(f"🛠️ Llamada a herramienta detectada: {response.tool_calls[0].get('name')}")
+    # 5. Ejecutar la herramienta (Manualmente para este ejemplo, pero LangChain tiene wrappers de Agente que lo automatizan)
+    # Extraer los argumentos que el LLM generó
+    tool_call = response.tool_calls[0]
+    func_name = tool_call['name']
+    func_args = tool_call['args']
+    # Ejecutar la función real usando los argumentos
+    tool_output = ejecutar_comando_terminal(**func_args)
+    print(f"   -> Comando a ejecutar: {func_args.get('comando')}")
+    print(f"   -> Salida de la terminal: \n{tool_output[:100]}...") # Mostrar un fragmento
+    # 6. Segundo paso: Enviar el resultado de vuelta al modelo
+    print("\n--- Paso 2: Enviando el resultado al LLM para la respuesta final ---")
+    # Para la respuesta final, es necesario enviar el historial completo, incluyendo
+    # la respuesta del LLM y el resultado de la herramienta.
+    messages = [
+        ("user", user_question),
+        response, # Respuesta del LLM que contenía la Tool Call
+        ("tool", tool_output) # Resultado de la ejecución de la herramienta
+    ]
+    # Llamar al modelo por segunda vez con el resultado
+    final_response = llm.invoke(messages)
+    print("\n✅ RESPUESTA FINAL DEL AGENTE:")
+    print(final_response.content)
+else:
+    # Si no hay Tool Call, el modelo responde directamente
+    print(f"✅ RESPUESTA DIRECTA:\n{response.content}")
+</code>
+Todo el script junto
+<code>
+import subprocess
+from langchain_community.chat_models import ChatOllama
+from langchain_core.tools import tool
+# --- PARTE 1: Configuración Inicial y Modelo ---
+# Asegúrate de que Ollama esté ejecutándose (ollama serve)
+MODELO_OLLAMA = "llama3.1:8b"
+llm = ChatOllama(model=MODELO_OLLAMA)
+# ----------------------------------------------------------------------
+# --- PARTE 2: Definición de la Herramienta (Tool) ---
+@tool
+def ejecutar_comando_terminal(comando: str) -> str:
+    """
+    Ejecuta un comando en la terminal (shell) del sistema operativo.
+    Usa esta herramienta para probar código o scripts como Playwright.
+    """
+    print(f"\n[EJECUTANDO COMANDO EN TERMINAL]: {comando}")
+    try:
+        # Usa subprocess para ejecutar el comando
+        resultado = subprocess.run(
+            comando,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=30 # Límite de tiempo de 30 segundos
+        )
+        if resultado.returncode == 0:
+            return f"Comando ejecutado con éxito. Salida:\n{resultado.stdout}"
+        else:
+            # Devuelve el error para que el LLM lo analice
+            return f"Error en el comando (código: {resultado.returncode}). Error:\n{resultado.stderr}\nSalida:\n{resultado.stdout}"
+    except Exception as e:
+        return f"Excepción al ejecutar el comando: {e}"
+# Lista de herramientas disponibles para el agente
+tools = [ejecutar_comando_terminal]
+# ----------------------------------------------------------------------
+# --- PARTE 3: Unir y Ejecutar la Lógica del Agente ---
+# 1. Unir el LLM con las herramientas
+# Esto crea una "cadena" o "Runnable" que sabe cómo manejar las llamadas a herramientas.
+llm_with_tools = llm.bind_tools(tools)
+# 2. Definir la pregunta para el agente
+# **NOTA IMPORTANTE:** Para esta prueba, asegúrate de tener un script 'test_playwright.js'
+# o un entorno Playwright configurado que responda a este comando.
+user_question = (
+    "Asumiendo que tengo un archivo llamado 'test_playwright.js' listo para usar, "
+    "ejecuta el comando 'node test_playwright.js' en la terminal. "
+    "Analiza la salida de la terminal y dame un resumen claro del resultado."
+)
+print(f"Pregunta al agente: {user_question}")
+# 3. Primer Paso: El modelo decide si usa la herramienta
+response = llm_with_tools.invoke(user_question)
+if response.tool_calls:
+    # 4. El Agente ejecuta la Herramienta
+    tool_call = response.tool_calls[0]
+    func_args = tool_call['args']
+    tool_output = ejecutar_comando_terminal(**func_args)
+    # 5. Segundo Paso: Enviar el resultado de vuelta al modelo para la respuesta final
+    # Prepara el historial completo, incluyendo el resultado de la herramienta
+    messages = [
+        ("user", user_question),
+        response, # La respuesta del LLM con la Tool Call
+        ("tool", tool_output) # El resultado de la terminal
+    ]
+    # Llama al modelo por segunda vez para que genere la respuesta final
+    final_response = llm.invoke(messages)
+    print("\n\n#####################################################")
+    print("RESPUESTA FINAL DEL AGENTE (Basada en la ejecución):")
+    print(final_response.content)
+    print("#####################################################")
+else:
+    # Si no hay Tool Call, el modelo responde directamente (no debería pasar en este caso)
+    print(f"\n RESPUESTA DIRECTA (sin usar la herramienta):\n{response.content}")
+</code>