Integrar Ollama en automatización

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre integraciones de Ollama

• Cómo integrar Ollama en diversas herramientas de automatización.
• Cómo conectar n8n, Node-RED, Home Assistant, Nextcloud y Paperless-ngx con Ollama.
• Casos prácticos para procesamiento de documentos, smart home y colaboración en equipo.
• Mejores prácticas de seguridad en API, rendimiento y confiabilidad.
• Cómo construir tus propias integraciones usando la API de Ollama.

Introducción: integraciones de Ollama explicadas

Ollama es un servidor local de modelos con una REST-API. Cualquier software capaz de enviar solicitudes HTTP puede usar Ollama. Esto convierte a Ollama en un backend de IA universal para herramientas de automatización. En lugar de depender de APIs en la nube, conectas tus herramientas con Ollama y mantienes todos los datos locales.

Este artículo está dirigido a usuarios que quieren integrar Ollama en sus herramientas existentes. Deberías entender cómo funciona Ollama y qué es Function Calling. Encontrarás fundamentos de programación en IRC-Coding.de.

Por qué necesito integraciones de Ollama

Imagina que usas n8n para automatizar flujos de trabajo, Home Assistant para tu hogar inteligente y Nextcloud para gestionar documentos. Cada herramienta por separado es útil. Con Ollama como backend de IA, puedes conectar todas ellas con inteligencia local: n8n clasifica correos electrónicos, Home Assistant responde comandos de voz, Nextcloud resume documentos. Todo local, sin nube, sin costos de API.

Integraciones de Ollama brevemente

Ollama proporciona una REST-API que cualquier cliente puede usar. Herramientas de automatización como n8n y Node-RED pueden enviar solicitudes HTTP a Ollama. Sistemas de hogar inteligente como Home Assistant pueden utilizar Ollama mediante complementos. Sistemas de gestión de documentos como Nextcloud y Paperless-ngx pueden conectarse a Ollama a través de plugins o scripts.

La idea central es simple: Ollama es el backend de IA, cada herramienta es el cliente.

Para quién está pensado este artículo

• Automatizadores que integran Ollama en herramientas existentes.
• Administradores de servidores que incorporan IA local en su infraestructura.
• Usuarios de smart home que usan IA en Home Assistant.
• Equipos que integran IA en Nextcloud o Paperless-ngx.

Es útil tener conocimientos previos sobre Ollama y uso básico de APIs.

Términos importantes

• Ollama - Servidor local de modelos. Cuándo es útil: como el backend de IA.
• REST-API - Interfaz HTTP. Cuándo es útil: cómo se comunican las herramientas con Ollama.
• n8n - Automatización de flujos de trabajo. Cuándo es útil: para flujos complejos.
• Node-RED - Editor de flujos visual. Cuándo es útil: para flujos visuales.
• Home Assistant - Plataforma de hogar inteligente. Cuándo es útil: para automatización de smart home.
• Nextcloud - Nube auto-hospedada. Cuándo es útil: para gestión de documentos.
• Paperless-ngx - Gestión de documentos. Cuándo es útil: para clasificación de documentos.
• Function Calling - Respuestas estructuradas de IA. Cuándo es útil: para uso de herramientas.
• Docker - Plataforma de contenedores. Cuándo es útil: para ejecutar herramientas de forma aislada.

Fundamentos de la API de Ollama

Todas las integraciones utilizan la REST-API de Ollama:

# Chat
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.1",
  "messages": [{"role": "user", "content": "Hola"}],
  "stream": false
}'

# Embeddings
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "Texto para embedding"
}'

# Function Calling
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.1",
  "messages": [{"role": "user", "content": "¿Cómo está el clima?"}],
  "tools": [{"type": "function", "function": {"name": "get_weather", "parameters": {"city": {"type": "string"}}}}],
  "stream": false
}'

Consulta Ollama REST API para más detalles.

Integración 1: Ollama con n8n

n8n es una herramienta de automatización de flujos de trabajo que puede usar Ollama a través de nodos HTTP-Request.

Configuración

