Flujos de trabajo con agentes usando Ollama

Qué cubre este artículo

• Qué son los agentes de IA y cómo funcionan.
• Cómo los agentes interactúan con herramientas.
• Cómo construir flujos de trabajo multietapa con Ollama.
• Memoria, planificación y bucles de retroalimentación.
• Ejemplo práctico con Python.

Introducción: Flujos de trabajo con agentes usando Ollama

Un agente de IA va más allá de un simple modelo de lenguaje. Un agente persigue un objetivo, decide por sí solo qué herramientas utilizar, evalúa resultados y ajusta su enfoque. Ollama proporciona una base sólida para estos agentes porque los modelos se ejecutan localmente y las herramientas se pueden invocar fácilmente a través de prompts. Al construir flujos de trabajo multietapa, puedes automatizar tareas complejas como investigación, procesamiento de datos o generación de código.

Este artículo muestra cómo implementar un flujo de trabajo con agentes simple pero funcional usando Ollama.

Conceptos clave

• Agente: Sistema que persigue objetivos y planifica acciones.
• Herramienta: Función externa que el agente invoca.
• ReAct: Razonamiento + Actuación, alternar entre pensar y actuar.
• Memoria: Almacenamiento de acciones y resultados anteriores.
• Planificación: Lograr objetivos paso a paso.
• Bucle de retroalimentación: Verificar resultados y ajustar el enfoque.
• Observación: Observación después de una acción.
• Pensamiento: Paso de razonamiento del agente.

Visión general del flujo de trabajo del agente

Un flujo de trabajo típico funciona así:

1. Establecer el objetivo.
2. Crear un plan.
3. Ejecutar el primer paso o invocar una herramienta.
4. Observar el resultado.
5. Planificar el siguiente paso.
6. Repetir hasta alcanzar el objetivo o el límite máximo de pasos.
7. Generar la respuesta final.

Flujo de trabajo ReAct simple

import requests
import json

def ollama_chat(prompt, model="llama3.1"):
    url = "http://localhost:11434/api/generate"
    payload = {
        "model": model,
        "prompt": prompt,
        "stream": False
    }
    response = requests.post(url, json=payload)
    return response.json()["response"].strip()

def tool_recherche(query):
    return f"Ergebnisse zu {query}: Seite 1, Seite 2, Seite 3."

def tool_rechner(ausdruck):
    try:
        return str(eval(ausdruck))
    except:
        return "Fehler"

prompt = """Der Assistent ist ein Agent. Erstelle die nächste Aktion im Format:
Aktion: [SUCHE] Thema
oder
Aktion: [RECHNE] 2+2

Ziel: Wie viele Seiten hat der BotServ-Artikel "Ollama Befehle"?"""

antwort = ollama_chat(prompt)
print(antwort)

Registrar herramientas

tools = {
    "SUCHE": tool_recherche,
    "RECHNE": tool_rechner,
}

Flujo de trabajo multietapa

def run_agent(ziel, max_steps=10):
    gedaechtnis = []

    for step in range(max_steps):
        kontext = "\n".join(gedaechtnis)
        prompt = f"""Ziel: {ziel}\nBisherige Schritte:\n{kontext}\n\nEntscheide die nächste Aktion. Format: Aktion: [NAME] Parameter"""
        antwort = ollama_chat(prompt)

        if "ENDE" in antwort:
            return antwort.replace("Aktion: ENDE", "")

        if antwort.startswith("Aktion:"):
            _, rest = antwort.split(":", 1)
            name, param = rest.strip().split(" ", 1)
            name = name.replace("[", "").replace("]", "")
            ergebnis = tools.get(name, lambda x: f"Unbekanntes Tool {name}")(param)
            gedaechtnis.append(f"Schritt {step + 1}: {antwort}\nErgebnis: {ergebnis}")
        else:
            gedaechtnis.append(f"Schritt {step + 1}: {antwort}")

    return "Maximale Schrittzahl erreicht."

print(run_agent("Suche nach Ollama Befehle und addiere die Anzahl der gelisteten Seiten"))

Memoria

Un agente necesita memoria para trabajar de forma coherente. Los enfoques simples incluyen:

• Cadena con pasos anteriores en el prompt.
• Lista que se amplía paso a paso.
• Base de datos vectorial para conversaciones más largas.
• Archivo o base de datos para almacenamiento persistente.

Planificación

Antes de ejecutar, el modelo puede crear un plan:

plan_prompt = f"""Erstelle einen kurzen Plan aus max. 5 Schritten für folgendes Ziel:

Ziel: {ziel}

Format:
1. Schritt
2. Schritt
"""

plan = ollama_chat(plan_prompt)
print(plan)

Bucles de retroalimentación

Después de cada paso, el agente verifica si el resultado avanza hacia el objetivo:

eval_prompt = f"""Bewerte kurz, ob dieses Ergebnis dem Ziel dient:

Ziel: {ziel}
Ergebnis: {ergebnis}

Antworte mit FORTFAHREN oder ZURUECKSETZEN."""

Diseñar herramientas correctamente

• Nombres claros.
• Descripciones concisas.
• Formatos de parámetros estrictos.
• Manejo de errores durante la ejecución.
• Devoluciones en formato definido.

Seguridad

• Validar entradas antes de ejecutar herramientas.
• No usar eval sin restricciones.
• Ejecutar herramientas de código de forma aislada.
• Prohibir bucles infinitos.
• Mantener registros de auditoría.
• No pasar datos sensibles a herramientas sin protección.

Enlaces e información adicional

• BotServ.de Ollama MCP
• BotServ.de Ollama Automatisierung
• BotServ.de Ollama Prompt-Engineering
• BotServ.de Agenten-Speicher

Preguntas frecuentes: Flujos de trabajo con agentes

¿Se necesita LangChain para construir agentes? No, los flujos de trabajo simples funcionan bien con Python y Ollama.

¿Pueden los agentes de Ollama ejecutar tareas complejas? Sí, siempre que la lógica esté bien estructurada.

¿Cuántas herramientas pueden estar disponibles simultáneamente? Varias, pero demasiadas pueden sobrecargar modelos más pequeños.

¿Cuál es la diferencia entre RAG y agentes? RAG recupera conocimiento, los agentes planifican y ejecutan acciones.

¿Son los agentes más lentos? Sí, porque requieren múltiples llamadas.

Fuentes y lecturas adicionales

• ReAct Paper: https://arxiv.org/abs/2210.03629
• LangChain Agents: https://python.langchain.com/docs/modules/agents/
• Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md

Resumen: Flujos de trabajo con agentes usando Ollama

Los flujos de trabajo con agentes amplían Ollama añadiendo planificación, uso de herramientas y bucles de retroalimentación. Con un prompt bien estructurado, memoria y algunas herramientas simples, es posible construir un agente funcional. Lo importante es contar con acciones estrictas, validación de entrada y un límite de pasos para evitar bucles infinitos. Para aplicaciones más complejas, frameworks como LangChain pueden resultar útiles, pero en muchos casos una implementación ligera propia es suficiente.