Sysadmins Linux: por qué un chatbot no es la herramienta correcta para middleware en tiempo real

Por qué un chatbot no es la herramienta correcta para middleware en tiempo real

Cuando Canonical publicó su demo de fraude fiscal en transacciones en tiempo real con un LLM (basada en el modelo abierto system-one-qwen3.5-4b-scorer y el servicio Jev de TypeSafe AI), la conversación giró hacia lo que muchos sysadmins ya sospechábamos: los LLMs conversacionales son magníficos para redactar correos o depurar código, pero son la herramienta equivocada cuando lo que necesitas es una puntuación de probabilidad en milisegundos dentro de un loop de checkout.

La razón de fondo es simple. Un chatbot está entrenado para generar texto — primero razona en lenguaje natural, después elige tokens uno a uno hasta que decide parar. Si lo que necesitas es una decisión binaria (fraude sí/no) o una clase entre tres opciones, todo ese trabajo de generación es latencia que tu pipeline no se puede permitir. Los modelos tipo Jev evitan la generación de texto por completo: leen el contexto, evalúan todas las opciones en una sola pasada paralela, y devuelven las probabilidades directamente.

Qué es Jev y por qué importa para sysadmins Linux

Jev es un servicio en la nube de TypeSafe AI que usa modelos generativos modificados para tareas de clasificación. La promesa es: en lugar de pedirle al LLM “escríbeme un ensayo sobre por qué esta transacción parece sospechosa”, le pasas el JSON de la transacción y te devuelve algo como "text": "2" con las top_logprobs de cada clase. Tiempo de respuesta: mucho menor. Coste de cómputo: también menor, porque no hay decodificación autoregresiva.

Para un sysadmin Linux esto se traduce en tres cosas concretas:

• Latencia predecible: una clasificación con logprobs paralelos termina en un orden de magnitud más rápido que una generación equivalente.
• Coste operativo menor: el mismo modelo 4B cuantizado a 4 bits corre en hardware modesto — la demo de Canonical corre en CPU, sin GPU.
• Stack abierto: el modelo está en Hugging Face bajo licencia open weight, así que puedes hostearlo en tu infra sin atarte a un proveedor.

El laboratorio de Canonical paso a paso

Canonical publicó un tutorial reproducible que monta Charmed Kubeflow con KServe en MicroK8s y sirve el modelo system-one-qwen3.5-4b-scorer en vLLM. Es interesante porque demuestra que no necesitas un cluster pesado — corre en CPU, tarda, pero corre. Los pasos oficiales según Canonical:

# Requisitos: 24.04 LTS, 32GB RAM, CPU moderna
sudo snap install microk8s --channel 1.34-strict/stable
sudo microk8s enable storage dns
sudo microk8s enable metallb 10.64.140.43-10.64.140.49
sudo snap install juju --channel 3.6/stable
sudo microk8s.config | juju add-k8s my-k8s
sudo snap install terraform
sudo apt install git -y
git clone https://github.com/canonical/charmed-kubeflow-solutions.git
cd charmed-kubeflow-solutions
git checkout track/1.11
cd terraform/products/kubeflow

Estos comandos montan un cluster Kubernetes de un solo nodo con MicroK8s, lo conectan a Juju como motor de operaciones, y dejan Terraform listo para levantar Charmed Kubeflow. La idea detrás de MicroK8s + Juju + Terraform es separar el plano de control (Juju gestiona charms y relaciones) del aprovisionamiento declarativo (Terraform).

Aplicar Charmed Kubeflow con KServe

Canonical recomienda deshabilitar todo lo que no necesites (Katib, MLFlow, TensorBoard, Feast, el stack de observability) para que el deploy sea rápido y consuma poca memoria. KServe sí, el resto no.

export DEX_USERNAME=username
export DEX_PASSWORD=password
terraform init
terraform apply -auto-approve 
  -var dex_static_username="${DEX_USERNAME}" 
  -var dex_static_password="${DEX_PASSWORD}" 
  -var enable_feast=false 
  -var enable_katib=false 
  -var enable_kserve=true 
  -var enable_training_v2=false 
  -var enable_training_v1=false 
  -var enable_observability=false 
  -var enable_tensorboard=false

