Ajusta un bot de soporte para tu app Lovable (sin costos de API en producción)

Toda app de Lovable eventualmente necesita soporte al cliente. La jugada estándar es conectar GPT-4 con un system prompt repleto de tus docs. Pones la temperatura baja, le dices que sea útil, y esperas lo mejor. Funciona — más o menos. Pero cuesta $0.03 a $0.06 por conversación, alucina tu página de precios al menos una vez por semana, y no tiene idea de que renombraste el "Plan Pro" a "Plan Growth" hace tres meses. Hay una mejor manera.

¿Qué pasaría si tu bot de soporte realmente conociera tu producto? No en el sentido de "raspé tu FAQ", sino en el sentido de "he sido entrenado con 500 conversaciones reales de soporte y conozco los casos extremos exactos que encuentran tus usuarios". Eso es lo que te da el fine-tuning. Y cuando despliegas el modelo ajustado localmente con Ollama, el costo por conversación baja de $0.04 a exactamente $0.00.

Esta guía recorre todo el proceso: recolectar tus datos de entrenamiento, ajustar un modelo con Ertas, desplegarlo localmente e integrarlo en una app construida con Lovable. No se requiere experiencia en ML. Sin clúster de GPU. Sin factura recurrente de API.

Por qué los LLM genéricos son malos bots de soporte

Seamos honestos sobre lo que pasa cuando apuntas GPT-4 a los docs de tu producto y le dices que responda preguntas de clientes.

Alucina detalles del producto. Pregúntale sobre tus precios y declarará con confianza números que eran verdad hace seis meses — o que nunca lo fueron. Pregunta sobre una limitación de función y inventará una solución que no existe. Los LLM genéricos no conocen tu producto. Conocen el patrón general de "responder preguntas sobre productos SaaS", y llenan los vacíos con fabricaciones que suenan plausibles.

Tiene un tono inconsistente. Una conversación suena como una página de marketing de Silicon Valley. La siguiente suena como un artículo de Wikipedia. Tu bot de soporte debería sonar como tu marca. Los modelos genéricos suenan como ellos mismos.

Es caro a escala. Aquí están las matemáticas de conversaciones de soporte con GPT-4o:

A 10,000 conversaciones por mes, estás gastando $300 a $600 solo en inferencia del bot de soporte. Para una app indie que cobra $9.99/mes, eso es un golpe significativo al margen. Y a diferencia de tus costos de hosting, que crecen sub-linealmente, los costos de API escalan linealmente con cada conversación.

No mejora con el tiempo. Tus agentes de soporte humanos aprenden. Ven el mismo ticket sobre el bug de exportación CSV doce veces y se vuelven más rápidos resolviéndolo. Un bot de GPT-4 no aprende nada de una conversación a la siguiente. Cada interacción empieza desde cero.

Fine-tuning soluciona los cuatro problemas. Un modelo entrenado con tus datos reales de soporte conoce los detalles de tu producto, mantiene un tono consistente, corre localmente sin costo por token, y puede reentrenarse conforme tu producto evoluciona.

El mejor enfoque: un modelo entrenado con TUS datos de soporte

Fine-tuning no se trata de hacer un modelo pequeño generalmente más inteligente. Se trata de hacerlo un experto en un dominio estrecho: tu producto, tus usuarios, tus casos extremos.

Un modelo de 7B parámetros ajustado con 400 conversaciones de soporte de alta calidad de tu producto real superará consistentemente a GPT-4 con un system prompt para tu caso de uso específico de soporte. ¿Por qué? Porque:

• Ha visto las preguntas reales que hacen tus usuarios, no hipotéticas
• Conoce tu conjunto exacto de funciones, limitaciones y precios
• Ha aprendido la voz de tu marca de cientos de ejemplos
• Maneja tus casos extremos específicos porque fue entrenado con ellos

La contrapartida es que será peor en todo lo demás. Pídele que escriba un poema y probablemente intentará solucionar problemas de tu página de facturación. Pero ese es exactamente el punto. No necesitas que tu bot de soporte escriba poemas.

Recolectando tus datos de entrenamiento

Necesitas pares de entrada-salida: una pregunta del cliente y la respuesta de soporte ideal. Aquí es dónde encontrarlos.

Fuente 1: Tickets de soporte anteriores. Si has estado haciendo soporte manualmente (email, Intercom, Crisp, lo que sea), estás sentado sobre una mina de oro. Exporta tu historial de tickets. Cada ticket resuelto es un ejemplo potencial de entrenamiento. Enfócate en tickets donde el cliente confirmó que su problema se resolvió — esos representan interacciones de soporte exitosas.

Fuente 2: Tu documentación de ayuda. Convierte cada artículo de ayuda en pares de preguntas y respuestas. Por cada sección de tus docs, escribe 3-5 preguntas que un usuario podría hacer que esta sección responde, luego escribe la respuesta ideal. Un centro de ayuda de 20 páginas puede generar 60-100 ejemplos de entrenamiento.

Fuente 3: Tu FAQ. Similar a los docs, pero ya están en formato de pregunta-respuesta. Expande cada respuesta del FAQ en una respuesta de soporte conversacional en lugar de una respuesta estilo documentación.

Fuente 4: Generación sintética. Esta es el arma secreta para arrancar cuando no tienes un historial grande de tickets. Usa GPT-4 para generar preguntas realistas de clientes sobre tu producto, luego escribe (o edita) manualmente las respuestas ideales. La palabra clave es "manualmente". Estás curando las respuestas, no auto-generándolas.

Aquí hay un flujo de trabajo concreto para generación sintética:

1. Dale a GPT-4 tu descripción de producto, lista de funciones y página de precios
2. Pídele que genere 50 preguntas realistas de soporte en distintas categorías (facturación, bugs, funciones, cómo hacer, gestión de cuentas)
3. Para cada pregunta, escribe la respuesta ideal tú mismo — o haz que GPT-4 redacte una que luego editas para precisión y tono
4. Revisa cada par por corrección

Fuente 5: Tu changelog y problemas conocidos. Los usuarios preguntan sobre cambios recientes y bugs conocidos constantemente. Crea pares de preguntas y respuestas para cada entrada del changelog y cada problema conocido.

Construyendo tu dataset

Tus datos de entrenamiento necesitan estar en formato JSONL, con cada línea representando un ejemplo de entrenamiento. Para un bot de soporte, el formato se ve así:

{"input": "I upgraded to the Growth plan but I'm still seeing the free plan limits. It's been 24 hours.", "output": "Thanks for reaching out! Plan upgrades can take up to 10 minutes to propagate, but 24 hours definitely isn't right. Let me check a few things: First, can you try logging out and back in? This forces a session refresh that picks up plan changes. If that doesn't fix it, go to Settings > Billing and confirm the plan shows as 'Growth' there. If it still shows 'Free,' the payment may not have completed — check your email for a receipt from Stripe. Let me know what you see and I'll get this sorted."}
{"input": "How do I export my data as CSV?", "output": "You can export to CSV from the Dashboard page. Click the three-dot menu in the top right corner of any data table, then select 'Export > CSV.' The file will download immediately for tables under 10,000 rows. For larger datasets, you'll get an email with a download link within a few minutes. Note: CSV exports are available on the Growth plan and above. If you're on the Free plan, you can export up to 100 rows at a time."}

¿Cuántos ejemplos necesitas? Para un bot de soporte enfocado, apunta a 300 a 500 ejemplos de alta calidad. Esto es suficiente para cubrir:

• 50-80 preguntas comunes de cómo hacer
• 30-50 preguntas de facturación y cuenta
• 40-60 reportes de bugs y flujos de resolución
• 30-40 solicitudes de funciones y explicaciones de soluciones alternativas
• 20-30 preguntas de onboarding
• El resto para casos extremos y misceláneos

La calidad importa más que la cantidad. Cada respuesta en tu conjunto de entrenamiento debería ser exactamente lo que quieres que el bot diga. Si no enviarías esa respuesta a un cliente real, no la incluyas.

Consejos de higiene del dataset:

• Elimina información personalmente identificable (nombres, emails, IDs de cuenta)
• Estandariza tu formato de respuesta (estilo de saludo, estilo de despedida, nivel de detalle)
• Incluye ejemplos del bot manejando elegantemente preguntas que no puede responder ("Te recomendaría contactar a nuestro equipo en support@yourapp.com para preguntas específicas de facturación de la cuenta")
• Agrega ejemplos del bot manejando usuarios frustrados o molestos con empatía

Fine-tuning con Ertas

Esta es la parte que suena intimidante pero toma unos 15 minutos.

Paso 1: Sube tu dataset. Inicia sesión en Ertas y navega al Studio. Sube tu archivo JSONL. Ertas validará el formato y señalará cualquier problema — JSON malformado, entradas duplicadas, respuestas extremadamente cortas que podrían no llevar suficiente señal.

Paso 2: Selecciona tu modelo base. Para un bot de soporte, Qwen 2.5 7B es el punto óptimo. Es lo suficientemente grande para manejar conversaciones de soporte matizadas pero lo suficientemente pequeño para correr en hardware modesto. Si estás desplegando en una máquina con RAM limitada (8GB o menos), considera Qwen 2.5 3B — aún superará dramáticamente a un modelo genérico con prompts para tu caso de uso específico.

Paso 3: Configura el entrenamiento. Usa fine-tuning con LoRA (el predeterminado en Ertas). Configuraciones clave:

• Épocas: 3-5 para un dataset de soporte de 300-500 ejemplos
• Tasa de aprendizaje: Deja el valor por defecto de Ertas a menos que tengas una razón para cambiarlo
• Rango LoRA: 16 es un valor sólido por defecto para bots de soporte

Paso 4: Entrena. Dale a iniciar. Entrenar un modelo de 7B con LoRA en 500 ejemplos típicamente toma 20-40 minutos en Ertas. Verás métricas de pérdida actualizándose en tiempo real. Quieres ver la curva de pérdida descendiendo de manera constante y aplanándose — no rebotando salvajemente.

Paso 5: Evalúa. Ertas proporciona una interfaz de evaluación donde puedes probar tu modelo ajustado contra entradas de ejemplo. Prueba 20-30 preguntas de tu cola real de soporte y compara las respuestas con lo que tus agentes humanos dirían. Presta atención a:

• Precisión factual (¿acierta tus precios?)
• Consistencia de tono (¿suena como tu marca?)
• Manejo de casos extremos (¿qué hace con preguntas para las que no fue entrenado?)

Si los resultados no son satisfactorios, la solución casi siempre es mejores datos de entrenamiento, no más datos. Vuelve y refina tu dataset — corrige respuestas incorrectas, agrega más ejemplos para áreas débiles, elimina entradas ruidosas.

Desplegando tu bot de soporte

Una vez que estés satisfecho con el modelo, expórtalo desde Ertas como un archivo GGUF. Este es el formato que Ollama usa para inferencia local.

Paso 1: Instala Ollama en tu servidor. Si estás ejecutando tu app Lovable en un VPS (DigitalOcean, Hetzner, Railway), instala Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Paso 2: Carga tu modelo.

ollama create my-support-bot -f Modelfile

Donde tu Modelfile apunta a tu GGUF exportado:

FROM ./my-support-bot.gguf
PARAMETER temperature 0.3
SYSTEM "You are the support assistant for [YourApp]. Be helpful, accurate, and concise."

Paso 3: Pruébalo.

curl http://localhost:11434/api/generate -d '{
  "model": "my-support-bot",
  "prompt": "How do I upgrade my plan?",
  "stream": false
}'

Paso 4: Verifica el rendimiento. Ejecuta tu conjunto de evaluación contra el modelo desplegado y confirma que la calidad coincide con lo que viste en Ertas. La cuantización a GGUF ocasionalmente puede afectar la calidad en los márgenes — si notas degradación, prueba un nivel de cuantización más alto (Q6_K o Q8_0 en lugar de Q4_K_M).

Integrando con tu app Lovable

Tu app Lovable probablemente ya tiene un componente frontend para el widget de chat. El único cambio es apuntarlo a tu endpoint local de Ollama en lugar de la API de OpenAI.

Opción A: Llamada directa a la API. Si tu backend es una ruta de API simple, cambia la llamada al SDK de OpenAI por un fetch a tu instancia de Ollama:

// Before: OpenAI API
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: userQuestion }],
});

// After: Local Ollama
const response = await fetch("http://localhost:11434/api/chat", {
  method: "POST",
  body: JSON.stringify({
    model: "my-support-bot",
    messages: [{ role: "user", content: userQuestion }],
    stream: false,
  }),
});

Opción B: Endpoint compatible con OpenAI. Ollama expone una API compatible con OpenAI en /v1/chat/completions. Esto significa que puedes literalmente solo cambiar la URL base en tu configuración existente del SDK de OpenAI:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:11434/v1",
  apiKey: "not-needed", // Ollama doesn't require a key
});

const response = await client.chat.completions.create({
  model: "my-support-bot",
  messages: [{ role: "user", content: userQuestion }],
});

Este enfoque requiere cero cambios en el código frontend existente de tu widget de chat. El formato de respuesta es idéntico.

Comparación de costos: los números que importan

Comparemos el costo total de ejecutar un bot de soporte con IA usando GPT-4o versus un modelo local ajustado durante 12 meses:

