Workflows de IA, automatiza tu día con Ollama y Docker

Vistas: 347
0:00 / 0:00
Workflows de IA, automatiza tu día con Ollama y Docker

Hasta ahora, con esto de la inteligencia artificial, hemos estado jugando con agentes, con herramientas sueltas como opencode, open-webui, con skills, con MCPs… en fin, una cantidad abrumadora de opciones que a veces abruma más que ayuda. Pero si lo piensas un momento, te darás cuenta de que por un lado estamos usando herramientas de terceros de las que no sabemos exactamente qué flujo realizan ni qué comparten con terceros, y por otro lado hay operaciones que directamente no necesitan IA para nada. La cuestión es que puedes montar un proceso donde solo una parte, por ejemplo la del informe o la de la alerta, use IA. Delegarlo todo a un LLM es malgastar tokens y recursos, y además le quitas predictibilidad a tu sistema. Así que en este episodio te he preparado cuatro workflows que puedes implementar tú mismo, o modificar a partir de lo que yo he hecho, para exprimir tu día a día sin dejarte los tokens en ello.

Del caos de herramientas a los workflows de IA

En los episodios anteriores, el 829 sobre skills, el 831 sobre MCPs, y otros donde te he hablado de ollama o de opencode, te he presentado piezas sueltas. Tienes ollama, tienes claude, tienes skills, tienes MCPs. Pero todo esto suelto no te vale para nada. Lo tienes que montar, lo tienes que combinar, lo tienes que unir para que tenga sentido. Y ahí es donde entran los workflows.

Un workflow de IA no es ni más ni menos que la combinación de varias herramientas, un modelo de lenguaje, un sistema de notificaciones, una base de datos, un programador de tareas, coordinadas para resolver un problema concreto. No es una herramienta, es un proceso. Y el Linuxero con IA tiene procesos, no solo herramientas sueltas.

Te puedo asegurar que hasta que no empecé a pensar en términos de workflows, todo era un caos. Tenía scripts por aquí, prompts por allá, modelos descargados a medias… un desastre. Cuando empecé a estructurarlo todo como procesos, con entrada, transformación y salida, todo cobró sentido. De repente, cada pieza tenía un propósito claro y un lugar definido en la cadena.

La diferencia entre tener herramientas sueltas y tener workflows es la misma que hay entre tener un montón de ladrillos y tener una casa construida. Los ladrillos son necesarios, pero sin un plano, sin una estructura, no son más que un montón de barro cocido. Con la IA pasa exactamente igual: puedes tener el mejor modelo del mundo, la mejor herramienta de prompts, el mejor sistema de notificaciones, pero si no los coordinas en un proceso, no estás aprovechando su potencial.

Y esto no es solo una cuestión de productividad, sino también de privacidad y control. Cuando usas herramientas de terceros para cada tarea, estás delegando datos y decisiones a servicios que no controlas. Con workflows locales, todo queda en tu máquina. Tus noticias, tus tareas, tus logs, tus investigaciones, todo procesado localmente sin pasar por servidores externos.

La arquitectura: Rust, Ollama y Docker como base del sistema

Antes de meterme en los cuatro workflows, déjame contarte por qué he elegido este stack. Porque no es casualidad, te lo aseguro. Llevo años experimentando con diferentes combinaciones y esta es la que mejor me ha funcionado.

Rust como lenguaje de implementación. ¿Por qué Rust y no Python o Bash? Pues porque los workflows que te voy a enseñar son servicios persistentes, no scripts que se ejecutan una vez al día. Necesitan estar funcionando 24/7, gestionar concurrencia real, manejar errores con gracia y, sobre todo, no depender de un entorno de ejecución en el servidor de producción. Los binarios compilados con cargo build --release pesan entre 5 y 8 MB, son estáticos, no necesitan ninguna librería del sistema. Te lo copias con scp a cualquier máquina Linux con la misma arquitectura y funciona. Punto. Sin Python, sin Node, sin JVM, sin nada.

Ollama como motor de inferencia local. Uso dos modelos: llama3.2:3b para generación de texto, resúmenes, clasificación, análisis de logs, respuestas RAG, y bge-m3 para embeddings. El llama3.2:3b pesa unos 2 GB, necesita unos 3 GB de RAM, y tiene 128K tokens de contexto. El bge-m3 son 567 millones de parámetros, 1.2 GB en disco, soporta más de 100 idiomas, incluyendo español, y genera embeddings de 1024 dimensiones. No lo confundas con nomic-embed-text, que solo funciona en inglés y tiene 768 dimensiones. Para español, bge-m3 es muy superior, y además soporta 8K tokens de contexto frente a los 2K de nomic-embed-text.

Docker como orquestador de contenedores. O Podman, que para el caso es lo mismo. Los workflows Rust van contenerizados con compose.yml, se conectan a la red de ollama, y se despliegan con docker compose up -d. También te mostraré la alternativa con servicios systemd, que para binarios Rust estáticos funciona de maravilla.

El stack mínimo para tener todo funcionando son unos 3.2 GB en disco y unos 4 GB de RAM. Funciona en cualquier CPU con 8 GB. Si tienes menos memoria, puedes usar qwen2.5:1.5b como alternativa más ligera, que pesa solo 1 GB y necesita unos 2 GB de RAM.

Antes de ponerte a instalar nada, te recomiendo que ejecutes el script de test que he preparado para verificar que todo funciona. El test-stack.sh hace cinco pruebas que cubren exactamente lo que necesitan los cuatro workflows: clasificación de mensajes en JSON, resumen de texto, análisis de logs, generación de embeddings con bge-m3, y un RAG simulado. Es como un smoke test para todo el stack. Si pasa las cinco pruebas, puedes estar tranquilo de que todo está listo.

El script está en el directorio 00-test-stack y se ejecuta con un simple bash test-stack.sh. Te recomiendo que lo tengas siempre a mano, sobre todo cuando actualices los modelos o cambies de versión de Ollama. Te lo dejo aquí para que lo tengas a mano:

#!/bin/bash
set -euo pipefail

MODEL="llama3.2:3b"
EMBED="bge-m3"

# Test 1: Clasificación en JSON
ollama run $MODEL 'Eres un clasificador. Responde SOLO en JSON.
Clasifica este mensaje: "Revisa los logs del servidor que están petando"
Devuelve: {"es_tarea": bool, "prioridad": "alta|media|baja", "contexto": "..."}'

# Test 2: Resumen
ollama run $MODEL 'Resume este artículo en 1-2 líneas en español:
"Meta ha lanzado Llama 3.2, una nueva versión de su modelo de lenguaje..."'

# Test 3: Análisis de logs
ollama run $MODEL 'Clasifica este log como CRITICO, ADVERTENCIA o INFO.
Log: "kernel: critical error - I/O error reading superblock on /dev/sda1"'

# Test 4: Embeddings con bge-m3
curl -s http://localhost:11434/api/embeddings \
  -d '{"model": "bge-m3", "prompt": "Los workflows de IA permiten automatizar tareas"}' \
  | jq '.embedding | length'

# Test 5: RAG simulado
ollama run $MODEL 'Contexto: Ollama permite ejecutar modelos localmente.
Pregunta: ¿Cómo se descargan modelos en Ollama?
Responde basándote SOLO en el contexto.'

Si todo esto funciona, tienes el stack listo para los cuatro workflows.

Los cuatro workflows que cambiarán tu día a día

Vamos al turrón. Te voy a presentar cuatro workflows que he implementado, con sus versiones en Bash como punto de partida didáctico y sus versiones en Rust como servicio persistente. Porque no todo tiene que ser Rust, y no todo tiene que ser Bash. Cada herramienta tiene su momento y su propósito.

Workflow 1: noticias-bot, RSS filtrado a Telegram

Este fue el primero que monté y el que más satisfacción me ha dado. El pipeline es sencillo: monitoreas varios feeds RSS, cuando aparece un artículo nuevo lo resumes con Ollama y lo envías a Telegram. Parece simple, pero los detalles marcan la diferencia entre un script cutre y un servicio profesional.

Empecé con una versión en Bash, porque era rápida de prototipar. El script fetch-news.sh descarga los feeds con curl y los parsea con xmlstarlet. La versión Bash tiene tres scripts que se encadenan: fetch-news.sh descarga los artículos, process-news.sh los resume con Ollama, y send-telegram.sh los envía a Telegram. Te pongo el process-news.sh porque es donde está la chicha:

#!/bin/bash
set -euo pipefail

INPUT="/tmp/raw-news.txt"
OUTPUT="/tmp/summarized-news.txt"
MODEL="llama3.2:3b"
TIMEOUT=30

if [ ! -f "$INPUT" ] || [ ! -s "$INPUT" ]; then
    echo "[ERROR] No hay artículos para procesar." >&2
    exit 1
fi

if ! ollama list 2>/dev/null | grep -q "$MODEL"; then
    echo "[ERROR] Modelo $MODEL no encontrado. Ejecuta: ollama pull $MODEL" >&2
    exit 1
fi