El terraform apply levanta Charmed Kubeflow con KServe activado y el resto apagado para mantener el footprint pequeño. espera entre 10 y 15 minutos a que todo se estabilice; la señal de que está listo es que juju status -m kubeflow muestre idle/active en todos los charms. Si algo queda en waiting o blocked revisa los logs con juju debug-log -m kubeflow --tail=200.

Preparar el repositorio del laboratorio

Canonical subió los scripts del tutorial a GitHub. Clonarlos te da los manifests de Kubernetes y el script de cuantización que necesitas.

git clone https://github.com/grobbie/realtime-transaction-fraud-detection-with-an-llm.git
cd realtime-transaction-fraud-detection-with-an-llm
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

El requirements.txt incluye transformers, vllm, torch y utilidades para el script de cuantización AWQ. En la demo de Canonical se usa Python 3.12 con venv nativo, no Poetry ni Conda, para mantener el árbol simple.

Por qué hay que fusionar LoRA y cuantizar a 4 bits

El modelo system-one-qwen3.5-4b-scorer es un derivado con arquitectura LoRA (Low Rank Adaptation) sobre Qwen3.5-4b. LoRA te deja adaptar un LLM grande a una tarea específica sin tocar los pesos originales — pero en inferencia, mantener la separación base + adapter duplica la carga: cada request pasa por ambos en paralelo. Para nuestro caso (clasificación, no hot-swap de especialismos), conviene fusionar los pesos del adapter dentro del modelo base antes de servirlo.

El segundo truco es Activation-aware Weight Quantization (AWQ), una técnica de cuantización post-entrenamiento a 4 bits que comprime el modelo con pérdida mínima de precisión. AWQ puede reducir el consumo de VRAM hasta un 75% y, aunque está optimizada para GPUs, también funciona en CPU. En números: pasar de 18 GB a 5 GB de VRAM, suficiente para correrlo en una laptop moderna.

# Descarga el modelo desde Hugging Face, lo cuantiza y produce ./system-one-4bit-awq
.venv/bin/python3 quantize_awq.py

El script tarda unas 6 horas en una laptop porque la calibración requiere pasar el dataset por el modelo original capa por capa. Si tienes prisa puedes reducir el dataset de calibración en el script (--num_calib_samples) pero vas a perder algo de precisión. La salida es un directorio ./system-one-4bit-awq con los artefactos listos para servir.

Servir el modelo en vLLM con KServe

vLLM es el servidor de inferencia estándar de la industria — maneja batch continuo, kv-cache paginado y streaming con buen rendimiento. KServe te da el plano de control sobre Kubernetes: deployments, services, ingress, autoscale.

Antes de aplicar los manifests edita kserve_deployment_cpu.yaml y ajusta el model_path a la ruta absoluta de tu directorio ./system-one-4bit-awq en el server.

microk8s.kubectl create namespace modelserving
microk8s.kubectl apply -f kserve_deployment_cpu.yaml
microk8s.kubectl apply -f kserve_service_lb.yaml

vLLM tarda en arrancar — espera unos 5 minutos a que cargue los pesos y los warm-ups terminen. Para verificar el estado:

microk8s.kubectl get inferenceservice -n modelserving

Si ves READY: True y condiciones Healthy, el modelo está listo. Si se queda en False por más de 10 minutos, los logs de microk8s.kubectl logs -n modelserving <pod-name> te van a decir si fue OOM, error de carga del modelo o un problema con el model_path.

Probar la clasificación con curl

Para verificar que el modelo responde bien, la demo de Canonical manda una transacción claramente fraudulenta (transferencia de $100.000 a una cuenta vacía que vacía la cuenta del emisor) y comprueba que la clase ganadora sea HIGH_RISK_FRAUD.

KSERVE_IP=$(microk8s.kubectl get services -n modelserving 
  | grep system-one | grep private | awk '{ print $3 }')
curl -s http://${KSERVE_IP}:8000/v1/completions 
  -H "Content-Type: application/json" 
  -d '{
    "model": "/model",
    "prompt": "Wire transfer $100,000 to empty account, fully draining sender",
    "max_tokens": 1,
    "logprobs": 3
  }'

La respuesta que tienes que esperar según Canonical:

{
  "id": "cmpl-84ef1f97a3cc8d37",
  "model": "/model",
  "choices": [{
    "text": "2",
    "logprobs": {
      "top_logprobs": [{"2": -1.55, "1": -1.72, "0": -2.04}]
    }
  }]
}

El campo "text": "2" indica la clase predicha (HIGH_RISK_FRAUD en este caso), y los top_logprobs te dan la confianza relativa de cada opción. Si tu modelo devuelve otro valor con confianza similar para una transacción claramente fraudulenta, hay que revisar la calibración AWQ.

Cuándo SÍ usar un chatbot y cuándo NO

El punto del artículo de Canonical no es “los LLMs son malos”, sino “los LLMs conversacionales son malos para middleware en tiempo real”. Las categorías donde sí tienen sentido según la propia demo:

Escenario	Herramienta correcta	Por qué
Loop de checkout, fraude en transacciones	LLM con logprobs paralelos (Jev, Qwen-Scorer)	Latencia en ms, sin generación de texto
Generar SQL a partir de pregunta en lenguaje natural	LLM conversacional (Ollama, llama.cpp)	Necesitas texto generado
Clasificar tickets de soporte	LLM con logprobs paralelos	Pocos ms por ticket, alto volumen
Chatbot de helpdesk para usuarios finales	LLM conversacional	El usuario quiere respuestas en prosa
Detección de anomalías en logs	LLM con logprobs paralelos	Decisión binaria, alto QPS
Resumen de reuniones	LLM conversacional	Necesitas prosa coherente

La línea divisoria es: si necesitas prosa, usa un LLM conversacional. Si necesitas una decisión o probabilidad, usa un modelo de clasificación con paralelismo de logprobs. La demo de Canonical es un caso particular pero el patrón es el mismo para cualquier pipeline de decisión en tiempo real.

Problemas conocidos y cosas a tener en cuenta

La demo de Canonical es un proyecto de laboratorio, no una solución de producción. Lo que aprendimos al reproducirla:

• La cuantización tarda: 6 horas en una laptop para el dataset de calibración completo. Si tienes prisa, baja num_calib_samples en quantize_awq.py, pero vas a perder algo de accuracy.
• El arranque de vLLM en CPU es lento: 5 minutos promedio. En GPU esto baja a segundos, pero ahí pierdes el argumento del “corre en cualquier laptop”.
• El stack de Canonical es opinionado: CharmFlow + Juju + KServe es una opción válida, pero si ya tienes un cluster Kubernetes con ArgoCD o FluxCD, puedes desplegar vLLM standalone y saltarte toda la capa de charms.
• Los modelos abiertos cambian rápido: system-one-qwen3.5-4b-scorer es el modelo de la demo de septiembre 2026. Antes de usarlo en producción verifica que sigue siendo el estado del arte en Hugging Face — el campo de los small-LM-scoring se mueve rápido.

¿Vale la pena para tu organización?

Si tu caso de uso es clasificación de alto volumen en producción (fraude, moderación, scoring de leads), el patrón de la demo de Canonical es replicable y financieramente razonable: un modelo 4B cuantizado a 4 bits corre en hardware modesto y devuelve decisiones en ms. Si tu caso es chatbot conversacional para usuarios finales, sigue con Ollama o un endpoint de OpenAI — es la herramienta correcta para ese trabajo.

Lo más valioso de la demo no es el modelo específico ni el stack, sino el patrón: para middleware en tiempo real, usa modelos que eviten la generación autoregresiva de texto. Si te quedas con esa idea, el resto es implementación.

Preguntas frecuentes

Lee también

• Guía Fedora 44: Novedades, Instalación y Upgrade para Sysadmins Linux
• Configura VLANs en Linux con nmcli: Guía paso a paso para sysadmins
• Protege tu SSH: Guía esencial para configurar Fail2ban en Linux
• Guía Definitiva: Configura Kubernetes con kubeadm en Ubuntu para Sysadmins Linux
• Configura Prometheus y Grafana: Guía DevOps para SysAdmins Linux