El punto de equilibrio es alrededor de 1,000 conversaciones por mes. Por debajo de eso, el enfoque de API es más simple y más barato. Por encima, los ahorros se acumulan cada mes. A 10K conversaciones por mes, estás ahorrando $3,000 a $6,600 por año.

Y aquí está lo clave: conforme tu app crece y las conversaciones aumentan, el costo de API sube linealmente mientras el costo del modelo local permanece fijo. A 50K conversaciones por mes, la API costaría $1,500 a $3,000 mensuales. Tu modelo local sigue costando $30.

Comparación de calidad: ajustado vs. con prompts

Los ahorros de costos no significan nada si el bot da peores respuestas. Esto es lo que vemos consistentemente al comparar un modelo ajustado de 7B contra GPT-4o con un system prompt para soporte específico de producto:

Precisión factual en detalles del producto: El modelo ajustado gana. Conoce tus niveles de precios exactos, limitaciones de funciones y problemas conocidos porque fue entrenado con ellos. GPT-4 con un system prompt ocasionalmente alucinará o confundirá detalles de sus datos generales de entrenamiento.

Consistencia de tono: El modelo ajustado gana. Cada respuesta suena como tu marca porque cada ejemplo de entrenamiento demostró la voz de tu marca. GPT-4 varía entre tonos dependiendo de la formulación de la pregunta.

Manejo de casos extremos: El modelo ajustado gana para casos extremos conocidos (los de tus datos de entrenamiento) y empata para casos extremos nuevos. Si un usuario pregunta algo completamente fuera de tu conjunto de entrenamiento, ambos modelos pueden tener dificultades — pero puedes agregar un fallback para enrutar preguntas verdaderamente novedosas a un agente humano.

Preguntas de conocimiento general: GPT-4 gana. Si alguien le pregunta a tu bot de soporte sobre física cuántica, GPT-4 responderá correctamente y tu modelo ajustado probablemente intentará relacionarlo con tu página de facturación. Pero este no es un escenario que importe para un bot de soporte.

Latencia de respuesta: El modelo local gana. Ollama en un VPS decente devuelve respuestas en 500ms a 2 segundos. Las llamadas a la API de OpenAI típicamente toman 2-5 segundos, con picos ocasionales a más de 10 segundos durante períodos de alto tráfico.

Manteniendo tu bot actualizado

Tu producto cambia. Tu bot de soporte necesita mantenerse al día. El flujo de trabajo es:

1. Recolecta nuevas conversaciones de soporte mensualmente (o después de cambios importantes del producto)
2. Agrega 20-50 nuevos ejemplos de entrenamiento cubriendo los cambios
3. Reentrena en Ertas (toma 20-40 minutos)
4. Exporta el GGUF actualizado e intercámbialo en caliente en tu servidor

Con Ertas a $14.50/mes, puedes reentrenar tan seguido como necesites. La mayoría de los equipos se establecen en una cadencia mensual — reentrenar una vez al mes con nuevos ejemplos de los tickets de soporte del mes anterior. Esto mantiene al bot actualizado sin requerir atención constante.

Empezando este fin de semana

Aquí está el plan mínimo viable:

1. Sábado por la mañana: Exporta tus últimos 3 meses de tickets de soporte. Límpialos en 200-300 ejemplos JSONL (esta es la parte más difícil — presupuesta 3-4 horas).
2. Sábado por la tarde: Sube a Ertas, selecciona Qwen 2.5 7B, entrena con valores LoRA por defecto. Mientras entrena, levanta un VPS de $6/mes en Hetzner e instala Ollama.
3. Domingo por la mañana: Exporta el GGUF, despliega en tu VPS, prueba con 20 preguntas de ejemplo.
4. Domingo por la tarde: Cambia el endpoint de API en tu app Lovable. Despliega. Listo.

Tiempo total: un fin de semana. Costo continuo total: $30/mes por el VPS. Cada conversación de soporte de ese punto en adelante te cuesta exactamente nada en inferencia de IA.

Tu bot de soporte debería conocer tu producto mejor de lo que GPT-4 jamás podría. Fine-tuning hace que eso suceda, y el despliegue local lo hace gratuito.

---

Lectura adicional

• Ajusta un modelo con los datos de tu app — La guía completa para principiantes sobre fine-tuning para desarrolladores independientes.
• Tu app vibe-coded llegó a 10K usuarios. Ahora tu factura de IA es $3K/mes. — Entendiendo el precipicio de costos de IA y cómo evitarlo.
• Ajusta IA sin escribir código — Cómo Ertas hace el fine-tuning accesible para desarrolladores sin experiencia en ML.