> "$OUTPUT"
while IFS='|' read -r title link date; do
    [ -z "$title" ] && continue
    summary=$(timeout "$TIMEOUT" ollama run "$MODEL" \
        "Resume este artículo de tecnología en menos de 20 palabras. \
         Sé conciso y directo: $title" 2>/dev/null) || \
        summary="[No se pudo generar resumen]"

    if [ -z "$summary" ] || [ ${#summary} -lt 5 ]; then
        summary="[Resumen no disponible]"
    fi

    {
        echo "📰 $title"
        echo "📝 $summary"
        echo "🔗 $link"
        echo "---"
    } >> "$OUTPUT"
done < "$INPUT"

Todo muy bonito, pero con limitaciones importantes: no hay deduplicación, si ejecutas el script dos veces recibes dos veces las mismas noticias. No hay filtrado por palabras clave, te llega todo. No hay control de errores fino, y todo es secuencial.

La versión en Rust soluciona todo esto. Te voy a contar cómo está organizada, porque la estructura es interesante y puede servirte de plantilla para tus propios workflows.

El config.toml se carga con serde y define los feeds, cada uno con su propio intervalo de actualización y sus palabras clave para filtrar. Fíjate en los detalles: el feed de Hacker News se actualiza cada 15 minutos, mientras que el de LWN solo cada 30 y además solo me interesan los artículos que mencionan Linux, kernel, security o Rust. Eso se traduce en un filtro por palabras clave antes de llamar a Ollama, ahorrándote tokens innecesarios.

La deduplicación se hace con SHA256 del enlace y una tabla SQLite con UNIQUE constraint. Cada vez que aparece un artículo nuevo, se calcula su hash, se comprueba si ya existe en la base de datos, y si no, se procesa y se marca como visto. Así nunca recibes duplicados, aunque el feed devuelva los mismos artículos en varias consultas.

El resumen con Ollama usa un prompt muy específico para que quepa en un mensaje de Telegram, con un timeout de 30 segundos. Esto es crítico: si el LLM se cuelga, y te aseguro que pasa, la llamada falla con timeout y el workflow continúa con el siguiente artículo. No se bloquea todo el proceso.

El despliegue es trivial con Docker o con systemd. Si usas systemd, el servicio se configura con Restart=on-failure y RestartSec=10, y lo activas con sudo systemctl enable --now noticias-bot. Así de simple.

Workflow 2: tareas-bot, GTD vía Telegram

Este es mi favorito con diferencia. Se trata de un bot de Telegram que recibe mensajes, los clasifica con Ollama para determinar si son tareas accionables, los persiste en SQLite y confirma en el chat. Es mi sistema GTD particular, pero sin complicaciones, sin metodologías imposibles, sin herramientas sobreingenierizadas.

La versión en Bash que tenía antes funcionaba con email: mbsync + mu + Ollama a TODO.md. Sin confirmación, sin tiempo real, sin SQLite. Un poco cutre, la verdad. Funcionaba, pero no era fiable.

La versión en Rust es un servicio persistente que hace long polling a la API de Telegram. Cada mensaje que llega se pasa por Ollama con un prompt de sistema muy trabajado que le dice al modelo cómo clasificar. Te pongo el prompt porque es un buen ejemplo de cómo poner guardarraíles a un LLM, que es una de las cosas más importantes cuando trabajas con inteligencia artificial local:

Eres un sistema de clasificación de texto especializado en la detección y extracción de tareas accionables a partir de mensajes en lenguaje natural.

Una tarea accionable es cualquier solicitud, recordatorio, orden o intención que implique ejecutar una acción concreta en el mundo real o digital.

Ejemplos de tareas: «Hay que revisar los logs del servidor», «Comprar el dominio nuevo», «Sacar a pasear al perro», «Prepara la presentación para el viernes».

NO son tareas: saludos, chistes o conversación informal como «Hola, ¿cómo estás?», preguntas puramente informativas como «¿A qué hora empieza la charla?», notificaciones pasivas como «El servidor está funcionando».

Y lo más importante: el prompt fuerza al modelo a responder solo en JSON, con un formato estricto. Si es una tarea, devuelve algo como:

{
  "is_task": true,
  "task_description": "Revisar logs del servidor",
  "priority": "alta",
  "context": "infraestructura"
}

Si no es una tarea, devuelve {"is_task": false}. El bot entonces decide si guarda la tarea en SQLite o la ignora.

La clasificación en JSON es clave porque te permite procesar la respuesta de manera determinista. No tienes que andar parseando texto libre, sino que serde_json te da la estructura directamente. Y si Ollama se desvía del formato, que a veces pasa, el código tiene un extractor que busca el primer { y el último } en la respuesta para extraer el JSON, ignorando cualquier texto circundante.

El bot responde con un mensaje de confirmación al mensaje original, usando reply_to_message_id. Así sabes que tu tarea se ha registrado correctamente. Y lo mejor es que el offset de Telegram se guarda en SQLite, así que si el bot se reinicia por actualización, por caída del sistema, lo que sea, retoma exactamente donde lo dejó, sin perder ni un mensaje.

La base de datos SQLite tiene tres tablas: bot_state para el offset, tasks para las tareas con toda su metadata, y processed_messages para llevar la cuenta de qué mensajes se han procesado ya. Todo con PRAGMA journal_mode=WAL para mejor concurrencia.

Workflow 3: monitor-bot, monitorización híbrida del sistema

Este es el ejemplo perfecto de lo que llamo IA híbrida: usar IA solo donde realmente aporta valor. El monitor-bot ejecuta cinco tipos de check configurables en config.toml. Los tres primeros checks son puramente deterministas: comprobar el disco con df -h, comprobar servicios con systemctl --failed, comprobar memoria con free -m. No necesitas un LLM para saber que el disco está al 95%. Pero el cuarto y el quinto, journalctl y docker, sí se benefician de la IA, porque un log de error puede ser crítico o puede ser un falso positivo, y un contenedor caído puede tener múltiples causas.

La versión en Bash del monitor es más limitada, pero te puede servir como punto de partida. El script monitor-logs.sh captura los logs del sistema con journalctl --since "1 hour ago" --priority err --output=json, y el analyze-logs.sh los pasa por Ollama para clasificarlos. Te pongo el analyze-logs.sh porque el prompt es otro ejemplo de guardarraíles bien puestos:

#!/bin/bash
set -euo pipefail

INPUT="/tmp/recent-errors.json"
MODEL="llama3.2:3b"
TIMEOUT=60

LOG_SAMPLE=$(jq -r '.[:20] | .[] | "\(.MESSAGE)"' "$INPUT" 2>/dev/null | head -30)

analysis=$(timeout "$TIMEOUT" ollama run "$MODEL" "
Eres un administrador de sistemas experto con 20 años de experiencia.
Analiza estos errores de log y clasifícalos:

🔴 CRÍTICO: pérdida de datos, servicio caído, disco lleno, kernel panic
🟡 ADVERTENCIA: alta carga, reintentos, timeouts, conexiones rechazadas
🟢 INFORMATIVO: esperado, config, debug, errores recuperables

Para cada 🔴 CRÍTICO, propón un comando de mitigación EXACTO.

Logs:
$LOG_SAMPLE
" 2>/dev/null) || analysis="⚠️ El análisis de logs falló por timeout."

La versión en Rust va mucho más allá. Tiene una arquitectura basada en un trait Check que todos los tipos de check implementan:

#[async_trait]
trait Check {
    async fn run(&self, client: &Client) -> Result<CheckResult>;
}

Cada tipo de check implementa su propio run, y el dispatcher create_check() crea la instancia adecuada según el tipo. Limpio, extensible, testable.

El bot tiene remediación automática: para logs críticos de disco, ejecuta journalctl --vacuum-time=7d; para contenedores, docker system prune; para paquetes, apt clean. Todo configurable, y con modo dry-run para probar antes de ejecutar acciones reales.

Además, tiene rate limiting: SQLite guarda un historial de alertas, y no se envía más de una alerta cada 15 minutos por cada tipo de check. Así evitas el spam de notificaciones cuando algo se repite, que es una de las cosas más molestas de los sistemas de monitorización mal configurados.

Workflow 4: investigacion-bot, búsqueda web con RAG local

Este es el más potente y el que más me ha costado, te lo aseguro. Se trata de un asistente de investigación que, dada una pregunta, busca en la web, extrae el contenido de las páginas más relevantes, construye un RAG (Retrieval Augmented Generation) en memoria con embeddings, y responde citando las fuentes. Es como tener tu propio asistente de investigación privado, sin depender de Google, sin trackers, sin perder tu privacidad.

La versión original en Bash+Python era un monstruo de 242 líneas de Python para el RAG, usaba html2text para convertir HTML a texto, sqlite-vec como base de datos vectorial, y las descargas eran secuenciales. Además, tenía problemas con UTF-8 multi-byte que me volvieron loco durante semanas. Cada vez que una página contenía un carácter Unicode fuera del rango básico, el chunking fallaba y el embedding se generaba mal. Un desastre.

La versión en Rust: cero dependencias del sistema, descargas paralelas con tokio::join_all, UTF-8 safe, todo en un solo binario. La diferencia es abismal. Te pongo el pipeline completo para que veas la elegancia de la solución:

cargo run -- "¿pregunta?"
  │
  ├─► Paso 1: Búsqueda web
  │     ├─► Ollama genera 3 consultas de búsqueda diferentes
  │     └─► SearXNG busca cada consulta y deduplica URLs
  │
  ├─► Paso 2: Extracción de contenido
  │     └─► tokio::join_all descarga todas las URLs en paralelo
  │         → scraper extrae HTML a texto plano
  │
  └─► Paso 3: RAG + Respuesta
        ├─► chunk_text(): divide en fragmentos de 1024 chars con 128 de overlap
        ├─► get_embedding(): bge-m3 vía Ollama para cada chunk
        ├─► cosine_similarity(): encuentra los top-5 chunks más relevantes
        └─► answer(): Ollama genera respuesta con contexto + fuentes

La generación de consultas es interesante: le pides a Ollama que, dada una pregunta, genere tres consultas de búsqueda diferentes. Por ejemplo, para «¿Qué novedades trae Podman 5?», el modelo podría generar:

  • «Podman 5 new features release notes»
  • «Podman v5 changelog breaking changes»
  • «Podman 5 vs Docker compatibility»

Luego cada consulta se lanza contra SearXNG, que es un metabuscador auto-hosteado que agrega resultados de 269 servicios de búsqueda. No trackea, no perfila, es privado. También puedes usar la API de Brave Search como alternativa, que te da 1000 consultas gratis al mes.

La extracción de contenido usa el crate scraper para parsear HTML con selectores CSS. Nada de llamar a html2text externo, nada de depender de Python. Todo dentro del binario.

El RAG en memoria es la parte más chula. Se divide cada página en chunks de 1024 caracteres con 128 de overlap, para que no se pierda contexto en los bordes. Se genera el embedding de cada chunk con bge-m3, y se almacena todo en un vector en memoria. Luego, cuando llega la pregunta, se genera su embedding y se calcula la cosine similarity con todos los chunks. Los cinco más cercanos se pasan como contexto a Ollama para que genere la respuesta.

El resultado es una respuesta con fuentes, algo como:

Podman 5 introduce soporte para pods como unidad de primera clase, mejoras en el manejo de redes con netavark 2.0, y la capacidad de ejecutar contenedores rootless sin problemas de montaje tmpfs. [Fuente: docs.podman.io] [Fuente: redhat.com]

Cada afirmación incluye su fuente original. Esto es clave para la credibilidad: no es un LLM alucinando, es información verificable.

Orquestación: systemd, Docker y just

Tener cuatro workflows está muy bien, pero si no los orquestas, tienes cuatro procesos sueltos. Aquí es donde entra la orquestación, que es lo que convierte un conjunto de herramientas en un sistema.

Systemd es mi opción preferida para los binarios Rust. Cada workflow tiene su propio servicio systemd con Restart=on-failure y RestartSec=10. Así, si el proceso cae por un error no controlado, por falta de memoria, lo que sea, systemd lo levanta automáticamente. Además, con After=network-online.target ollama.service te aseguras de que el bot no arranque antes de que la red y Ollama estén disponibles.

Docker Compose es la alternativa si prefieres contenerización. Cada workflow tiene su propio compose.yml que lo conecta a la red de Ollama. La ventaja es que aíslas completamente cada servicio y puedes actualizarlos independientemente. El compose.yml típico es muy simple:

services:
  noticias-bot:
    build: .
    restart: unless-stopped
    depends_on:
      - ollama
    volumes:
      - ./config.toml:/app/config.toml:ro
      - data:/app/data
    networks:
      - ollama

  ollama:
    image: ollama/ollama:latest
    restart: unless-stopped
    volumes:
      - ollama_data:/root/.ollama

volumes:
  data:
  ollama_data:

networks:
  ollama:
    external: true

Just es el command runner que uso para los workflows en Bash. Es una herramienta escrita en Rust, cómo no, que te permite definir recetas como si fueran targets de Makefile, pero mucho más limpias y con sintaxis moderna. El justfile del episodio tiene recetas para cada workflow y para combinaciones:

# Resumen diario de noticias
workflow-news:
    @echo "📰 Workflow: Resumen de noticias"
    cd {{noticias_dir}} && ./fetch-news.sh
    cd {{noticias_dir}} && ./process-news.sh
    cd {{noticias_dir}} && ./send-telegram.sh

# Investigar un tema
workflow-research question:
    cd {{investigacion_dir}} && ./run-research.sh "{{question}}"

# Workflow matutino completo
workflow-morning: workflow-news workflow-tasks
    @echo "☕ Buenos días! Todo listo."

# Verificar dependencias
check-deps:
    @command -v ollama >/dev/null && echo "✅ ollama" || echo "❌ ollama"
    @ollama list 2>/dev/null | grep -q "llama3.2" && echo "✅ llama3.2:3b" || echo "❌ llama3.2:3b"

Ejecutas just workflow-news y se lanza la cadena completa. O just workflow-morning y tienes noticias y tareas en un solo comando.

Buenas prácticas que aprendí por las malas

Después de meses iterando sobre estos workflows, he aprendido algunas lecciones que te pueden ahorrar más de un dolor de cabeza. Porque te aseguro que yo me he llevado más de un disgusto hasta llegar a una configuración estable.

Siempre usa timeouts en las llamadas a Ollama. El LLM se puede colgar, puede tardar más de lo esperado, o puede simplemente no responder. Si no pones un timeout, tu workflow se queda bloqueado esperando indefinidamente. En Rust, cada llamada HTTP lleva su timeout(). En Bash, usas timeout antes de ollama run. Nunca, bajo ningún concepto, hagas una llamada a un LLM sin timeout.

Validación de entrada en los prompts. El LLM puede desviarse del formato esperado. Por eso siempre incluyo un extractor de JSON que busca {...} en la respuesta, por si el modelo decide añadir texto explicativo antes o después del JSON. En el tareas-bot, por ejemplo, el extractor busca el primer { y el último } en la respuesta, y parsea solo esa sección. Así, aunque el modelo añada «Aquí tienes el JSON solicitado:» antes del JSON, el código sigue funcionando.

Graceful shutdown con ctrl_c y AtomicBool. En Rust, cada workflow tiene un manejador de SIGINT que pone una bandera atómica a true, y los loops de los workers comprueban esa bandera en cada iteración. Así, cuando pulsas Ctrl+C, todos los workers terminan ordenadamente, cerrando conexiones y guardando estado. Sin esto, si matas el proceso con SIGKILL, puedes corromper la base de datos SQLite.

Logging estructurado con tracing. Nada de println! o eprintln!. Uso tracing con EnvFilter para poder activar o desactivar niveles de log sin recompilar. En producción, RUST_LOG=noticias_bot=info. Para depurar, RUST_LOG=noticias_bot=debug. Y todo con formato que journalctl puede parsear y filtrar. Cuando algo falla a las 3 de la madrugada, tener logs estructurados es la diferencia entre saber qué pasó y no tener ni idea.

Errores con contexto con anyhow. En lugar de unwrap() por todas partes, uso anyhow::Context para añadir contexto a los errores. Cuando algo falla, el mensaje de error te dice exactamente qué estaba haciendo el programa en ese momento. Por ejemplo, si falla la lectura del config.toml, el error dice «No se pudo leer /app/config.toml», no un críptico «error reading file».

Idempotencia con SQLite UNIQUE constraints. Todas las operaciones de escritura son idempotentes gracias a INSERT OR IGNORE y ON CONFLICT DO UPDATE. Puedes ejecutar el mismo artículo, la misma tarea, la misma alerta múltiples veces y nunca tendrás duplicados. Esto es especialmente importante en los workflows que se ejecutan en bucle, donde un mismo evento podría procesarse dos veces si el timing no es perfecto.

Verificación de dependencias al arrancar. Cada workflow debería comprobar al arrancar que Ollama está disponible y que los modelos necesarios están descargados. El script check-deps.sh que te he preparado hace exactamente eso: verifica que curl, jq, xmlstarlet, ollama están instalados, que llama3.2:3b y bge-m3 están descargados, y que SearXNG responde si lo necesitas. Es mejor fallar rápido al arrancar que descubrir a mitad de la ejecución que falta una dependencia.

Bash vs Rust: cuándo usar cada uno

Llegados a este punto, igual te estás preguntando: vale, Lorenzo, pero ¿siempre tengo que usar Rust? Pues no, claro que no. Cada herramienta tiene su momento.

Usa Bash cuando tengas un pipeline lineal y simple, cuando uses comandos del sistema como journalctl, df o systemctl, cuando no necesites estado entre ejecuciones, y cuando la concurrencia no sea relevante. Para un script que una vez al día descarga un RSS, lo resume y lo envía a Telegram, Bash es perfecto. Rápido de escribir, fácil de modificar, y con herramientas que ya conoces.

Usa Rust cuando necesites un servicio persistente que funcione 24/7, cuando tengas estado complejo con SQLite, sesiones, deduplicación, cuando necesites concurrencia real con tokio, cuando quieras cero dependencias del sistema en producción, y cuando el deploy sea crítico, un solo binario que copias y ejecutas.

La comparativa es reveladora: los cuatro workflows en Bash suman unas 520 líneas en 11 scripts, dependen de curl, jq, xmlstarlet, html2text, python3 y pip. Los cuatro workflows en Rust suman unas 1750 líneas en 38 archivos, pero dependen de cero herramientas del sistema. Y tienen 15 tests unitarios, logging estructurado con niveles, graceful shutdown con ctrl_c y AtomicBool, y configuración externa con config.toml.

El Linuxero con IA tiene procesos

Te puedo asegurar que desde que empecé a pensar en términos de workflows, en lugar de herramientas sueltas, mi productividad ha mejorado notablemente. Ya no tengo que estar recordando qué script ejecutar, ni dónde dejé aquel prompt que funcionaba tan bien. Todo está organizado, todo tiene su lugar, todo es reproducible.

La clave de todo esto es la IA híbrida: no uses un LLM para todo. Usa la IA solo donde aporta valor, interpretar logs, clasificar mensajes, resumir artículos, responder preguntas con contexto, y deja las tareas deterministas para código determinista. Comprobar si el disco está lleno no necesita un modelo de 3B parámetros. Pero interpretar por qué se llenó el disco a las 3 de la madrugada, eso sí se beneficia de la IA. Esta distinción marca la diferencia y es lo que separa un sistema bien diseñado de un juguete que gasta tokens innecesariamente.

Y los guardarraíles en los prompts son fundamentales. Un prompt bien escrito, con formato de salida estricto, con ejemplos, con restricciones claras, convierte un LLM impredecible en una herramienta fiable. No es magia, es ingeniería de prompts. Cada uno de los cuatro workflows tiene prompts cuidadosamente diseñados para que el modelo se comporte de manera predecible. Y cuando el modelo se desvía, el código tiene mecanismos de recuperación: extractores de JSON, timeouts, reintentos, valores por defecto.

El stack que te he presentado, Rust, Ollama, Docker, SQLite, SearXNG, funciona en cualquier Linux con 8 GB de RAM, sin GPU, sin conexión a internet, sin depender de servicios externos. Todo corre en tu máquina, todo es privado, todo es controlable. Y lo mejor es que puedes empezar poco a poco: primero el noticias-bot, que es el más sencillo, luego el tareas-bot, que te cambia la forma de organizarte, y según te vayas sintiendo cómodo, añades el monitor y el investigador. No hace falta montarlo todo de golpe.

Si te quedas con una sola idea de este episodio, que sea esta: el Linuxero con IA tiene procesos, no solo herramientas sueltas. Un workflow bien diseñado, aunque sea simple, vale más que diez herramientas increíbles que no se coordinan entre sí.

¿Y tú? ¿Has pensado en qué procesos de tu día a día podrían beneficiarse de un workflow de IA? ¿Sigues usando herramientas sueltas o ya tienes procesos montados? Te leo en los comentarios 😊


Más información,

Ver el vídeo de este episodio
Transcripción

Hola soy lorenzo y esto es atareado con Linux episodio número 833 hasta el momento con el,

Tema de la inteligencia artificial hemos estado jugando con agentes con herramientas que están,

Implementadas para utilizar agentes como pueden ser open code open web ui en fin hay una gran,

Cantidad de opciones y posibilidades para utilizar la inteligencia artificial pero si lo piensas un,

Poco si haces un poquito de retrospectiva habrás dado cuenta que por un lado estamos utilizando,

Herramientas de terceros o herramientas open source que no sabemos exactamente el flujo que,

Realizan por un lado lo siguiente que no sabemos exactamente que están compartiendo con terceros,

Y luego que por otro lado hay determinadas operaciones que realmente no son necesarias,

Que vayan con ia o que todo el flujo sea con ia es decir tú puedes montar un proceso donde solamente,

Una parte por ejemplo la parte del reporte la parte donde te avisa o te informa sea con ia es decir,

Que convierta unos datos unos datos puros y duros en algo que te diga oye que tu disco está lleno,

Eso está muy interesante pero claro delegarlo todo en la ia es decir poner a un hermes a hacer,

Todo ese tipo de operación es malgastar tokens así que en este episodio te voy a mostrar cuatro,

Ejemplos que puedes implementar tú mismo o que puedes modificar aparte de lo que yo he hecho para,

Exprimir tu día a día sin dejarte los tokens en ello así que vamos directos al turrón en este,

Episodio te voy a hablar sobre workflows de ia y por supuesto y como no podía ser de otra manera,

Lo primero es dar un poquito de contexto y el poquito de contexto es que en los episodios anteriores,

En el 829 que te hablé de skills en los 831 en el que te hablé de mcps y en otros episodios donde,

Te ha hablado de oyama o te ha hablado de open code lo cierto es que te ha hablado de piezas o de,

Herramientas sueltas tienes oyama cloud skills mcp pero si lo piensas todo esto suelto pues no te,

Vale para nada lo tienes que montar tener una ia con mcps y skills es tener toda una caja de,

Herramientas sin ningún plano hoy no quiero hablarte de herramientas sino te quiero hablar de planos de,

Cómo organizar todo esto de cómo organizar tu todo tu composición para que llegados a un momento,

Puedas automatizar tus procesos y el lugar que como te decía anteriormente directamente te diga que,

Tienes el disco o sea que te diga que tu disco está al 89% te diga oye que tienes el disco lleno o,

Incluso que vaya un poquito más allá de todas maneras en este episodio yo quiero ir muy poco a poco es,

Decir no quiero hacer un workflow tremendamente complejo sino más bien lo que quiero es contarte,

Un poco las posibilidades que tiene y que realmente es sencillo de montar realmente la gracia de todo,

Esto si lo piensas es que en lugar de como te decía anteriormente delegarlo todo en la ia lo suyo es que,

Delegues en la ia lo que necesites es decir lo que puedes hacer es decirle a la ia que te cree un,

Flujo y ese flujo es estático no necesitas nada dinámico porque realmente no necesitas hacer ningún tipo,

De interpretación de nada es decir para capturar cuál es la ocupación de disco no necesitas nada,

Simplemente necesitas determinadas herramientas y luego para que le diga a alguien que aquello está,

Bastante estropeado sí que hace falta algo más en este sentido el linuxero normal tiene realmente,

Modelos potentes y el linuxero con ia tiene procesos no es el modelo son las automatizaciones,

Los workflows todo aquello que funciona mientras tú duermes todo en local todo completamente gratis,

Todo con herramientas que ya tenemos en Linux y ahora con binarios compilados lo cierto es que este,

Episodio partí de scripts en base pero luego lo evolucioné ligeramente y lo evolucioné ligeramente,

Porque estaba viendo que me resultaba más complejo montar todo un script en base que simplemente hacer,

Un binario en rast incluso meterlo en un contenedor en un contenedor Docker o en un contenedor potman,

Para hacer toda la operación esto tiene muchísimas ventajas me refiero al tema del contenedor porque una,

Vez ya lo tienes preparado simplemente si lo quieres desplegar por ejemplo para saber cuánto tienes ocupado,

Para ver qué es lo que está sucediendo con tus contenedores valga la redundancia simplemente tienes que,

Coger ese contenedor y desplegarlo donde quieras y ya está otro asunto que he hecho todo esto está,

Montado con oyama pero con oyama sin cpu digo perdón sin gpu sin cpu hubiera sido muy complicado sin gpu es,

Decir que todo lo que vas a ver vas a ver que funciona relativamente rápido para lo que es desde luego que,

Los modelos que elegido son modelos ligeros elegido el llama 3.2 para que veas que realmente va más o menos,

Rápido pero qué es un workflow de día bueno un workflow de ella es una combinación entre una,

Skill suelta un mcp aislado y un prom bien escrito un workflow de ella realmente es una secuencia de pasos,

Donde tú le dices o mejor dicho donde la ella participa en uno de ellos pero no necesitaría no necesariamente en,

Todos por ejemplo te puedo decir dos casos muy claros un caso muy claro es que te haga determinadas,

Mediciones no la ia sino tu proceso haga determinadas mediciones y luego la ia los interprete o te los,

Diga los humanice digamos y luego otro ejemplo claro es por ejemplo para el tema del scripting digo del,

Scripting no del scrapping en el caso de que hagas un scrapping de una página web es muy cómodo y esto,

Te lo expliqué en un episodio anterior utilizar scrapping con ia porque te permite ver como a pesar,

De que una página va cambiando la ia es capaz de interpretar qué es lo que sucede porque la ia,

Entiende la página web no es como un parser que si te cambian cualquier cosa se va a perder no la ia,

No la ia sabe exactamente lo que es un tag body o un tag ella lo entiende al final la ia es,

Precisamente bueno los modelos de inteligencia los modelos de lenguaje mejor dicho lo que hacen es,

Entender el lenguaje o comprender el lenguaje predecirlo vale la cadena de montaje bueno para,

Que nos hagamos una idea como si fuera esto una fábrica de coches tenemos el chasis el motor la,

Carrocería la pintura y el control de calidad bueno pues un workflow de ia puede ser perfectamente,

Un script en base que recoge datos que pueden ser logs rss emails un binario en ras que lo que se,

Encarga es de orquestar en su caso con concurrencia con login con gestión de errores toda la operación,

Una llamada a un modelo de lenguaje para procesar los datos resumirlo clasificarlo extraerlo y luego ya,

Comandos Linux sueltos que transforman el resultado todo esto lo puedes combinar como,

Quieras quiere decir que puedes utilizar el script en base para recoger datos un comando Linux como,

Puede ser jq o sqlite 3 o cur para procesar esos datos el binario en ras para combinarlo todo y luego,

La llamada al modelo del lm o el modelo del lm si lo utilizas para hacer el scrapping en fin que puedes,

Combinar las cosas como tú consideres más oportuno la clave de todo esto y lo más importante es que,

Un workflow ya sea de ia o de lo que sea se tiene que ejecutar completamente solo tú no tienes que,

Estar ahí mirando si tu workflow se ejecuta o no se ejecuta sino que tiene que ser un sistema o un,

Servicio completamente persistente ya sea consistente ya sea con Docker o como tú quieras,

Pero tiene que ser completamente persistente y que se ejecute completamente solo,

La diferencia entre un linuxer normal y uno con ia es que el segundo el linuxer o con ia tiene procesos.

Yo lo que he hecho ha sido hacer cuatro workflows en ras que te voy a mostrar o que te voy a contar,

A continuación para que te hagas una idea de distintas opciones o distintos distintas situaciones en,

Las que puedes combinar la ia con distintos workflows y ya te digo que el objetivo no es tanto crear un proceso,

Completo para hacer una determinada,

Operación o para hacer un determinado workflow sino darte unas pinceladas de cosas que se pueden hacer,

Verás y esto te contaré dentro de varios episodios como utilizado la ia para,

Otro tipo de casos pero que están muy relacionados con esto de los workflows y la cuestión es que es ver,

Distintas opciones distintas posibilidades para que tú te hagas una un mapa mental de todas las opciones y,

Posibilidades que tienes en el caso concreto yo he utilizado ras por lo que te decía porque me ha resultado un poco,

Más cómodo y he utilizado distintas distintos crates pero son crates o digamos librerías para que él que no esté metido con el en el mundo del,

Ras en son librerías muy estándar librerías que vas a poder utilizar o que vas a encontrar prácticamente en cualquier sitio,

Por ejemplo la de rast la de ese culite te permite tener ese culite embebido y luego utilizado o llama y dos versiones o llama para gestionar el modelo de lenguaje y dos versiones el llama 3 o mejor dicho dos modelos llama 3.2 de 3 billions que es el que va a hacer todo el tema de interpretación y el llama bg m3 que lo utilizó para la generación o la gestión de embeddings,

Y con esto más o menos tendría ya todo el panorama de lo que te quiero contar el primero de los ejemplos la primera de los usos es un una una herramienta para,

Que te haga notificaciones rss esto es una solución un poco más ligera de la que yo tengo implementada en el grupo de atareado con Linux pero que más o menos viene a ser algo similar y es que al final,

Si estás interesado por algún tema pues lo que quieres es tener noticias noticias pues lo más actualizadas posibles y esto es el caballo de batalla de prácticamente cualquiera de nosotros por la mañana te tomas el café y mientras estás tomándote el café tienes dos opciones,

O perder el tiempo mirando twitter o x o tener una sin una sintetización de las noticias que más te interesan y todo sin necesidad de abrir ni twitter ni bueno x ni ninguna otra,

Sí historia ni siquiera dirigirte a tus sistemas rss simplemente lo que tienes es un pequeño workflow que lo que hace es leer una serie de noticias rss y publicártelas en telegram así de sencillo y esto es lo que he creado,

El noticias bot que también lo vas a tener disponible en yo creo que bueno lo vas a tener disponible en las,

En las notas del episodio para que lo puedan montar tú fácilmente si puedo también lo subiré a boker hub por si lo quieres utilizar,

De allí directo,

Cómo funciona esto bueno pues simplemente es un,

Un archivo un archivo tómel donde están todas las fuentes que tú quieras combinar,

Cada feed tiene su intervalo propio y las palabras clave para filtrar los artículos,

Y luego tienes un pequeño problema,

Que es que,

Y esto sucede muy a menudo que el mismo artículo puede aparecer en distintos feeds,

Esto es muy habitual porque lo normal es que los que publican noticias,

Se hagan eco de algún,

Desarrollador o de algún,

Alguna distribución como puede ser Ubuntu,

Y cada vez que Ubuntu saca una nueva versión vas a ver que todos los youtubers publican sobre eso,

Que han sacado entonces claro te vas a tener la misma noticia en todos los sitios el mismo artículo puede aparecer en distintos feeds,

Yo aquí lo he hecho en base a hash es decir en base al artículo yo digo si es lo mismo o no pero podríamos hacerlo mucho más,

Elaborado en el sentido de que podríamos utilizar un,

¿Como se llama,

Podríamos utilizar embeddings para teniendo todos los artículos que por cada artículo se genere un embedding,

Y cuando,

La similitud entre dos artículos sea superior a un valor determinado pues sabes que son iguales,

Aquí bueno aquí he hecho algo sencillito para no complicarme la cabeza,

Porque al final lo que se trataba era de darte una visión general de lo que te quiero contar,

Al final yo lo he levantado con Docker compose,

Y lo mismo también te iba a decir lo mismo también he hecho con,

¿Cómo se llama,

Lo mismo lo he hecho con bash,

Lo que pasa que es mucho más práctico,

Como te digo con bash,

De cualquier manera en el episodio voy a dejar,

Todos los scripts si puedo,

Tanto de,

Rush como de bash,

Bueno,

¿Cómo funciona esto,

Bueno pues para funcionar esto es tan sencillo como un Podman,

Podman,

Compose,

App-d,

Force recreate,

Y si hay alguna noticia nueva me la debería de publicar aquí,

Evidentemente como ya lo he publicado todo pues no hay ninguna,

Lo que voy a hacer es,

Voy a borrar,

La imagen,

Para que empiece a publicar de nuevo,

A ver,

Vale,

A ver si lo puedo publicar,

En compose.yaml,

Puedo borrar es,

El volumen se llama,

Podman,

Volumen,

Voy a borrar el volumen,

Que se llama,

El,

Noticias bot,

Doc Podman,

Podman funciona exactamente igual que funciona Docker,

Entonces,

Podman volumen,

Remove,

0,

8,

Noticias bot,

Ya lo tengo y ahora lo levanto,

Podman,

Compose,

A menos de,

Force,

Recreate,

Entonces el ahora,

Podman,

Compose,

Logs,

Menos f,

Y va a empezar a,

El empieza ya a publicar,

Todas las noticias que tiene nueva,

Así de sencillo,

Pero es que no tiene más,

Esto es tan sencillo como esto,

Voy a pararlo,

Con,

Podman compose,

Down,

En mi caso yo lo que tengo hecho es un poco más complejo,

Pero porque me lo he querido montar así,

En mi caso lo que tengo hecho ha sido simplemente,

Un,

Tengo levantado,

Un servicio de rss,

Y lo que voy haciendo es actualizando contra ese servicio de rss,

Ni siquiera tengo base de datos porque lo que hago es cuando leo del servicio de rss,

Marco que un determinado artículo está ya leído y ya dejo de trabajar con él,

Y así de sencillo,

Este sería uno de los ejemplos que te quería contar,

Algo sencillo.

El siguiente es de tareas en telegram,

Y es,

Nunca,

O sea,

Esto es,

Digamos el ejemplo más,

Más práctico,

¿No.

El ejemplo más práctico del día a día,

De tener,

De crearte tareas,

O sea,

Cada vez que alguien te dice,

Bueno,

O simplemente,

El método,

O el método GTD,

De,

Getting things done,

De tener las cosas hechas,

¿No,

Lo más importante,

De cualquiera de estos procesos es,

Anotar las tareas que tienes que hacer,

Y quitártelas de la cabeza,

Entonces,

Una solución muy sencilla es,

Hacerlo con telegram,

Porque al final es una de las herramientas,

Que tenemos siempre más a mano,

Entonces,

Claro,

Aquí simplemente es,

Escribes algo,

Y se lo mandas a tu bot,

¿Qué pasa,

Que tu bot,

Es un bot,

Que tendrías que hacer las cosas,

Un poquito más elaboradas,

Para conseguirlo,

Pero,

¿Y si tu bot es capaz de,

Interpretar,

Qué es lo que es una tarea,

Y qué es lo que no es una tarea.

Pues esto es así de sencillo,

Esta es la operación real,

En este caso,

Lo que he hecho ha sido,

Un bot,

Que lo que hace es identificar,

Qué son tareas,

Y qué no son tareas,

Es decir,

Por ejemplo,

Hola,

No es una tarea,

Pero comprar pan,

Sí que es una tarea,

Entonces,

¿Qué es lo que hace,

Pues este bot,

Lo que hace es leer,

Todos los mensajes,

Que entran en tu,

En un determinado grupo,

Clasifica cada uno de ellos,

Con un modelo del lenguaje,

Extrae las tareas,

Y lo confirma,

No hace nada más que esto,

Como,

Te puedes hacer una idea,

Esto es,

Bueno,

Esto es,

Digamos,

La punta del iceberg,

A partir de ahí,

Podemos hacer,

Casi cualquier cosa,

Que te puedas imaginar,

Así que,

Voy a hacer,

La operación,

Que es,

Me voy a ir,

Al,

07,

Vale,

Ya tengo creado,

Mi,

Mi,

El bot,

Donde está corriendo.

Y ahora,

La cuestión sería,

La cuestión es ahora,

Ir diciéndole exactamente,

Qué es lo que es tarea,

Y qué es lo que no es tarea,

Y cómo tiene que funcionar,

Así de sencillo,

No tiene,

No tiene mucho más misterio,

Vale,

Esto sería,

Aquí,

Yo ahora sí,

Ya tengo mi bot levantado,

Voy a hacer un Podman,

Compose,

Logs menos f,

Y ahora le voy a decir,

Hola,

Ahora ves,

Él ya ha leído,

Que ha llegado,

Un mensaje,

Que dice hola,

Y dice,

Mensaje no clasificado,

Como tarea,

Si ahora le pongo,

Comprar,

Ciruelas,

Él va a hacer,

Ya me ha detectado,

Uno nuevo,

Y ahora sí que pone,

Tarea registrada,

Comprar ciruelas,

Algo tan sencillo,

Como esto,

Y realmente es verdaderamente,

Espectacular,

Claro,

Aquí es muy sencillo,

O sea,

Simplemente,

No tenemos que estar ahí,

Pensando,

No,

Si viene,

Si es un verbo,

Si no sé qué,

No,

Todo esto,

Lo hacemos,

Con un modelo de lenguaje,

Y lo hacemos,

Completamente local,

Esto funciona muy sencillo,

Simplemente tienes un bot,

O tienes un proceso,

Que está leyendo,

Continuamente,

Lo que sucede,

En ese canal,

Si lo que sucede,

En ese canal,

Se corresponde,

Con algo,

Que él entiende,

Que es una tarea,

La procesa como tarea,

Que no la descarta,

Simplemente esto,

Luego,

El siguiente,

Sería una monitorización,

De sistema,

Esto es algo también,

Muy estándar,

Simplemente se trata,

De decirle,

Una serie de cosas,

Que quieres que monitorice,

Por ejemplo,

Disco,

La memoria,

Los contenedores,

Que tienes levantados,

Y él,

Los monitoriza,

Y luego,

Lo que tiene que hacer,

Es analizar,

¿Qué es lo que pasa,

Que depende,

De cómo lo hagas,

Pueden ser,

Checks deterministas,

O,

Digamos que,

Checks,

Que tiene que interpretar,

Por ejemplo,

Los logs,

Los tendría que interpretar,

Bueno pues,

Con una,

IA híbrida,

Podríamos,

Podríamos,

Una parte,

De los servicios,

Hacerlos de forma,

Completamente directa,

Y otra,

Por ejemplo,

El tema de los logs,

Hacerlo,

Utilizando,

Ese modelo de lenguaje,

Así de sencillo,

En este caso,

Voy a,

Docker,

Docker,

Podman,

Compose down,

Compose down,

Y ahora iríamos,

Al,

0.9,

Al ejemplo,

9,

Si,

Si,

Les estoy llamando,

Ejemplos 7,

8,

9 Y 10,

Porque,

Inicialmente,

Estaba hablando,

Exactamente,

De los ejemplos,

En base,

Que vendrán,

También,

En el,

En el artículo,

Que puedes encontrar,

En la tarea,

.Es,

Ahora vamos,

Al ejercicio,

9,

Al ejemplo 9,

Que es el del,

Monitor bot,

Podman compose,

A menos,

Podman,

Logs,

Menos,

F,

Y ahora,

Podman,

Compose,

Y aquí,

Lo que vamos a tener,

Es directamente,

Él está haciendo,

Sus operaciones,

Está comparando,

Ha iniciado un check,

Cada 15 minutos,

Otro cada 10,

Otro no sé cuántos,

Y él va mirando,

Cuál es,

Por ejemplo,

La memoria,

Es del 28%,

Cuando llegue al 90%,

Nos va a mandar,

Un mensaje,

Igual está,

Del 71,

Y así sucesivamente,

No necesita,

Nada más,

Igual que esto,

Lo podemos hacer,

Para casi cualquier cosa,

Que te puedas imaginar,

Y luego,

El último que te quería contar,

Es uno de,

Investigación asistida,

¿Qué es esto,

De investigación asistida,

Esto es algo,

Que ya estoy haciendo,

Con los artículos,

De atareado.es,

De los tutoriales,

Que lo que hacen es,

Me ayudan a buscar,

Documentación,

Para generar los artículos,

Por ejemplo,

Tú le haces una pregunta,

De,

Cuéntame,

Lo nuevo,

Que hay en,

Podman 6,

Y lo que hace,

Lo que tienes que hacer,

Tú,

Por tu cuenta,

Es analizar,

Distintas fuentes,

Ver lo que funciona,

Y luego,

Combinarlo todo,

Bueno,

Pues todo esto,

Lo puedes hacer,

De otra manera,

Completamente distinta,

Es utilizando,

Una,

Un workflow,

De búsqueda real,

Una búsqueda real,

Donde lo haga,

Haga un rag,

Local,

Y donde tú le puedes,

Hacer preguntas,

A ese rag,

De todo lo que tú quieras,

Y esto claro,

Ya te puedes hacer una idea,

Que es,

Algo realmente espectacular,

Así tienes,

El primer paso,

Que es,

Ejecutas,

Una pregunta,

Luego con,

Search ng,

Bueno realmente,

Esto lo he cambiado,

Y ahora lo estoy haciendo,

Con brave,

Vas a hacer,

Una búsqueda,

De las noticias,

Más interesantes,

La troceas,

Como hemos hecho,

En otros episodios,

En el paso 3,

En el paso 4,

Generas prom,

Y en el resultado,

Tienes las respuestas,

Con las fuentes reales,

No hay ningún tipo,

De alucinación,

Todo es información,

Viva y autorizada,

La primera versión,

Estaba utilizando,

Base y python,

Pero claro,

Me parecía muy absurdo,

Utilizar dos soluciones,

Para hacer algo,

Que lo puedes hacer,

Directamente,

Con una de las,

Soluciones,

Y en este caso,

Me he decantado,

Por rast,

Donde tengo un scrapper,

Que lo que hace,

Es leer todo el texto,

En html,

Luego hace un rag,

En memoria ram,

Para hacer todas,

Las operaciones,

Y todo sin,

Sin sqlite,

Las descargas,

Las hace con tokyo,

De forma completamente,

Paralela,

Y no tienes ninguna,

Dependencia del sistema,

Y esto es una de las,

Mejores cosas,

Que puede ser,

Quiero decir,

Que para hacer,

Todo esto,

No necesitas,

Una librería,

De,

O sea,

De python,

Una librería,

De bash,

O mejor dicho,

Una aplicación,

De bash,

No necesitas,

Nada de esto,

Simplemente,

Con lo que te acabo,

De dar,

Lo tendrías todo,

Para empezar,

A trabajar,

Evidentemente,

Para programar esto,

Para crear,

El binario,

Si que vas a necesitar,

Todos los crates,

Pero una vez lo tienes,

Lo puedes desplegar,

Donde quieras,

Que va a funcionar,

Perfectamente,

Así por ejemplo,

Podemos hacer,

Un ejemplo claro,

En este ejemplo claro,

Lo que puedo hacer,

Voy a pararlo,

Voy a parar,

El anterior,

Y nos vamos a ir,

Al siguiente ejemplo,

Que es el ejemplo,

De la investigación,

Perdón,

A ver si me deja,

Vale,

Vamos al ejemplo,

De la investigación,

Y aquí simplemente,

Es un cargo,

Run,

Y ahora yo le puedo,

Preguntar,

Que novedades,

Trae,

Podman 6,

Este ejemplo,

Ya lo he hecho antes,

Para asegurarme,

Que iba a encontrar,

Cosas,

Pero puede valiarnos,

Perfectamente,

Entonces ahora,

Lo que hace,

Es lo primero,

Hace es una búsqueda,

Como te digo,

Inicialmente,

Lo hacía,

Con search ng,

Pero ahora,

Lo estoy haciendo,

Con brave,

Y lo estoy haciendo,

Con brave,

Porque al final,

Mi equipo,

También lo han detectado,

O sea,

Mi casa,

También lo han detectado,

Como algo,

Que está haciendo,

Hay búsquedas,

Locas,

Entonces,

Por ejemplo,

Ahora has traído,

1, 2, 3, 4, 5, 6, 7, 8,

10 Artículos,

Cada uno de los artículos,

Con distintas cantidades,

Ahora va a hacer,

Una indexación,

De todas las páginas,

Que ha obtenido,

Los va a trocear,

Va a generar,

Los embedding,

Con BGM3,

Y con todo esto,

Nos va a dar,

Información,

De lo que,

Estamos buscando,

Directamente,

Eres completamente,

Es completamente,

Agnóstico,

De lo que tú,

Le vayas a preguntar,

Como te decía,

El hecho de haberme,

Decantado,

Por brave,

Es que tiene una app,

Que hasta 2.000 consultas,

Creo que son,

Diarias o al mes,

Uy ahora no me acuerdo,

Bueno pero aunque fuera,

Al mes,

2.000 Consultas al mes,

Está bastante bien,

Para lo que,

Habitualmente,

Hacemos nosotros,

Si quieres más,

Pues evidentemente,

Es cuestión de,

O de cantarte,

Por la de brave,

O por la de google,

O por la que tú quieras,

Pero bueno,

Con este tipo,

De operaciones,

Realmente,

Yo lo que he estado,

Probando,

Funciona muy bien,

Y la verdad,

Es que,

Es súper interesante,

Yo todo este tipo,

De cosas,

Si te das cuenta,

Con 4 workflows,

Has tenido,

O has podido ver,

Una visión general,

De todas las opciones,

Y posibilidades,

Que te trae esto,

Solamente es darle,

Un poquito de,

Cuerda,

A la imaginación,

Una vez,

Yo te he contado,

4 Opciones,

Seguro que a ti,

Se te han ocurrido,

4 No,

4.000,

O 40.000,

Ya es cuestión,

De ir atando,

Cada una,

Con su pieza,

Las cosas,

Que realmente,

Antes tenías que hacer,

Más o menos,

De forma manual,

O que incluso,

Aquellas cosas,

Que en un momento,

Determinado,

Habías programado,

Ahora,

Si no las habías,

Programado,

Porque no tenías,

Conocimientos de programación,

Ahora con modelos,

De lenguaje,

Puedes programarla,

Pero no te quedes,

En eso,

No te quedes en,

Que cada vez,

Que tienes que hacer,

Una cosa,

La tienes que programar,

No no,

Preparas una aplicación,

Que se encargue,

De hacer ese workflow,

O de,

Coordinar el workflow,

Cogiendo aquellas piezas,

Que tú necesitas,

En cada momento,

Concreto,

Y luego,

Pues en,

Alguno de los,

Distintos pasos,

Utilizas,

Un modelo de lenguaje,

Para hacer el ensamplado,

Y es realmente,

Espectacular,

Bueno,

Este está indexando,

Aquí las 11 páginas,

Que le he dicho,

Pero tampoco,

Nos va a dar,

Mucho más,

De lo que,

Yo espero aquí,

Simplemente,

Es,

Una,

Una opción,

Al final,

Todas las grandes,

Ventajas que tienes,

Aquí que,

Es que los binarios,

Son servicios,

Persistentes,

Que los puedes,

Tener corriendo,

Ya sea en Docker,

Ya sea,

Utilizando systemd,

O como tú quieras,

La,

Cualquiera de estas,

Opciones es posible,

Yo la he levantado,

Con Docker,

Por el simple hecho,

Que con Docker,

La ventaja que tengo,

Es que puedo mover,

Rápidamente,

Los contenedores,

De un sitio a otro,

Para ver las soluciones,

O para utilizarlo,

Donde yo quiera,

Pero bueno,

Esto cada uno,

Se lo puede montar,

Como quiera,

La gran ventaja,

De montarte,

Wordflux,

Es la de potencia,

En el sentido,

De que puedes tener,

El mismo resultado,

Lo ejecutes,

Todas las veces,

Que lo ejecutes,

El inconveniente,

Que puedes tener,

Con un modelo de lenguaje,

Es que al final,

No son deterministas,

Y en este sentido,

Lo que te puedes encontrar,

La sorpresa,

Que te puedes encontrar,

Es que te esperes,

Un resultado,

Y que sea,

Completamente distinto,

Por eso,

Es importante,

Seleccionar,

Donde tienes que utilizar,

El modelo,

Dentro de tu workflow,

Para que los resultados,

Que te den,

Sean exactamente,

Los que tú quieras,

Que digamos,

Hayas establecido,

Los guardarrailes,

Para que tu modelo,

De lenguaje,

Circule por donde,

Tiene que circular,

Y poco más que decirte,

Espero que te haya gustado,

A ver si ha terminado,

Por casualidad,

No,

Está todavía,

Bueno,

Ya está,

Ya ha generado,

Los,

Vale ya está,

Ya nos ha dado,

Mira,

Nos ha dado,

Toda la información,

Según las fuentes,

Proporcionadas,

Las novedades principales,

Que trae Podman 6,

Son,

Soporte para gpus,

Mejora la gestión,

De redes,

Mejora en el rendimiento,

Eliminación de tecnologías,

Heredadas,

Limpieza y simplificación,

Y luego te da,

Un listado,

De las fuentes,

Consultadas,

Por ejemplo,

Inicialmente,

Él había considerado,

Ubunlog,

Y los resultados,

Ya lo ha quitado,

Y nada más,

Esto es un poco,

Lo que quería contarte,

Espero que te haya gustado,

Este nuevo episodio,

Y que lo hayas disfrutado,

Tanto como lo he disfrutado yo,

Espero que,

Bueno pues que,

Que surjan ideas,

De todo esto,

Que te acabo de contar,

Recordarte que este es un podcast,

De la red de podcast,

De la fantástica,

Maravillosa red de podcast,

De sospechosos habituales,

Donde puedes encontrar,

Fantásticos,

Y maravillosos podcasts,

Puedes participar en esa red,

Entrando en telegram,

En Wintable TINFO,

Y de la misma manera,

Si quieres participar,

En el grupo,

De la tarea con Linux,

Simplemente tienes que buscar,

Esa tarea con Linux,

Y allí nos vas a encontrar,

Hablando de Docker,

Linux,

Podman.

2 comentarios en “Workflows de IA, automatiza tu día con Ollama y Docker”

Deja una respuesta