Agentes de IA locales con Ollama

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre agentes de IA con Ollama

• Cómo ejecutar agentes de IA localmente usando Ollama como backend.
• Qué frameworks de agentes funcionan con Ollama y cómo configurarlos.
• Cómo implementar uso de herramientas, memoria y configuraciones multi-agente.
• Ejemplos prácticos de agentes autónomos: investigación, ejecución de código, gestión de archivos.
• Mejores prácticas para seguridad, rendimiento y confiabilidad.

Introducción: Agentes de IA con Ollama explicados

Los agentes de IA son programas que utilizan un modelo de lenguaje para resolver tareas de forma autónoma. Planifican, ejecutan herramientas, observan resultados y adaptan su plan. Con Ollama como backend, estos agentes se ejecutan completamente en local, sin la nube, sin costos de API, sin preocupaciones sobre protección de datos.

Este artículo está dirigido a desarrolladores que deseen construir agentes autónomos con IA local. Deberías entender qué son los agentes de IA, cómo funciona Ollama y qué es el Function Calling. Encontrarás fundamentos de programación Python en IRC-Coding.de.

Por qué necesito agentes de IA locales

Imagina que quieres construir un agente que ordene tus correos, gestione citas y resuma documentos. En la nube cada paso del agente cuesta dinero, cada llamada a API se registra, cada punto de datos va a un proveedor. Con IA local, todo se ejecuta en tu hardware, sin costos por invocación, sin fuga de datos.

Los agentes locales son especialmente valiosos cuando trabajas con datos sensibles, cuando necesitas muchos pasos de agente (que resultan caros en la nube) o cuando quieres ser independiente de los proveedores de nube.

Agentes de IA con Ollama explicados brevemente

Un agente de IA es un programa que ejecuta un bucle: Planificar → Llamar herramienta → Observar resultado → Adaptar plan. El modelo de lenguaje toma decisiones, el código ejecuta las herramientas. Con Ollama como backend, el modelo de lenguaje se ejecuta localmente, las herramientas son programas locales (sistema de archivos, shell, solicitudes web).

La idea central es: el agente es el bucle, Ollama es el cerebro, las herramientas son las manos.

Para quién es este artículo

• Desarrolladores que quieren construir agentes autónomos con IA local.
• Administradores de sistemas que ejecutan agentes para automatización en hardware propio.
• Investigadores que estudian el comportamiento de agentes con modelos locales.
• Auto-hospedadores que desean ser independientes de los proveedores de nube.

Se requieren conocimientos previos en Python, Ollama y Function Calling.

Términos importantes sobre agentes de IA con Ollama

• Agente de IA - Programa que resuelve tareas de forma autónoma. Útil para: flujos de trabajo autónomos.
• Ollama - Servidor de modelos local. Útil para: como cerebro del agente.
• Function Calling - Respuestas de IA estructuradas. Útil para: permitir que el agente llame herramientas.
• Herramienta - Función que el agente puede invocar. Útil para: las manos del agente.
• Memoria - Memoria del agente. Útil para: que el agente recuerde pasos anteriores.
• MCP - Protocolo de contexto de modelo. Útil para: estándar de integración de herramientas.
• OpenHands - Plataforma de agentes de código abierto. Útil para: agente listo para usar con soporte Ollama.
• Bucle de agente - El bucle central: Planificar → Herramienta → Observar → Adaptar. Útil para: el corazón de cada agente.

Frameworks de agentes con soporte Ollama

LangChain con Ollama

LangChain es el framework más conocido para aplicaciones LLM. Soporta Ollama como backend.

from langchain_community.llms import Ollama
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import Tool

# Ollama como backend
llm = Ollama(model="llama3.1", base_url="http://localhost:11434")

# Definir herramientas
def search_wikipedia(query):
    # Implementación aquí
    return f"Resultado para: {query}"

tools = [
    Tool(name="Wikipedia", func=search_wikipedia, description="Busca en Wikipedia")
]

# Crear agente
agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

# Ejecutar agente
result = executor.invoke({"input": "¿Cuál es la capital de Francia?"})
print(result)

LangGraph con Ollama

LangGraph es la evolución de LangChain para agentes con estado. Permite grafos de agentes complejos con ciclos.

from langchain_community.llms import Ollama
from langgraph.graph import StateGraph, END

llm = Ollama(model="llama3.1")

# Definir estado
from typing import TypedDict, List
class AgentState(TypedDict):
    messages: List[str]
    tool_results: List[str]

# Definir nodos
def call_model(state):
    response = llm.invoke(state["messages"][-1])
    return {"messages": state["messages"] + [response]}

def call_tool(state):
    # Ejecución de herramienta
    return {"tool_results": ["Resultado"]}