1. Ollama se ejecuta en http://localhost:11434.
2. En n8n, añades un nodo HTTP-Request.
3. Configuración:
   • Method: POST
   • URL: http://localhost:11434/api/chat
   • Body: JSON

   {
     "model": "llama3.1",
     "messages": [{"role": "user", "content": "{{$json.prompt}}"}],
     "stream": false
   }

Caso práctico: clasificación de correos electrónicos

// En nodo Function de n8n
const email = $input.item.json;
const response = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://localhost:11434/api/chat',
  body: {
    model: 'llama3.1',
    messages: [
      { role: 'system', content: 'Clasifica en: support, sales, billing, spam.' },
      { role: 'user', content: `Asunto: ${email.subject}\nCuerpo: ${email.body}` }
    ],
    stream: false
  },
  json: true
});
return { category: response.message.content };

Consulta n8n Guide para más detalles.

Integración 2: Ollama con Node-RED

Node-RED es un editor de flujos visual que puede usar Ollama a través de nodos HTTP-Request.

Configuración

1. Arrastra un nodo inject al flujo.
2. Arrastra un nodo function:

   msg.payload = {
     model: "llama3.1",
     messages: [{ role: "user", content: msg.payload }],
     stream: false
   };
   msg.headers = { "Content-Type": "application/json" };
   return msg;

3. Arrastra un nodo http request:
   • Method: POST
   • URL: http://localhost:11434/api/chat
   • Return: parsed JSON
4. Conecta: inject → function → http request → debug.

Consulta Node-RED para más detalles.

Integración 3: Ollama con Home Assistant

Home Assistant es una plataforma de hogar inteligente que puede usar Ollama mediante complementos o sensores RESTful.

Configuración mediante sensor RESTful

# configuration.yaml
sensor:
  - platform: rest
    name: "Respuesta de IA"
    resource: http://localhost:11434/api/chat
    method: POST
    payload: |
      {
        "model": "llama3.1",
        "messages": [{"role": "user", "content": "¿Cómo está el clima?"}],
        "stream": false
      }
    value_template: "{{ value_json.message.content }}"

Caso práctico: asistente de voz

# Comando Shell para Ollama
shell_command:
  ollama_chat: >
    curl -s http://localhost:11434/api/chat -d '{"model": "llama3.1", "messages": [{"role": "user", "content": "{{ question }}"}], "stream": false}' | jq -r .message.content

# Automatización
automation:
  - alias: "Asistente de voz con IA"
    trigger:
      - platform: conversation
        command: "pregunta ai [question]"
    action:
      - service: shell_command.ollama_chat
        data:
          question: "{{ trigger.question }}"
      - service: notify.mobile_app
        data:
          message: "{{ states('sensor.ki_antwort') }}"

Integración 4: Ollama con Nextcloud

Nextcloud es una nube auto-hospedada que puede usar Ollama mediante apps o scripts.

Configuración mediante Nextcloud App

Existen aplicaciones de la comunidad que integran Ollama en Nextcloud. Alternativamente, puedes usar scripts:

// Script de Nextcloud (app externa u comando occ)
function callOllama($prompt) {
    $client = \OC::$server->getHTTPClientService()->newClient();
    $response = $client->post('http://localhost:11434/api/chat', [
        'json' => [
            'model' => 'llama3.1',
            'messages' => [['role' => 'user', 'content' => $prompt]],
            'stream' => false
        ]
    ]);
    return json_decode($response->getBody(), true)['message']['content'];
}

Ejemplo práctico: Resumen de documentos

#!/usr/bin/env python3
# Script de Nextcloud: Resumen de documentos
import requests
import sys

def summarize_document(content):
    response = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": [
                {"role": "system", "content": "Fassa el documento en 5 oraciones."},
                {"role": "user", "content": content[:4000]}
            ],
            "stream": False
        }
    )
    return response.json()["message"]["content"]

if __name__ == "__main__":
    content = sys.stdin.read()
    print(summarize_document(content))

Integración 5: Ollama con Paperless-ngx

