Differences

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

--- informatica:inteligencia_artificial:agentes [2025/10/16 08:21] – jose
+++ informatica:inteligencia_artificial:agentes [2025/12/05 07:59] (current) – jose
@@ Line 7: / Line 7: @@
   DIR_OLLAMA=/media/jose/2Tb/ia/ollama
   docker run --name ollama -v $DIR_OLLAMA/scrics:/scrics -v $DIR_OLLAMA/usr_local_lib:/usr/local/lib -v $DIR_OLLAMA/root_ollama:/root/.ollama -ti debian
+MAC ponemos mas memoria al docker:
+  docker run -d --name ollama -p 11434:11434 --memory="16g" -v $DIR_OLLAMA/scrics:/scrics -v $DIR_OLLAMA/usr_local_lib:/usr/local/lib -v $DIR_OLLAMA/root_ollama:/root/.ollama -ti debian
   apt-get install -y curl python3-venv
 Instalamos ollama. Lo instala en /usr/local/lib/ollama
   curl -fsSL https://ollama.com/install.sh | sh
+  python3 -m venv /ollama-agente
+  source /ollama-agente/bin/activate
 Arrancamos ollama:
   ollama serve
@@ Line 17: / Line 25: @@
   ollama pull llama3.1:70b
   ollama pull llama3.1:8b
+  ollama pull codellama:13b
+  ollama pull qwen2.5-coder:7b
+  ollama pull deepseek-coder-v2:16b
+Para ver los que tenemos:
+  ollama list
+  NAME             ID              SIZE      MODIFIED
+  llama3.1:8b      46e0c10c039e    4.9 GB    About a minute ago
+  codellama:13b    9f438cb9cd58    7.4 GB    38 minutes ago
-  python3 -m venv /ollama-agente
-  source /ollama-agente/bin/activate
 Para ejecutar un modelo concreto:
   ollama run llama3.1:8b
-Instalamos las tools:
+Esto es solo LLM, si le preguntamos por algo que tenga que interactuar nos dice:
-  pip install langchain langchain-ollama
+  >>> ¿que tiempo va a hacer mañana en Madrid?
-. 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
+Lo siento, pero no tengo acceso a información de tiempo real o actualizada sobre el clima. Sin embargo, puedo
-from langchain_core.prompts import ChatPromptTemplate
+sugerirte algunas formas de obtener la información que buscas:
-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)
+Ojo porque si le preguntamos lo mismo a codellama:13b nos responde pero se lo ha inventado:
+  ollama run codellama:13b
-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
+I can provide you with information about the weather in Madrid, but I cannot predict the future. However, I can
-import subprocess
+tell you the current weather conditions and forecast for Madrid.
-# Usamos el decorador @tool de LangChain para convertir la función Python
+According to data from AEMET (the Spanish National Meteorological Agency), the current weather conditions in
-# en una herramienta que el LLM puede entender.
+Madrid are:
-@tool
+* Temperature: 15°C (59°F)
-def ejecutar_comando_terminal(comando: str) -> str:
+* Humidity: 60%
-    """
+* Wind: 2 km/h (1.2 mph)
-    Ejecuta un comando en la terminal (shell) del sistema operativo.
+* Clouds: Scattered clouds
-    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:
+As for the forecast, AEMET predicts that the weather will be mostly sunny with a high of 22°C (72°F) and a low of
-        return f"Excepción al ejecutar el comando: {e}"
+°C (48°F) on Monday. There is a chance of scattered thunderstorms in the afternoon.
-# Lista de herramientas disponibles para el agente
-tools = [ejecutar_comando_terminal]
+Please note that this information may not reflect the actual weather conditions in Madrid, as weather can change
+rapidly and it's always best to check with local authorities or a reliable weather source for the most up-to-date
+information.
 </code>
+Esto es porque se lo inventa, porque codellama está entrenado para usar APIs y generar código y entonces se inventa que lo puede conseguir. Si le preguntamos:
-. Unir y Ejecutar el Agente (El Bucle de Tools Calling)
+  >>> ¿Cuál es la temperatura exacta AHORA MISMO en Madrid?
-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
+No puedo proporcionarte la temperatura exacta en Madrid AHORA MISMO. La información meteorológica actual se basa
-# LangChain usa las descripciones de las funciones (docstrings) para crear el JSON Schema
+en los datos de las estaciones meteorológicas, que pueden estar ubicadas en diferentes puntos de la ciudad y puede
-# que Ollama necesita.
+haber un delay entre el momento en que se toma la medición y el momento en que se hace disponible.
-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
+Sin embargo, puedo proporcionarte una predicción de la temperatura para Madrid en función de las condiciones
-    print("\n--- Paso 2: Enviando el resultado al LLM para la respuesta final ---")
+meteorológicas actuales y previstas. Por ejemplo, si la temperatura en Madrid es de 15°C ahora mismo, podría
+predecirse que suba a 17°C en los próximos días si la temperatura promedio es de 16°C durante el día y baja a 9°C
-    # Para la respuesta final, es necesario enviar el historial completo, incluyendo
+por la noche.
-    # 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:
+Por favor, tenga en cuenta que estas son solo predicciones y que la temperatura real puede variar según las
-    # Si no hay Tool Call, el modelo responde directamente
+condiciones meteorológicas específicas y locales.
-    print(f"✅ RESPUESTA DIRECTA:\n{response.content}")
 </code>
-Todo el script junto
+====== Tools ======
-<code>
+Para que el LLM tenga acceso a herramientas dinámicas, por ejemplo consulta del tiempo mañana.
-import subprocess
+  pip install ollama
-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>