# Construir grafo
workflow = StateGraph(AgentState)
workflow.add_node("model", call_model)
workflow.add_node("tool", call_tool)
workflow.add_edge("model", "tool")
workflow.add_edge("tool", "model")

CrewAI con Ollama

CrewAI es un framework para sistemas multi-agente. Varios agentes con roles diferentes trabajan juntos.

from crewai import Agent, Task, Crew
from crewai.llms import Ollama

# Configurar LLM
llm = Ollama(model="llama3.1", base_url="http://localhost:11434")

# Definir agentes
researcher = Agent(
    role="Investigador",
    goal="Recopilar información",
    backstory="Eres un investigador experimentado.",
    llm=llm
)

writer = Agent(
    role="Escritor",
    goal="Escribir un informe",
    backstory="Eres un escritor experimentado.",
    llm=llm
)

# Definir tareas
research_task = Task(description="Investiga el tema X", agent=researcher)
write_task = Task(description="Escribe un informe", agent=writer)

# Crear equipo
crew = Crew(agents=[researcher, writer], tasks=[research_task, write_task])
result = crew.kickoff()

OpenHands con Ollama

OpenHands (antes OpenDevin) es una plataforma de agentes completa con interfaz web. Soporta Ollama como backend.

Consulta Configurar OpenHands para más detalles.

Uso de herramientas con Ollama

Function Calling con Ollama

Ollama soporta Function Calling, que el agente utiliza para invocar herramientas:

import requests

def call_ollama_with_tools(messages, tools):
    response = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": messages,
            "tools": tools,
            "stream": False
        }
    )
    return response.json()

# Definir herramientas
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtiene el clima para una ciudad",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nombre de la ciudad"}
                },
                "required": ["city"]
            }
        }
    }
]

# Bucle de agente
messages = [{"role": "user", "content": "¿Cómo está el clima en Berlín?"}]

while True:
    response = call_ollama_with_tools(messages, tools)
    msg = response["message"]

    if msg.get("tool_calls"):
        for tool_call in msg["tool_calls"]:
            # Ejecutar herramienta
            result = execute_tool(tool_call)
            messages.append(msg)
            messages.append({
                "role": "tool",
                "content": result
            })
    else:
        print(msg["content"])
        break

MCP con Ollama

El Model Context Protocol (MCP) es un estándar para integración de herramientas. Los modelos de Ollama pueden utilizar servidores MCP.

Consulta Fundamentos de MCP para más detalles.

Memory para agentes

Los agentes necesitan memoria para recordar pasos anteriores. Existen varios tipos de memoria:

Short-Term Memory

El contexto actual, es decir, los últimos mensajes. Está limitado por la longitud de contexto del modelo.

messages = [
    {"role": "system", "content": "Du bist ein Agent."},
    {"role": "user", "content": "Schritt 1"},
    {"role": "assistant", "content": "Ergebnis 1"},
    {"role": "user", "content": "Schritt 2"},
    # ...
]

Long-Term Memory

Almacenamiento persistente, por ejemplo en una base de datos vectorial. El agente puede recuperar conocimientos anteriores.

from chromadb import Client

chroma = Client()
collection = chroma.create_collection("agent_memory")

# Guardar memoria
collection.add(
    documents=["Wichtige Erkenntnis aus Schritt 5"],
    ids=["step_5"]
)

# Recuperar memoria
results = collection.query(query_texts=["Was weiß ich über X?"], n_results=3)

Summary Memory

Cuando el contexto se vuelve demasiado largo, el agente resume los mensajes antiguos.

def summarize_if_needed(messages, max_length=4000):
    total_length = sum(len(m["content"]) for m in messages)
    if total_length > max_length:
        # Resumir
        summary = call_ollama([
            {"role": "system", "content": "Fasse diese Konversation zusammen."},
            {"role": "user", "content": str(messages)}
        ])
        messages = [
            messages[0],  # Mantener el system prompt
            {"role": "system", "content": f"Zusammenfassung: {summary}"}
        ]
    return messages

Configuraciones Multi-Agent

Agentes jerárquicos

Un agente supervisor delega en agentes especializados:

def supervisor(task):
    # El supervisor decide qué agente interviene
    decision = call_ollama([
        {"role": "system", "content": "Du bist ein Supervisor. Entscheide, welcher Agent dran ist: researcher, coder, oder writer."},
        {"role": "user", "content": task}
    ])

    if "researcher" in decision:
        return researcher_agent(task)
    elif "coder" in decision:
        return coder_agent(task)
    elif "writer" in decision:
        return writer_agent(task)

Agentes en paralelo

Múltiples agentes trabajan en paralelo sobre el mismo problema:

import concurrent.futures

def parallel_agents(task, agents):
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = [executor.submit(agent, task) for agent in agents]
        results = [f.result() for f in futures]
    return results

Ejemplo práctico 1: Agente de investigación

Un agente que investiga un tema, recopila fuentes y redacta un informe.

def research_agent(topic):
    messages = [
        {"role": "system", "content": "Du bist ein Recherche-Agent. Nutze die Tools search_web und read_page."},
        {"role": "user", "content": f"Recherchiere: {topic}"}
    ]

    tools = [
        {"type": "function", "function": {"name": "search_web", "parameters": {"query": {"type": "string"}}}},
        {"type": "function", "function": {"name": "read_page", "parameters": {"url": {"type": "string"}}}}
    ]

    while True:
        response = call_ollama_with_tools(messages, tools)
        msg = response["message"]
        messages.append(msg)

        if msg.get("tool_calls"):
            for tc in msg["tool_calls"]:
                result = execute_tool(tc)
                messages.append({"role": "tool", "content": result})
        else:
            return msg["content"]

Ejemplo práctico 2: Agente de ejecución de código

Un agente que escribe y ejecuta código para resolver tareas.

def coder_agent(task):
    messages = [
        {"role": "system", "content": "Du bist ein Code-Agent. Nutze write_code und run_code."},
        {"role": "user", "content": task}
    ]

    tools = [
        {"type": "function", "function": {"name": "write_code", "parameters": {"code": {"type": "string"}}}},
        {"type": "function", "function": {"name": "run_code", "parameters": {"file": {"type": "string"}}}}
    ]

    # Agent-Loop como arriba
    # IMPORTANTE: Ejecuta el código en un sandbox

Consulta Entornos sandbox para recomendaciones de seguridad.

Consideraciones de seguridad

• Sandbox para ejecución de código: Los agentes que ejecutan código deben correr en un sandbox. Consulta Entornos sandbox.
• Principio de mínimo privilegio: Los agentes deben tener acceso solo a las herramientas que necesitan. Consulta Principio de mínimo privilegio.
• Human-in-the-Loop: Para acciones críticas, el agente debe solicitar aprobación humana. Consulta Aprobación humana.
• Audit Logging: Se deben registrar todas las acciones del agente. Consulta Audit Logging.
• Guardrails: Utiliza guardrails para prevenir acciones dañinas. Consulta Configurar guardrails.
• Protección contra Prompt Injection: Protege el agente contra inyección de prompts. Consulta Protección contra Prompt Injection.

Consejos de rendimiento

• Modelo pequeño para planificación: Utiliza un modelo pequeño para pasos de planificación y uno más grande para tareas complejas.
• Ten en cuenta la longitud del contexto: Los loops largos de agentes pueden exceder la longitud del contexto. Usa Summary Memory.
• Caching: Cachea resultados de herramientas para evitar llamadas repetidas.
• Paralelización: Cuando sea posible, ejecuta herramientas en paralelo.
• Elige el modelo: Para tool-use, los modelos con buen Function Calling son adecuados, como llama3.1, qwen2.5, mistral.

Escollos típicos

• Sin sandbox: Los agentes que ejecutan código sin sandbox son un riesgo de seguridad.
• Modelos demasiado grandes: Un modelo de 70B para cada paso del agente es lento y costoso en VRAM.
• Sin manejo de errores: Si una herramienta falla, el agente debe detectarlo y adaptarse, no crashear.
• Longitud de contexto excedida: Los loops largos pueden exceder el contexto. Usa Summary Memory.
• Bucles infinitos: Los agentes pueden quedarse atrapados en bucles. Limita el número de pasos.
• Sin guardrails: Sin guardrails, el agente puede ejecutar acciones dañinas.

Enlaces adicionales e información sobre agentes de IA con Ollama

• Instalar Ollama - Backend para agentes.
• Function Calling - Fundamentos del uso de herramientas.
• Fundamentos de MCP - Model Context Protocol.
• Fundamentos de agentes de IA - Qué son los agentes de IA.
• Configurar OpenHands - Plataforma de agentes lista para usar.
• Entornos sandbox - Seguridad para agentes de código.
• Aprobación humana - Human-in-the-Loop.
• Configurar guardrails - Guardrails para agentes.

Puntos clave:

• Los agentes de IA con Ollama se ejecutan completamente de forma local, sin cloud.
• Frameworks: LangChain, LangGraph, CrewAI, OpenHands.
• Tool-use mediante Function Calling o MCP.
• Memory: Short-Term, Long-Term, Summary.
• Multi-Agent: Jerárquico o paralelo.
• Seguridad: Sandbox, Principio de mínimo privilegio, Guardrails, Audit Logging.

Preguntas frecuentes: Agentes de IA con Ollama

Referencias y lecturas complementarias

• Ollama Documentación - Documentación oficial de Ollama.
• LangChain Documentación - Documentación de LangChain.
• CrewAI Documentación - Documentación de CrewAI.
• OpenHands - Plataforma de agentes.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert