Ollama para agentes de IA

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué trata este artículo sobre Ollama para agentes de IA

• Cómo funciona Ollama como servidor de modelos para agentes de IA.
• Qué frameworks soportan Ollama y cómo conectarlos.
• Cómo funciona Function Calling con Ollama y qué modelos son adecuados.
• Cómo construir un agente simple con Ollama y LangGraph.
• Qué obstáculos típicos surgen en agentes locales y cómo resolverlos.

Introducción: Ollama como servidor de modelos para agentes de IA

Los agentes de IA son programas que planifican de forma autónoma, invocan herramientas y completan tareas. Necesitan un modelo de lenguaje que tome decisiones y genere las llamadas a herramientas. Ollama es un servidor de modelos local que proporciona exactamente eso: un modelo accesible a través de una API REST que soporta Function Calling.

Este artículo está dirigido a desarrolladores que deseen construir agentes de IA con modelos locales. Deberías entender qué son los agentes de IA, cómo funciona el tool calling y cómo instalar Ollama. Conocimientos básicos de Python son útiles para los ejemplos de código. Si quieres aprender Python, encontrarás tutoriales en IRC-Coding.de.

¿Por qué necesito Ollama para agentes de IA?

Imagina que construyes un agente que lee correos electrónicos, los clasifica y los reenvía al departamento correcto. El agente utiliza un modelo de lenguaje para determinar la categoría e invoca funciones para reenviar el correo.

Si alquilas el modelo a un proveedor en la nube, pagas por cada solicitud. Con 1000 correos al día y 0,001 euros por solicitud, son 1 euro al día, 365 euros al año. Además vienen las preocupaciones de privacidad: cada correo se envía a un proveedor externo.

Con Ollama ejecutas el modelo localmente. Después de la inversión en hardware, solo pagas la electricidad. Los correos nunca salen de tu red. Eres independiente de los límites de API, aumentos de precio o apagones de servicio.

Ollama para agentes de IA explicado brevemente

Ollama es un servidor de modelos que se ejecuta localmente en tu hardware. Proporciona una API REST a través de la cual puedes consultar modelos. Para agentes de IA, lo más importante es Function Calling: el modelo puede definir funciones que está autorizado a invocar y genera llamadas estructuradas que tu código ejecuta.

La idea central es simple: Ollama proporciona el modelo, tu código proporciona la lógica, el modelo decide qué herramientas invocar.

¿Para quién es Ollama para agentes de IA?

• Desarrolladores que desean construir agentes de IA con modelos locales.
• Empresas que no quieren entregar cargas de trabajo críticas para la privacidad a la nube.
• Aficionados que construyen agentes para automatización personal.
• Investigadores que evalúan modelos para flujos de trabajo de agentes.

Los conocimientos previos en Python, APIs e ingeniería básica de prompts son útiles. Si nunca has trabajado con Function Calling, deberías leer primero los conceptos fundamentales.

Términos importantes relacionados con Ollama y agentes de IA

• Ollama - Servidor de modelos local. Útil cuando: como backend de modelo para cualquier agente local.
• Function Calling - Capacidad del modelo para invocar funciones. Útil cuando: el agente debe usar herramientas.
• LangGraph - Framework de agentes basado en grafos. Útil cuando: para agentes complejos con estados.
• CrewAI - Framework multi-agentes. Útil cuando: varios agentes colaboran.
• OpenClaw - Plataforma de agentes de código abierto. Útil cuando: para self-hosting de agentes.
• MCP - Model Context Protocol. Útil cuando: conectar agentes con herramientas externas.
• Ollama REST API - API HTTP para consultas de modelo. Útil cuando: accedes a Ollama directamente.

¿Qué frameworks soportan Ollama?

La mayoría de frameworks de agentes comunes soportan Ollama como backend de modelo. La integración es generalmente simple porque Ollama proporciona una API compatible con OpenAI.

La integración funciona generalmente así: instalas el framework, configuras Ollama como backend de modelo y defines tus herramientas. El framework invoca Ollama cuando el modelo necesita tomar una decisión y ejecuta las llamadas a herramientas generadas.

Function Calling con Ollama

Function Calling es la capacidad más importante para agentes de IA. El modelo recibe una lista de funciones que puede invocar y decide según la solicitud del usuario cuál es relevante. Genera una llamada estructurada que tu código ejecuta.

Ollama soporta Function Calling desde la versión 0.3.0. Los modelos que son adecuados para esto incluyen:

• Llama 3.1 8B - Pequeño, rápido, bueno para agentes simples.
• Qwen 2.5 14B - Más grande, mejor en llamadas a herramientas complejas.
• Mistral Nemo 12B - Equilibrado, bueno en selección de herramientas.
• Llama 3.3 70B - Grande, si tu hardware lo permite.

Un ejemplo con la API REST de Ollama:

import requests
import json

OLLAMA_URL = "http://localhost:11434/api/chat"

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtiene el clima actual para una ubicación",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Nombre del lugar, p.ej. 'Berlín'"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = requests.post(OLLAMA_URL, json={
    "model": "llama3.1",
    "messages": [
        {"role": "user", "content": "¿Cuál es el clima en Berlín?"}
    ],
    "tools": tools,
    "stream": False
})

result = response.json()
print(json.dumps(result, indent=2, ensure_ascii=False))

El modelo genera una llamada a herramienta que se incluye en la respuesta. Tu código ejecuta la función get_weather y devuelve el resultado al modelo, que genera a partir de él la respuesta final.

