Inteligencia artificial, Python

Introducción

Los modelos de inteligencia artificial ejecutados de forma local permiten construir pequeños agentes capaces de recopilar información del sistema, analizarla y generar una explicación comprensible para el usuario.

En este ejemplo vamos a crear un agente muy sencillo utilizando Python y Ollama.

La idea es separar dos tareas:

Python se encarga de ejecutar una herramienta del sistema.
Ollama analiza la información obtenida y explica qué ha ocurrido.

Nuestro primer experimento será muy sencillo: Python realizará un ping contra la puerta de enlace 192.168.1.1 y enviará el resultado a un modelo de lenguaje ejecutado localmente mediante Ollama.

El flujo será:

Python
   │
   │ ejecuta ping
   ▼
192.168.1.1
   │
   │ resultado
   ▼
Python
   │
   │ envía los datos
   ▼
Ollama
   │
   │ analiza
   ▼
Diagnóstico

De esta forma, Ollama no ejecuta comandos directamente. Python recopila los datos y el modelo se limita a interpretarlos.

1. Requisitos

Para realizar el laboratorio necesitamos:

macOS, Linux o Windows.
Python 3.
Ollama.
Un modelo compatible instalado en Ollama.
Acceso a una red local.

En este ejemplo se utiliza un Mac y Ollama con el modelo:

llama3.1:latest

2. Instalar Ollama

Ollama permite ejecutar modelos de inteligencia artificial directamente en el equipo.

Una vez instalado, podemos comprobar que está disponible mediante:

ollama --version

En el laboratorio utilizado para este ejemplo se obtuvo:

ollama version is 0.34.4

Esto confirma que Ollama está instalado.

3. Comprobar que Ollama está funcionando

Ollama proporciona una API local que podemos utilizar desde Python.

La dirección utilizada será:

http://localhost:11434

Podemos comprobar los modelos disponibles ejecutando:

curl http://localhost:11434/api/tags

La respuesta será similar a:

{
  "models": [
    {
      "name": "llama3.1:latest",
      "model": "llama3.1:latest"
    }
  ]
}

También podemos utilizar:

ollama list

Por ejemplo:

NAME              ID              SIZE
llama3.1:latest   46e0c10c039e    4.9 GB

En nuestro caso utilizaremos:

llama3.1:latest

Es importante que el nombre utilizado en Python coincida con uno de los modelos instalados.

4. Instalar la biblioteca requests

Nuestro programa Python utilizará HTTP para comunicarse con la API de Ollama.

Instalamos requests:

pip install requests

En algunos sistemas puede ser necesario utilizar:

pip3 install requests

5. Crear el programa Python

Creamos un archivo denominado:

agente.py

El funcionamiento será muy sencillo.

Primero Python ejecutará:

ping 192.168.1.1

Después capturará:

paquetes enviados;
paquetes recibidos;
pérdida de paquetes;
latencia;
código de salida;
posibles errores.

Toda esta información se enviará posteriormente a Ollama.

6. Código completo del agente

Este es el código completo:

import platform
import subprocess
import requests


# ============================================================
# CONFIGURACIÓN
# ============================================================

OLLAMA_URL = "http://localhost:11434/api/chat"
MODEL = "llama3.1:latest"

HOST = "192.168.1.1"


# ============================================================
# COMPROBAR OLLAMA
# ============================================================

def comprobar_ollama():

    try:

        respuesta = requests.get(
            "http://localhost:11434/api/tags",
            timeout=5
        )

        respuesta.raise_for_status()

        datos = respuesta.json()

        modelos = [
            modelo["name"]
            for modelo in datos.get("models", [])
        ]

        print("[+] Ollama está funcionando.")

        print("[+] Modelos disponibles:")

        for modelo in modelos:
            print(f"    - {modelo}")

        if MODEL not in modelos:
            print()
            print(f"[!] El modelo {MODEL} no está disponible.")

            return False

        print(f"[+] Modelo seleccionado: {MODEL}")

        return True

    except Exception as e:

        print(f"[!] No se puede conectar con Ollama: {e}")

        return False


# ============================================================
# EJECUTAR PING
# ============================================================

def ejecutar_ping(host):

    print()
    print("=" * 60)
    print(f"EJECUTANDO PING CONTRA {host}")
    print("=" * 60)

    sistema = platform.system()

    if sistema == "Windows":

        comando = [
            "ping",
            "-n",
            "4",
            host
        ]

    else:

        # macOS / Linux
        comando = [
            "ping",
            "-c",
            "4",
            host
        ]

    print()
    print("Comando:")
    print(" ".join(comando))
    print()

    try:

        resultado = subprocess.run(
            comando,
            capture_output=True,
            text=True,
            timeout=15
        )

        print("Resultado obtenido:")
        print("-" * 60)
        print(resultado.stdout)

        if resultado.stderr:

            print("STDERR:")
            print(resultado.stderr)

        return resultado

    except subprocess.TimeoutExpired:

        print("[!] El ping ha tardado demasiado.")

        return None

    except Exception as e:

        print(f"[!] Error ejecutando ping: {e}")

        return None


# ============================================================
# ENVIAR INFORMACIÓN A OLLAMA
# ============================================================

def analizar_con_ollama(resultado):

    if resultado is None:

        return "No se pudo ejecutar el ping."

    prompt = f"""
Analiza el resultado de una prueba de conectividad de red.

El equipo analizado es:

{HOST}

Python ha ejecutado un ping y ha obtenido exactamente
la siguiente información:

--------------------------------------------------
SALIDA DEL COMANDO
--------------------------------------------------

{resultado.stdout}

--------------------------------------------------
CÓDIGO DE SALIDA
--------------------------------------------------

{resultado.returncode}

--------------------------------------------------
ERROR
--------------------------------------------------

{resultado.stderr}

--------------------------------------------------

Analiza estos datos.

Quiero que expliques:

1. Si {HOST} responde.
2. Cuántos paquetes se enviaron.
3. Cuántos paquetes se recibieron.
4. El porcentaje de pérdida.
5. La latencia observada.
6. Si existe algún problema.
7. Qué significa el resultado para la conectividad de red.

No inventes ningún dato.

Si algún dato no aparece en la información proporcionada,
indícalo expresamente.

Explica el resultado de forma clara para una persona
que está aprendiendo redes.
"""

    payload = {

        "model": MODEL,

        "messages": [

            {
                "role": "system",
                "content": (
                    "Eres un analista de redes. "
                    "Tu función es interpretar resultados "
                    "de herramientas de diagnóstico. "
                    "Debes basarte exclusivamente en los "
                    "datos proporcionados."
                )
            },

            {
                "role": "user",
                "content": prompt
            }

        ],

        "stream": False
    }

    try:

        print()
        print("=" * 60)
        print("ENVIANDO INFORMACIÓN A OLLAMA")
        print("=" * 60)

        respuesta = requests.post(
            OLLAMA_URL,
            json=payload,
            timeout=120
        )

        respuesta.raise_for_status()

        datos = respuesta.json()

        return datos["message"]["content"]

    except requests.exceptions.ConnectionError:

        return (
            "ERROR: No se ha podido conectar con Ollama."
        )

    except requests.exceptions.HTTPError as e:

        return (
            f"ERROR HTTP de Ollama: {e}\n\n"
            f"Respuesta del servidor:\n"
            f"{respuesta.text}"
        )

    except Exception as e:

        return f"ERROR comunicando con Ollama: {e}"


# ============================================================
# PROGRAMA PRINCIPAL
# ============================================================

def main():

    print()
    print("=" * 60)
    print("     AGENTE DE DIAGNÓSTICO DE RED")
    print("     Python + Ping + Ollama")
    print("=" * 60)
    print()

    # --------------------------------------------------------
    # 1. Comprobar Ollama
    # --------------------------------------------------------

    if not comprobar_ollama():

        print()
        print("[!] No se puede continuar.")

        return

    # --------------------------------------------------------
    # 2. Ejecutar ping
    # --------------------------------------------------------

    resultado = ejecutar_ping(HOST)

    if resultado is None:

        return

    # --------------------------------------------------------
    # 3. Enviar resultado a Ollama
    # --------------------------------------------------------

    analisis = analizar_con_ollama(resultado)

    # --------------------------------------------------------
    # 4. Mostrar análisis
    # --------------------------------------------------------

    print()
    print("=" * 60)
    print("ANÁLISIS DE OLLAMA")
    print("=" * 60)
    print()

    print(analisis)

    print()
    print("=" * 60)
    print("FIN DEL ANÁLISIS")
    print("=" * 60)


# ============================================================
# INICIO
# ============================================================

if __name__ == "__main__":
    main()

7. Ejecutar el agente

Una vez creado el archivo:

python3 agente.py

El programa primero comprueba la conexión con Ollama:

============================================================
     AGENTE DE DIAGNÓSTICO DE RED
     Python + Ping + Ollama
============================================================

[+] Ollama está funcionando.
[+] Modelos disponibles:
    - llama3.1:latest
[+] Modelo seleccionado: llama3.1:latest

Después ejecuta el ping.

En macOS y Linux utilizará:

ping -c 4 192.168.1.1

Mientras que en Windows utilizará:

ping -n 4 192.168.1.1

8. Resultado del ping

Si la puerta de enlace responde, podemos obtener información similar a:

64 bytes from 192.168.1.1:
icmp_seq=0 ttl=64 time=1.234 ms

64 bytes from 192.168.1.1:
icmp_seq=1 ttl=64 time=0.987 ms

64 bytes from 192.168.1.1:
icmp_seq=2 ttl=64 time=1.102 ms

64 bytes from 192.168.1.1:
icmp_seq=3 ttl=64 time=1.050 ms

4 packets transmitted,
4 packets received,
0.0% packet loss

Python captura esta información directamente mediante:

subprocess.run()

La salida no se interpreta manualmente en Python.

Se conserva el resultado original para que pueda ser enviado al modelo.

9. Enviar los datos a Ollama

Una de las partes más interesantes del proyecto es la comunicación entre Python y el modelo de lenguaje.

Python crea una petición HTTP hacia:

http://localhost:11434/api/chat

El cuerpo de la petición contiene el modelo:

"model": "llama3.1:latest"

y los mensajes que se enviarán al modelo.

La información obtenida mediante ping se incorpora al prompt:

{resultado.stdout}

De esta forma, Ollama recibe los datos reales obtenidos por Python.

10. Ollama analiza el resultado

El modelo no ejecuta el ping.

Tampoco necesita acceder directamente a la red.

Su función consiste en analizar la información que Python le proporciona.

Por ejemplo, si recibe:

4 packets transmitted,
4 packets received,
0.0% packet loss

puede generar una explicación como:

El dispositivo 192.168.1.1 responde correctamente.

Se han enviado 4 paquetes y se han recibido los 4,
por lo que no existe pérdida de paquetes.

La latencia observada se encuentra aproximadamente
alrededor de 1 ms.

El resultado indica que existe conectividad con la
puerta de enlace de la red local.

La ventaja de esta aproximación es que el modelo transforma una salida técnica de una herramienta de diagnóstico en una explicación comprensible.

11. ¿Por qué utilizar Python y Ollama por separado?

Una característica importante de este diseño es la separación de responsabilidades.

Python se ocupa de:

ejecutar herramientas;
recopilar información;
controlar errores;
comunicarse con el sistema operativo;
enviar los datos al modelo.

Ollama se ocupa de:

interpretar los datos;
detectar patrones;
explicar resultados;
generar un diagnóstico comprensible.

Podemos representarlo así:

┌─────────────────────┐
│       PYTHON        │
│                     │
│  Ejecuta ping       │
│  Recopila datos     │
│  Controla errores   │
└──────────┬──────────┘
           │
           │ HTTP
           │
           ▼
┌─────────────────────┐
│       OLLAMA        │
│                     │
│   llama3.1:latest   │
│                     │
│  Analiza los datos  │
│  Genera diagnóstico │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│      USUARIO        │
│                     │
│ Explicación del     │
│ resultado           │
└─────────────────────┘

Crear un agente local con Python y Ollama para analizar la conectividad de red (Python, Inteligencia artificial)