El error que comete todo frontend antes de tocar IA: ignorar el backend

Ayer vi un frontend integrar la API de OpenAI directo desde el navegador. API key hardcodeada en el código. Cada request salía desde el cliente. En dos días, el límite de uso explotó, la factura llegó a $847 dólares y la key estaba publicada en Reddit. No es un caso extremo: es el resultado directo de saltar al mundo de IA sin entender cómo funciona una arquitectura backend básica.

La obsesión con "hacer IA" te hace creer que podés pegar un SDK y listo. Pero integrar modelos de lenguaje, embeddings o APIs de IA en producción sin conocer APIs REST, manejo de estado en servidor, bases de datos y arquitectura es construir una bomba de tiempo. Y cuando explota, no hay modelo que te salve.

Por qué las APIs REST son tu primera línea de defensa con IA

Cuando integrás un modelo de IA, no estás pegando un componente React. Estás haciendo requests a servicios externos que cuestan plata por token, que tienen rate limits brutales y que requieren keys sensibles. Todo eso necesita vivir en tu backend, nunca en el cliente.

El flujo correcto se ve así:

// ❌ MAL: Cliente hace request directo
const response = await fetch('https://api.openai.com/v1/chat/completions', {
  headers: { 'Authorization': `Bearer ${OPENAI_API_KEY}` } // Key expuesta
});

// ✅ BIEN: Cliente habla con tu backend
const response = await fetch('/api/chat', {
  method: 'POST',
  body: JSON.stringify({ message: userInput })
});

Tu backend es el intermediario que:

• Valida requests: No dejás que cualquiera envíe lo que quiera a un modelo que cobra por token
• Controla rate limiting: Limitás cuántas veces un usuario puede llamar a la IA
• Protege credenciales: Las API keys viven en variables de entorno del servidor, nunca en el bundle de JavaScript
• Cachea respuestas: Si diez usuarios preguntan lo mismo, no pagás diez veces

Sin una API REST bien diseñada, tu integración de IA es un agujero de seguridad y plata.

Bases de datos: donde la IA realmente se vuelve útil

Los modelos de IA no tienen memoria. GPT no sabe quién sos, qué preguntaste antes o qué contexto necesitás. Para que una integración de IA sea funcional, necesitás persistir:

• Historial de conversaciones: Para mantener contexto entre requests
• Embeddings de tus datos: Para hacer búsqueda semántica o RAG (Retrieval-Augmented Generation)
• Logs de uso: Para debugging, facturación y optimización de prompts
• Caché de respuestas: Para no quemar tokens en preguntas repetidas

Ejemplo real: un chatbot con memoria

// Backend con Express y una base de datos
app.post('/api/chat', async (req, res) => {
  const { userId, message } = req.body;
  
  // 1. Traer historial del usuario desde la DB
  const history = await db.conversations.find({ userId }).limit(10);
  
  // 2. Construir contexto para el modelo
  const context = history.map(h => `User: ${h.userMsg}\nAI: ${h.aiMsg}`).join('\n');
  
  // 3. Llamar al modelo con contexto
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      { role: 'system', content: 'Sos un asistente...' },
      { role: 'user', content: `${context}\n\nUser: ${message}` }
    ]
  });
  
  // 4. Guardar en DB
  await db.conversations.insert({
    userId,
    userMsg: message,
    aiMsg: response.choices[0].message.content,
    timestamp: Date.now()
  });
  
  res.json({ reply: response.choices[0].message.content });
});

Sin base de datos, tu chatbot es un goldfish: cada conversación arranca de cero. Con base de datos, podés construir experiencias que realmente importan.

Arquitectura: el piso técnico que nadie quiere aprender

Integrar IA en producción no es un feature aislado. Es una decisión de arquitectura que impacta:

Latencia: Los modelos tardan. Un request a GPT-4 puede demorar 5-15 segundos. ¿Tu frontend está preparado para eso? ¿Usás streaming? ¿Tenés estados de carga decentes?

Costo: Cada token cuesta. Si no medís, no optimizás. Si no optimizás, quebrás. Necesitás logging, métricas y límites por usuario.

Escalabilidad: Si tu app crece, ¿podés manejar 1000 requests concurrentes a tu endpoint de IA? ¿Tenés un queue system? ¿Un worker que procese en background?