Ejemplo práctico: un agente con Ollama y LangGraph

Imagina que quieres un agente que realice investigaciones. Debe buscar en internet, resumir resultados y generar una respuesta final. Con Ollama y LangGraph se ve así:

from langchain_ollama import ChatOllama
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    next_step: str

llm = ChatOllama(model="llama3.1", temperature=0)

def search_node(state: AgentState):
    # Función de búsqueda simulada
    query = state["messages"][-1]["content"]
    results = f"Resultados de búsqueda para: {query}"
    return {"messages": [{"role": "system", "content": results}]}

def summarize_node(state: AgentState):
    # Resumen con LLM
    context = "\n".join([m["content"] for m in state["messages"]])
    response = llm.invoke(f"Resume lo siguiente: {context}")
    return {"messages": [{"role": "assistant", "content": response.content}]}

def should_continue(state: AgentState):
    if "buscar" in state["messages"][-1]["content"].lower():
        return "search"
    return "summarize"

workflow = StateGraph(AgentState)
workflow.add_node("search", search_node)
workflow.add_node("summarize", summarize_node)
workflow.set_entry_point("search")
workflow.add_conditional_edges("search", should_continue)
workflow.add_edge("summarize", END)

app = workflow.compile()
result = app.invoke({"messages": [{"role": "user", "content": "Busca sobre IA local"}]})
print(result["messages"][-1]["content"])

Este agente pasa por varios estados: búsqueda, resumen, fin. Ollama proporciona el modelo, LangGraph orquesta el flujo. El modelo decide si se necesitan pasos adicionales.

Conectar Ollama con MCP

El Model Context Protocol (MCP) es un estándar que permite a los agentes acceder a herramientas externas. En lugar de escribir definiciones de herramientas propias para cada agente, usas servidores MCP que proporcionan las herramientas.

Ollama en sí no es un cliente MCP, pero la mayoría de frameworks de agentes que soportan Ollama también pueden usar MCP. LangGraph, CrewAI y OpenClaw tienen integraciones con MCP.

Un setup típico funciona así:

1. Ollama se ejecuta como servidor de modelos en localhost:11434.
2. Servidores MCP proporcionan herramientas (por ejemplo, sistema de archivos, base de datos, búsqueda web).
3. Framework de agentes conecta Ollama con el servidor MCP.
4. El agente invoca Ollama cuando necesita tomar una decisión.
5. El modelo genera una llamada de herramienta que el framework ejecuta a través de MCP.

Encontrarás detalles sobre cómo construir tu propio servidor MCP en el artículo Construir servidores MCP.

Elegir modelos para agentes

La elección del modelo influye enormemente en la calidad del agente. Un modelo demasiado pequeño no entiende correctamente las llamadas de herramientas, mientras que uno demasiado grande es lento y requiere mucha VRAM.

Es fundamental probar el modelo antes de ponerlo en producción. El artículo Evaluación de Ollama explica cómo comparar modelos de forma sistemática. Para Function Calling, debes probar el modelo con tus herramientas específicas, ya que no todos los modelos entienden igual de bien cada esquema de herramientas.

Errores comunes con agentes de Ollama

• Modelo incorrecto: Un modelo de 7B no funciona bien en llamadas complejas de herramientas. Antes de usar uno, verifica que entienda correctamente tus herramientas.
• Sin manejo de errores: Cuando falla una llamada de herramienta, el agente debe detectarlo y reaccionar. Un agente que se bloquea con cada error no está listo para producción.
• Demasiadas herramientas: Un modelo con 20 herramientas se satura. Es mejor tener pocas herramientas bien definidas que muchas vagas.
• Sin límite de conversación: Un agente que piensa indefinidamente consume tokens y tiempo. Define un número máximo de pasos.
• Seguridad ignorada: Un agente que puede invocar herramientas también puede causar daño. Los permisos de herramientas y el sandboxing son obligatorios.
• Sin monitoreo: Si no te enteras de que el agente toma decisiones incorrectas, te darás cuenta demasiado tarde. El audit logging es esencial.
• Olvidar la aprobación humana: En acciones críticas necesitas aprobación humana, no ejecución ciega.

Enlaces y recursos adicionales sobre agentes de Ollama

• Ollama Function Calling - Define herramientas en Ollama.
• API REST de Ollama - API para solicitudes de modelos.
• Framework LangGraph - Construye agentes complejos.
• Framework CrewAI - Sistemas multi-agente.
• Conceptos básicos de MCP - Proporciona herramientas para agentes.
• Evaluación de Ollama - Compara modelos sistemáticamente.
• Seguridad de agentes - Asegura tus agentes.

Puntos clave:

• Ollama es un servidor de modelos local que soporta Function Calling para agentes de IA.
• La mayoría de frameworks comunes (LangGraph, CrewAI, LangChain) soportan Ollama.
• La elección del modelo afecta enormemente la calidad del agente.
• MCP conecta agentes con herramientas externas sin que tengas que definir cada herramienta tú mismo.
• Seguridad, manejo de errores y aprobaciones humanas son obligatorios para agentes con acceso a herramientas.

FAQ: Ollama para agentes de IA - Preguntas frecuentes

Referencias y lecturas complementarias

• Ollama Documentación - Documentación oficial de Ollama.
• LangGraph - Framework para agentes.
• CrewAI - Framework multi-agentes.
• Model Context Protocol - Estándar de herramientas para agentes.
• LangChain Ollama Integration - Integración de Ollama en LangChain.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert