Function Calling con Ollama

Qué cubre este artículo sobre Function Calling

• Qué es Function Calling.
• Qué modelos de Ollama soportan Tool Use.
• JSON-Mode y Schema.
• Cómo se formula un Tool Call en el prompt.
• Ejemplo práctico en Python.

Introducción: Function Calling con Ollama

Function Calling permite que los modelos de lenguaje no solo generen texto, sino que también emitan llamadas estructuradas a funciones externas. De esta forma, un modelo puede consultar datos, disparar cálculos o activar acciones dentro de una aplicación. Ollama soporta Function Calling en modelos compatibles, y con el prompt correcto, podemos hacer que el modelo devuelva JSON con nombres de funciones y parámetros.

Este artículo explora cómo funciona Function Calling con Ollama y cómo integrarlo en tus propios scripts.

Términos clave

• Function Calling: El modelo emite llamadas estructuradas.
• Tool Use: Sinónimo de Function Calling.
• JSON-Mode: El modelo entrega exclusivamente JSON.
• Schema: Definición de las funciones y parámetros permitidos.
• System Prompt: Instrucción que prepara el modelo para Function Calling.
• Named Entity: Entidad reconocida que se convierte en un argumento de herramienta.
• Tool Result: Resultado que se devuelve al modelo.

Cómo funciona

1. La aplicación recibe la solicitud del usuario.
2. El modelo recibe las herramientas disponibles.
3. El modelo decide si debe llamar a una herramienta.
4. La aplicación ejecuta la herramienta.
5. El resultado se devuelve al modelo.
6. El modelo formula una respuesta basada en el resultado de la herramienta.

Modelos soportados

• Llama 3.1 y versiones posteriores con Tool Use.
• Qwen 2.5 y variantes más grandes.
• Mistral, Mixtral y algunos fine-tunes.
• No todos los modelos son adecuados, ya que requieren una salida JSON limpia.

System Prompt para Function Calling

El asistente puede llamar funciones cuando la solicitud lo requiera.
Responde con texto normal o con un objeto JSON en el siguiente formato cuando se necesite una herramienta:

{
  "function": "tool_name",
  "arguments": {
    "key": "value"
  }
}

Definir herramientas disponibles

Herramientas disponibles:
- wetter(location: str) -> str
- rechnen(ausdruck: str) -> str

Ejemplo en Python

import requests
import json

url = "http://localhost:11434/api/generate"

tools = {
    "wetter": lambda location: f"Sonnig in {location}, 22 °C.",
    "rechnen": lambda ausdruck: str(eval(ausdruck))
}

system_prompt = """El asistente puede llamar funciones.

Si se necesita una herramienta, responde únicamente con JSON en este formato:
{
  "function": "tool_name",
  "arguments": {"key": "value"}
}

Herramientas disponibles:
- wetter(location: str)
- rechnen(ausdruck: str)
"""

def call_ollama(prompt, model="llama3.1"):
    response = requests.post(url, json={
        "model": model,
        "prompt": f"{system_prompt}\n\nUsuario: {prompt}\nAsistente:",
        "format": "json",
        "stream": False
    })
    return response.json()["response"].strip()

def process(user_input):
    raw = call_ollama(user_input)
    try:
        call = json.loads(raw)
        name = call["function"]
        args = call["arguments"]
        result = tools[name](**args)

        # Segunda llamada con el resultado de la herramienta
        second = call_ollama(f"Resultado de {name}({args}): {result}\nResponde ahora la pregunta original.")
        return second
    except (json.JSONDecodeError, KeyError, TypeError):
        return raw

print(process("¿Cómo es el clima en Berlín?"))

Usar JSON-Mode

Con format: json, Ollama fuerza al modelo a emitir JSON. Sin embargo, el modelo debe estar entrenado para entregar JSON limpio. Con modelos más pequeños, puede ser útil especificar el schema en el prompt.

Schema en el prompt

{
  "function": "tool_name",
  "arguments": {
    "arg_name": "tipo"
  }
}

Devolver el resultado de la herramienta

El modelo necesita contexto para responder al resultado:

Resultado de wetter(location="Berlin"): "Soleado, 22 °C."
Responde la pregunta: ¿Cómo es el clima en Berlín?

Manejo de errores

• JSON inválido: Reintentar con un prompt más corto.
• Función desconocida: Informar al modelo.
• Tipo de parámetro incorrecto: Validar antes de ejecutar la herramienta.
• Sin Function Call: Mostrar la respuesta de texto directo.

Seguridad

• Nunca usar eval sin validación.
• Validar entradas antes de pasarlas a las herramientas.
• Restringir el acceso a herramientas peligrosas.
• No incluir secretos en los logs.
• Limitar los permisos de las funciones de herramientas.

Enlaces e información adicional

• BotServ.de Ollama Agenten-Workflows
• BotServ.de Ollama MCP
• BotServ.de Ollama REST API

FAQ: Function Calling con Ollama

¿Qué modelos funcionan mejor? Llama 3.1, Qwen 2.5 y mistral-nemo son excelentes opciones.

¿Necesito JSON-Mode? Sí, para obtener salidas confiables.

¿Puede Ollama llamar múltiples herramientas a la vez? Teóricamente sí, pero muchos modelos emiten solo una llamada por respuesta.

¿Qué pasa si el JSON no es válido? La herramienta debe devolver un error e idealmente solicitar un nuevo intento.

¿Debería usar eval? Solo con restricciones extremas y nunca con entradas del usuario.

Fuentes y lecturas adicionales

• Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md
• Guía de Function Calling: https://platform.openai.com/docs/guides/function-calling
• llama.cpp Grammars: https://github.com/ggerganov/llama.cpp/blob/master/grammars/README.md

Resumen: Function Calling con Ollama

Function Calling amplía Ollama con capacidad de llamadas a herramientas estructuradas. Con un system prompt claro, una definición de herramientas, JSON-Mode y manejo robusto de errores, es posible automatizar muchas aplicaciones. No todos los modelos son adecuados, y la seguridad es crítica. Quienes implementen Function Calling deben validar entradas, restringir herramientas y siempre contar con un fallback.