Implementa validación semántica eficiente con NLP en tus formularios

¿Quieres dejar de aceptar “texto por rellenar” y empezar a capturar información que realmente sirva? Bienvenido a los formularios inteligentes.

Tiempo estimado de lectura: 6 min

• Validación semántica mide intención, tono y completitud, no solo formato.
• Patrón recomendado: Cliente (debounce + AsyncValidator) → BFF/Edge → Servicio de inferencia → Telemetría y caché.
• Fail-open y caché reducen latencia y coste; nunca poner keys en el bundle.
• Prompts estructurados que devuelven JSON permiten integraciones deterministas en el frontend.

Introducción

Poca gente habla claro sobre esto: validar texto ya no es solo regex y minlength. Es entender intención, tono y completitud antes de que la información llegue a tu base de datos. Y sí: se puede hacer en producción sin convertir tu app en una pesadilla de latencias o facturación.

Resumen rápido (lectores con prisa)

Validación semántica usa modelos de NLP ligeros para evaluar intención, tono y completitud de texto de usuario.

Úsala cuando necesites datos accionables (descripciones de producto, tickets, mensajes moderados) en tiempo real.

Importa porque reduce trabajo humano, mejora calidad de datos y evita respuestas tóxicas en el origen.

Funciona como un pipeline: cliente (debounce) → BFF (auth + prompt) → inferencia → JSON estructurado → cache/telemetría.

Qué problematiza la validación tradicional

• Regex: perfecto para formatos. Horrible para sentido.
• MinLength: mide dedos en teclado, no valor.
• Moderación reactiva (post-mortem): costosa y lenta para operaciones.

Por qué importa la validación semántica

La validación semántica es un filtro de inteligencia: es un guardián que mira la intención, no el pasaporte. Te ayuda a:

• Bloquear mensajes tóxicos en el momento.
• Forzar descripciones de producto que vendan.
• Evitar tickets inútiles que consumen tiempo humano.

Arquitectura recomendada (lo que harás en serio)

1. Cliente (Angular)

UX, debouncing, AsyncValidator, Signals para estado local.

2. BFF / Edge Function (obligatorio)

recibe requests del cliente, valida JWT, llama a la API de inferencia/ML (OpenAI/Anthropic o modelo interno), devuelve JSON estructurado.

3. Servicio de inferencia (puede estar en el BFF)

llama a LLMs ligeros o a una cola si quieres bajar costos.

4. Telemetría y caché

cache de resultados por hash de texto, métricas de latencia.

Nunca pongas keys en el bundle. Punto.

Diseño del prompt: estructura estricta

Si hay una lección técnica: pide JSON. Forzar salida estructurada hace que el frontend pueda programar la respuesta sin ambigüedades.

Prompt de ejemplo para validación de tono:

System:
> Eres un validador estricto. Analiza el texto y responde SOLO con JSON. Escribe:
> {
>  "isValid": boolean,
>  "reason": string, // breve y accionable
>  "severity": "info"|"warning"|"block" // recomendación UX
>  }
> Reglas: si hay insultos claros, odio o amenazas, isValid=false, severity=block. Si hay sarcasmo agresivo, severity=warning. Si es neutral o constructivo, isValid=true.

Prompt para completitud de producto:

System:
> Eres un validador de descripciones. Para ser válida debe mencionar: material, público objetivo y al menos un beneficio. Responde SOLO con JSON:
> { "isValid": boolean, "missing": string[], "reason": string }

Ejemplo de respuesta:

{ "isValid": false, "missing": ["material"], "reason": "No se indica el material de fabricación (ej. cuero, poliéster)." }

Código: AsyncValidator en Angular (esqueleto)

Este es el patrón: debounce en el frontend; fail-open; caché por hash.

// semantic.validator.ts
import { AbstractControl, AsyncValidatorFn } from '@angular/forms';
import { from, of } from 'rxjs';
import { debounceTime, switchMap, catchError } from 'rxjs/operators';
import { sha256 } from 'some-hash-lib'; // usa una lib ligera