Fallback: OpenAI se cae. Claude se cae. Tu modelo local se cuelga. ¿Qué hace tu app cuando falla el servicio de IA?

Decisiones de arquitectura que importan

1. Procesamiento sincrónico vs asincrónico

   • Sincrónico: Usuario espera. Bueno para chat rápido.
   • Asincrónico: Usuario recibe notificación. Mejor para análisis largo o generación de contenido pesado.

2. Streaming vs respuesta completa

   • Streaming: Tokens llegan de a poco (como ChatGPT). Mejor UX, más complejo.
   • Respuesta completa: Esperás todo. Más simple, peor UX.

3. Cache strategy

   • Cache en memoria (Redis): Para respuestas frecuentes.
   • Cache en DB: Para embeddings pre-calculados.

4. Rate limiting por usuario/IP

   • Evitás abuso.
   • Controlás costos.
   • Protegés tu cuenta de API externa.

Todo esto requiere conocer cómo funciona un servidor, cómo se comunica con una base, cómo se estructura una API y cómo se deployea. No hay atajo.

El checklist técnico antes de integrar IA

Antes de pegar tu primer npm install openai, verificá que tenés esto resuelto:

• Endpoint backend seguro que maneje las llamadas a servicios de IA
• Variables de entorno configuradas correctamente (nunca API keys en el cliente)
• Base de datos para persistir conversaciones, logs o embeddings
• Sistema de rate limiting por usuario o IP
• Manejo de errores robusto (timeout, retry logic, fallback)
• Logs de uso para medir tokens consumidos y costos
• Cache layer para respuestas frecuentes o embeddings
• Sistema de autenticación si tu app tiene usuarios

Si no tenés al menos 5 de estos 8 puntos, no estás listo para producción con IA.

La trampa del tutorial de IA

Los tutoriales te muestran esto:

import OpenAI from 'openai';
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const response = await openai.chat.completions.create({...});

Y parece mágico. Pero ese código corre en tu máquina, con tu key personal, sin usuarios reales, sin rate limits, sin facturación por usuario, sin logs, sin nada.

El salto de tutorial a producción es:

• Diseñar una API REST que exponga tu feature de IA
• Validar input del usuario (sanitización, límite de caracteres)
• Implementar autenticación y autorización
• Persistir datos en una base
• Manejar errores y timeouts
• Medir uso y costo por usuario
• Implementar caching inteligente
• Deployar en un servidor real con variables de entorno

Ningún tutorial te enseña eso. Y es el 80% del trabajo real.

Preguntas frecuentes

¿Puedo usar IA desde el frontend si uso variables de entorno en Vercel o Netlify?

No. Las variables de entorno en frameworks como Next.js que usan NEXT_PUBLIC_* o similares se exponen en el bundle del cliente. Cualquiera puede verlas en el navegador. Las API keys de servicios de IA siempre deben vivir en el servidor.

¿Qué base de datos me recomendás para guardar conversaciones de IA?

Depende de tu stack. Si ya usás PostgreSQL, agregá una tabla. Si necesitás búsqueda semántica (embeddings), mirá Pinecone, Weaviate o pgvector (extensión de Postgres). Para caché rápido, Redis. No hay una respuesta única, pero necesitás persistencia.

¿Es necesario saber backend si solo quiero hacer un chatbot simple?

Si es un experimento personal, podés usar servicios como Vercel AI SDK con edge functions. Pero si tu proyecto tiene usuarios reales, facturación o datos sensibles, sí: necesitás entender backend, APIs y bases de datos. No hay atajo seguro.

El piso técnico que te ahorra el desastre

Integrar IA sin backend es como construir una casa sin cimientos. Funciona hasta que llega la primera lluvia. Las APIs REST te dan control. Las bases de datos te dan persistencia. La arquitectura te da escalabilidad. Y todo eso junto es lo que separa un demo de un producto real.

El error no es querer usar IA. El error es creer que podés saltear los fundamentos. Porque cuando tu app explota en producción, ningún modelo te va a debuggear el desastre.

Checklist final para no cagarla:

• Tu frontend nunca toca API keys de servicios externos
• Todas las llamadas a IA pasan por tu backend
• Tenés una base de datos que persiste lo que importa
• Implementaste rate limiting y logging de uso
• Tu arquitectura puede escalar si llegan más usuarios
• Sabés cuánto estás gastando por request y por usuario
• Tenés un plan B cuando el servicio de IA falla