1. Introducción contextual

En los últimos cinco años la adopción de inteligencia artificial conversacional en el sector salud ha crecido un 215 % según el informe de IDC Health AI 2024. Los pacientes exigen respuestas inmediatas, precisas y disponibles 24 h/7 d, mientras que los proveedores buscan reducir la carga operativa de sus call‑centers. El resultado es una oportunidad clara: un agente conversacional que pueda gestionar consultas de síntomas, agenda de citas, resultados de laboratorio y educación preventiva, todo integrado a los sistemas clínicos existentes (EHR, SIS, etc.).

Sin embargo, la implementación no es trivial. Los retos incluyen:

• Regulación y privacidad (HIPAA, GDPR, Ley de Protección de Datos de Salud en cada país).
• Latencia: una respuesta tardía degrada la confianza del paciente y afecta los Core Web Vitals (CLS, LCP, FID).
• Escalabilidad: picos estacionales (influenza, COVID‑19) pueden multiplicar el tráfico por 5‑10×.

Resolver estos problemas hoy es crítico porque la competencia ya está desplegando bots basados en LLM que ofrecen una experiencia “casi humana”. Quien no evolucione perderá tanto en satisfacción del usuario como en eficiencia operativa. En este artículo, describo una arquitectura robusta, paso a paso, desde un prototipo naive hasta una solución productiva, con énfasis en Next.js, Node.js, Python, PostgreSQL, Supabase y Docker.

2. Fundamentos y Arquitectura

2.1. Principios de diseño

2.2. Diagrama conceptual (descrito en texto)

1. Cliente web (Next.js SSR + React SPA) → solicita /api/chat vía HTTP/2.
2. API Gateway (NGINX + Cloudflare) → distribuye la petición a Node.js (Express) o FastAPI (Python) según la ruta (/api/chat vs /api/rag).
3. Orquestador (Node.js) valida token JWT, verifica límites de uso y delega a:
   • LLM externo (OpenAI, Anthropic) o modelo local (llama.cpp) mediante Factory.
   • RAG service (Supabase + pgvector) para recuperación de documentos clínicos.
4. Persistencia: PostgreSQL con esquema conversations, patients, documents.
5. Cache: Redis (TTL 5 min) para respuestas idénticas y resultados de búsqueda vectorial.
6. Observabilidad: Prometheus + Grafana; logs en Loki.

2.3. Trade‑offs críticos

3. Implementación práctica

A continuación, muestro la evolución de cinco componentes críticos. Cada bloque supera las 15 líneas y está listo para copiarse en un proyecto real.

3.1. Endpoint básico en Node.js (Express)

Versión naive: recibe el mensaje del paciente y lo envía directamente a la API de OpenAI.

// src/api/chatNaive.ts
import express, { Request, Response } from "express";
import fetch from "node-fetch";

const router = express.Router();

/**
 * POST /api/chat-naive
 * cuerpo: { mensaje: string, pacienteId: string }
 */
router.post("/chat-naive", async (req: Request, res: Response) => {
  const { mensaje, pacienteId } = req.body;

  // Sin validación ni control de errores
  const openAiResponse = await fetch("https://api.openai.com/v1/chat/completions", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
    },
    body: JSON.stringify({
      model: "gpt-4o-mini",
      messages: [{ role: "user", content: mensaje }],
    }),
  });

  const data = await openAiResponse.json();
  res.json({ respuesta: data.choices[0].message.content });
});

export default router;

Problemas: no hay validación de entrada, no se controla el número de tokens, no se registra nada y la respuesta se entrega sin caché.

3.2. Endpoint productivo con Factory, validación y caché

// src/api/chat.ts
import express, { Request, Response, NextFunction } from "express";
import { z } from "zod";
import { LLMFactory } from "../services/LLMFactory";
import redisClient from "../utils/redisClient";
import logger from "../utils/logger";

const router = express.Router();

// Esquema Zod para validar la carga útil
const chatSchema = z.object({
  mensaje: z.string().min(1).max(1000),
  pacienteId: z.string().uuid(),
});

/**
 * Middleware de validación
 */
function validateBody(req: Request, res: Response, next: NextFunction) {
  const result = chatSchema.safeParse(req.body);
  if (!result.success) {
    logger.warn("Validación fallida", result.error.format());
    return res.status(400).json({ error: "Datos de entrada inválidos" });
  }
  // Attach parsed data
  req.body = result.data;
  next();
}

/**
 * POST /api/chat
 */
router.post("/chat", validateBody, async (req: Request, res: Response) => {
  const { mensaje, pacienteId } = req.body as { mensaje: string; pacienteId: string };
  const cacheKey = `chat:${pacienteId}:${hashString(mensaje)}`;

  // 1️⃣ Intentar recuperar de Redis (TTL 300 s)
  const cached = await redisClient.get(cacheKey);
  if (cached) {
    logger.info("Cache hit", { cacheKey });
    return res.json(JSON.parse(cached));
  }

  // 2️⃣ Seleccionar LLM mediante Factory (puede ser SaaS o local)
  const llm = LLMFactory.getInstance(process.env.LLM_STRATEGY ?? "openai");

  try {
    const respuesta = await llm.generate({
      prompt: mensaje,
      userId: pacienteId,
    });

    const payload = { respuesta };
    // 3️⃣ Guardar en caché
    await redisClient.setEx(cacheKey, 300, JSON.stringify(payload));

    // 4️⃣ Persistir conversación (Repository pattern)
    await llm.conversationRepository.save({
      pacienteId,
      mensaje,
      respuesta,
      timestamp: new Date(),
    });

    res.json(payload);
  } catch (error) {
    logger.error("Error en LLM", { error });
    res.status(502).json({ error: "Servicio de IA no disponible" });
  }
});

/**
 * Función hash simple (SHA‑256) para generar clave de caché
 */
import crypto from "crypto";
function hashString(input: string): string {
  return crypto.createHash("sha256").update(input).digest("hex");
}

export default router;

Mejoras introducidas:

• Validación con Zod (evita inyección).
• Factory (LLMFactory) permite cambiar de proveedor sin tocar el endpoint.
• Cache en Redis con TTL para reducir costos de token.
• Repository para persistir la conversación (se muestra más abajo).
• Logging estructurado (p.ej., Loki).

3.3. Servicio LLM con patrón Factory (Node)

// src/services/LLMFactory.ts
import { OpenAIService } from "./OpenAIService";
import { LocalLlamaService } from "./LocalLlamaService";
import { ILlmService } from "./ILlmService";

/**
 * Factory que devuelve una implementación concreta de ILlmService.
 * La estrategia se define mediante variable de entorno.
 */
export class LLMFactory {
  private static instance: ILlmService | null = null;

  static getInstance(strategy: string): ILlmService {
    if (this.instance) return this.instance;

    switch (strategy) {
      case "local":
        this.instance = new LocalLlamaService();
        break;
      case "openai":
      default:
        this.instance = new OpenAIService();
        break;
    }
    return this.instance;
  }
}

Interfaz común:

// src/services/ILlmService.ts
export interface ILlmService {
  generate(params: { prompt: string; userId: string }): Promise<string>;
  conversationRepository: ConversationRepository;
}

3.4. Implementación del repositorio de conversaciones (PostgreSQL + Supabase)

// src/repositories/ConversationRepository.ts
import { createClient, SupabaseClient } from "@supabase/supabase-js";

export interface Conversation {
  id?: number;
  pacienteId: string;
  mensaje: string;
  respuesta: string;
  timestamp: Date;
}

/**
 * Repository que abstrae el acceso a la tabla `conversations`.
 * Utiliza Supabase como capa de datos (PostgreSQL + Row Level Security).
 */
export class ConversationRepository {
  private client: SupabaseClient;

  constructor() {
    this.client = createClient(
      process.env.SUPABASE_URL!,
      process.env.SUPABASE_ANON_KEY!
    );
  }

  async save(conv: Conversation): Promise<void> {
    const { data, error } = await this.client
      .from<Conversation>("conversations")
      .insert([conv]);

    if (error) {
      throw new Error(`Error al guardar conversación: ${error.message}`);
    }
  }

  async getByPaciente(pacienteId: string, limit = 20) {
    const { data, error } = await this.client
      .from<Conversation>("conversations")
      .select("*")
      .eq("pacienteId", pacienteId)
      .order("timestamp", { ascending: false })
      .limit(limit);

    if (error) {
      throw new Error(`Error al obtener conversaciones: ${error.message}`);
    }
    return data;
  }
}

3.5. Frontend React (Next.js) – Componente de chat naive

// components/ChatBoxNaive.tsx
import { useState } from "react";

export default function ChatBoxNaive() {
  const [mensaje, setMensaje] = useState("");
  const [historial, setHistorial] = useState<string[]>([]);

  const enviar = async () => {
    const res = await fetch("/api/chat-naive", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ mensaje, pacienteId: "11111111-2222-3333-4444-555555555555" }),
    });
    const data = await res.json();
    setHistorial([...historial, `Yo: ${mensaje}`, `Bot: ${data.respuesta}`]);
    setMensaje("");
  };

  return (
    <div className="p-4 border rounded">
      <div className="h-64 overflow-y-auto mb-2">
        {historial.map((line, i) => (
          <p key={i}>{line}</p>
        ))}
      </div>
      <input
        value={mensaje}
        onChange={(e) => setMensaje(e.target.value)}
        placeholder="Escribe tu consulta..."
        className="border p-2 w-full"
      />
      <button onClick={enviar} className="mt-2 bg-blue-600 text-white p-2 w-full">
        Enviar
      </button>
    </div>
  );
}

3.6. Frontend productivo con lazy loading, memo y manejo de errores

// components/ChatBox.tsx
import { useState, useCallback, useEffect, memo } from "react";
import useSWR from "swr";

/**
 * Hook SWR para fetch con reintentos exponenciales y cache del navegador.
 */
const fetcher = (url: string, body: any) =>
  fetch(url, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(body),
  }).then((r) => {
    if (!r.ok) throw new Error(`HTTP ${r.status}`);
    return r.json();
  });

interface Mensaje {
  rol: "user" | "bot";
  contenido: string;
}

/**
 * ChatBox memoizado para evitar renders innecesarios.
 */
const ChatBox = memo(function ChatBox() {
  const [input, setInput] = useState("");
  const [historial, setHistorial] = useState<Mensaje[]>([]);
  const pacienteId = "11111111-2222-3333-4444-555555555555"; // En producción proviene de JWT

  const { mutate, error, isValidating } = useSWR(
    // La clave incluye el mensaje para que SWR lo cachee
    input ? ["/api/chat", { mensaje: input, pacienteId }] : null,
    fetcher,
    { revalidateOnFocus: false, shouldRetryOnError: true }
  );

  // Cuando mutate devuelve datos, los añadimos al historial
  useEffect(() => {
    if (mutate?.data?.respuesta) {
      setHistorial((prev) => [
        ...prev,
        { rol: "user", contenido: input },
        { rol: "bot", contenido: mutate.data.respuesta },
      ]);
      setInput("");
    }
  }, [mutate?.data]);

  const enviar = useCallback(() => {
    if (!input.trim()) return;
    mutate(); // dispara SWR
  }, [input, mutate]);

  return (
    <section className="p-4 border rounded-lg shadow-md max-w-lg mx-auto">
      <div className="h-72 overflow-y-auto mb-3 bg-gray-50 p-2 rounded">
        {historial.map((msg, idx) => (
          <p key={idx} className={msg.rol === "user" ? "text-right" : "text-left"}>
            <strong>{msg.rol === "user" ? "Tú" : "Bot"}:</strong> {msg.contenido}
          </p>
        ))}
        {isValidating && <p className="text-gray-500">Escribiendo…</p>}
        {error && <p className="text-red-600">Error: {error.message}</p>}
      </div>
      <div className="flex gap-2">
        <input
          value={input}