export function semanticValidator(apiUrl: string, tokenFn: () => string): AsyncValidatorFn {
  const cache = new Map<string, any>();

  return (control: AbstractControl) => {
    const text: string = control.value || '';
    if (text.length < 12) return Promise.resolve(null); // evitar llamadas innecesarias

    const key = sha256(text);
    if (cache.has(key)) return Promise.resolve(cache.get(key).isValid ? null : { semanticError: cache.get(key) });

    return from(Promise.resolve(text)).pipe(
      debounceTime(300),
      switchMap(t => fetch(apiUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${tokenFn()}` },
        body: JSON.stringify({ text: t })
      }).then(r => r.json())),
      catchError(() => of({ isValid: true })), // FAIL-OPEN
    ).toPromise().then((resp: any) => {
      cache.set(key, resp);
      return resp.isValid ? null : { semanticError: resp };
    });
  };
}

Patrones UX: cómo mostrar resultados sin joder conversiones

• Soft block por defecto: no deshabilites el botón. Muestra un warning con acción: “Reformular” o “Enviar de todos modos”.
• Severity: usa el campo severity del JSON para decidir si bloquear (block) o sugerir (warning).
• Feedback accionable: el campo reason debe decir exactamente qué falta o cómo suavizar el tono. No muestres “Error general”.
• Mostrar ejemplos: si pides mejores descripciones, incluye un minibloque con ejemplo correcto.

Estrategias para reducir latencia y costos

• Debounce 300–700ms en inputs largos.
• Cache por hash (cliente y BFF).
• Modo offline: fail-open y mostrar “validación temporalmente no disponible”.
• Usa modelos ligeros: gpt-4o-mini, gpt-4o-mini-embedding, o modelos on-prem más pequeños si tu infra lo permite.
• Batching: si validas varios campos (título, descripción), envíalos en un solo request al BFF.

Ejemplo de BFF (Node/Express) minimal y seguro

– Valida JWT. – Llama al servicio de inferencia. – Cache y rate-limit por usuario.

// bff.js (esqueleto)
app.post('/api/validate', authenticateJWT, async (req, res) => {
  const { text } = req.body;
  const userId = req.user.id;

  // opcional: cache check by hash
  const resp = await callInferenceService({ text, rules: req.body.rules });
  res.json(resp);
});

Medición: qué métricas te importan

• Latencia total (cliente → BFF → model → cliente).
• Tasa de falsos positivos/negativos (monitorea con muestras humanas).
• Porcentaje de fallas (fail-open).
• Cost per validation (si usas pago por token).

Falsos positivos: manejo humano

• Provee un flujo de apelación: “Si crees que esto es correcto, marca ‘Enviar’ y nuestro equipo revisará”.
• Mantén un dashboard de casos rechazados para ajustar prompts y thresholds.

Prompts: iteración y testeo

• Trata los prompts como código: versiona, A/B testea y monitorea cambios.
• Añade ejemplos (few-shot) con casos límites para reducir ambigüedad.
• Exige JSON estricto y valida con un JSON Schema en el BFF.

Ejemplo de Prompt optimizado (few-shot)

System: instrucciones como antes.
User: "Este es un ejemplo de tono aceptable: 'Estoy frustrado con el servicio porque...' => {isValid:true,...}"
User: "Ejemplo de tono no aceptable: '¡Sois unos incompetentes!...' => {isValid:false,...}"

Consideraciones legales y de privacidad

• Si envías datos sensibles a servicios externos, agrega consentimiento explícito.
• Para datos críticos, prefiere modelos on-prem o que cumplan tu política de datos.
• Loguea solo metadatos: no almacenes texto de usuario a menos que sea necesario y con consentimiento.

Checklist rápido antes de ponerlo en producción

• [ ] BFF implementado y keys no expuestas.
• [ ] Debounce y caché en cliente.
• [ ] Fail-open por defecto.
• [ ] Mensajes de UI claros y accionables.
• [ ] Métricas y dashboard de falsos positivos.
• [ ] Pruebas A/B con prompts y thresholds.

Cierre (sin pompa, con acción)

La validación semántica no es magia: es criterio aplicado con modelos. Si quieres menos ruido y mejores datos, deja de medir longitud y empieza a medir intención. Implementa el patrón BFF + AsyncValidator + Structured Prompt. Prueba el código de ejemplo en un formulario real—en 48 horas tendrás evidencia clara de si tu negocio gana o pierde con la intervención.

Haz esto ahora: copia el AsyncValidator, conéctalo a un endpoint BFF que devuelva JSON con {isValid,reason,severity}. Prueba con diez entradas reales del negocio. Si quieres, te envío un prompt optimizado para tu dominio: responde con “Quiero el prompt” y te lo doy hecho.

Dominicode Labs

FAQ

• ¿Qué diferencia hay entre validación tradicional y semántica?
• ¿Qué rendimiento debo esperar en producción?
• ¿Cómo reduzco costes al usar LLMs para validación?
• ¿Qué hago si el validador falla (falsos positivos)?
• ¿Puedo usar esto sin exponer claves en el frontend?
• ¿Qué métricas debo monitorear?