Paperless-ngx es un gestor documental que puede usar Ollama para clasificación y resumen de documentos.

Instalación mediante script personalizado

# Script personalizado de paperless-ngx
import requests

def ollama_classify(document_text):
    response = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": [
                {"role": "system", "content": "Clasifica en: factura, contrato, cliente, otro."},
                {"role": "user", "content": document_text[:2000]}
            ],
            "stream": False
        }
    )
    return response.json()["message"]["content"].strip().lower()

# En la configuración de paperless-ngx
# PAPERLESS_CONSUMER_RECURSIVE=true
# PAPERLESS_CONSUMER_SCRIPT=/path/to/ollama_classify.py

Ejemplo práctico: Asignación automática de etiquetas

def ollama_tags(document_text):
    response = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": [
                {"role": "system", "content": "Asigna 3-5 etiquetas para este documento. Responde como JSON-Array."},
                {"role": "user", "content": document_text[:2000]}
            ],
            "format": "json",
            "stream": False
        }
    )
    return response.json()["message"]["content"]

Construir integraciones propias

Si no existe un plugin listo para usar, puedes crear integraciones propias con la API de Ollama:

import requests

class OllamaClient:
    def __init__(self, base_url="http://localhost:11434"):
        self.base_url = base_url

    def chat(self, model, messages, stream=False):
        response = requests.post(
            f"{self.base_url}/api/chat",
            json={"model": model, "messages": messages, "stream": stream}
        )
        return response.json()

    def embeddings(self, model, prompt):
        response = requests.post(
            f"{self.base_url}/api/embeddings",
            json={"model": model, "prompt": prompt}
        )
        return response.json()

    def chat_with_tools(self, model, messages, tools):
        response = requests.post(
            f"{self.base_url}/api/chat",
            json={"model": model, "messages": messages, "tools": tools, "stream": False}
        )
        return response.json()

# Uso
client = OllamaClient()
response = client.chat("llama3.1", [
    {"role": "user", "content": "Hola"}
])
print(response["message"]["content"])

Consideraciones de seguridad

• Asegurar Ollama: No expongas Ollama a Internet sin autenticación. Consulta Claves API.
• Aislamiento de red: Usa redes Docker para que Ollama sea accesible solo a herramientas locales. Consulta Aislamiento de red.
• Sin datos sensibles en la nube: Ollama se ejecuta localmente, pero verifica que las herramientas no envíen datos a servicios en la nube.
• Registro de auditoría: Registra las llamadas a Ollama. Consulta Registro de auditoría.
• Límites de velocidad: Ollama no tiene límites de velocidad integrados. Protege contra sobrecargas.

Errores comunes

• Ollama no accesible: Verifica que Ollama esté en ejecución y que la URL sea correcta.
• Modelo incorrecto: Comprueba que el modelo esté cargado (ollama list).
• Longitud de contexto excedida: Los documentos largos deben dividirse en fragmentos.
• Sin manejo de errores: Si Ollama no es accesible, las herramientas no deberían fallar.
• Seguridad olvidada: Ollama sin autenticación es un riesgo.

Enlaces relacionados

• API REST de Ollama - Referencia de API.
• Instalar Ollama - Instalación.
• Guía de n8n - n8n con Ollama.
• Node-RED - Node-RED con Ollama.
• Function Calling - Uso de herramientas.
• Claves API - Asegurar Ollama.
• Aislamiento de red Docker - Asegurar red.

Puntos clave:

• Ollama ofrece una API REST que cualquier herramienta puede usar.
• Integraciones: n8n, Node-RED, Home Assistant, Nextcloud, Paperless-ngx.
• Todas las integraciones funcionan localmente, sin la nube.
• Seguridad: asegurar Ollama, aislamiento de red, registro de auditoría.
• Construir integraciones propias con la API de Ollama.

Preguntas frecuentes

Fuentes y lecturas recomendadas

• Ollama API - Referencia de API.
• n8n - Automatización de flujos de trabajo.
• Node-RED - Editor visual de flujos.
• Home Assistant - Plataforma de domótica.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert