OCR ligero con Google Vision para documentos de admisión

Introducción

Los formularios y documentos de admisión suelen llegar como fotos borrosas, PDFs escaneados o imágenes desde WhatsApp. Si capturas todo manualmente, pierdes tiempo, introduces errores y tu equipo de operaciones termina apagando incendios en lugar de mejorar el proceso.

Con un OCR ligero usando Google Vision y un orquestador como Make, puedes extraer datos clave rápidamente, validarlos con reglas simples y registrarlos en tus sistemas (p. ej., CRM o HIS) sin despliegues pesados. El objetivo: menos tecleo, más precisión y trazabilidad.

En esta guía te muestro un flujo práctico “captura → OCR → validación → registro” con buenas prácticas de reintentos, idempotencia y alertas. Tú decides hasta dónde escalar.

Resumen accionable

• Define un punto único de entrada (formulario, email o WhatsApp) y normaliza archivos a PDF/PNG.
• Usa Google Vision (Text Detection/Document Text Detection) para extraer texto y bloques.
• Estructura los datos con reglas y regex (p. ej., DNI, fecha de nacimiento, póliza).
• Implementa validaciones mínimas: obligatoriedad, formatos, rangos y consentimiento.
• Aplica idempotencia con un hash del archivo para evitar duplicados.
• Configura reintentos exponenciales y alertas (email/Slack) para OCR fallido.
• Registra en tu base (p. ej., Google Sheets, PostgreSQL, CRM) con logs y estado.
• Mide calidad con un dashboard: tasa de extracción, errores, tiempo a registro.

Nota: respeta la privacidad y las normativas locales. Esto no es asesoría legal.

Captura

Para un OCR ligero, lo más importante es estandarizar cómo entra el documento. Si permites múltiples vías sin control, el resto del flujo se complica. Define 1–2 canales máximos (p. ej., formulario web con upload y buzón de email dedicado). Establece límites de tamaño y tipos permitidos (PDF, JPG, PNG) y una convención de nombres opcional (ayuda en auditorías).

En Make, configura el trigger adecuado: “Webhook” para un formulario, “Watch Emails” para buzón, o un conector de WhatsApp/API. Inmediatamente después del trigger, agrega un módulo de normalización: convierte imágenes a PNG, endereza (deskew) si es posible, y guarda en almacenamiento temporal con un ID de correlación. Esto simplifica el OCR y reduce falsos negativos.

Para fiabilidad, genera un hash (SHA-256) del binario y úsalo como clave idempotente (evita procesar el mismo archivo dos veces). Almacena metadatos: nombre original, canal, timestamp, tamaño y mimetype. Esto te da trazabilidad y base para métricas.

Diagrama (flujo general):

[Captura] --> [Normalización] --> [OCR Vision]
     \                              |
      \--> [Hash/Idempotencia] <----/
                         |
                    [Validación]
                         |
                      [Registro]
                         |
                      [Alertas/Logs]

OCR

Una vez normalizado el archivo, llama a Google Vision con el modo adecuado:

• Text Detection para documentos simples (1 página, tipografía clara).
• Document Text Detection para formularios más densos o multi-página.

Configura la codificación de salida en JSON y guarda tanto el fullTextAnnotation como los bounding boxes (coordenadas) si planeas auditorías visuales o futuros modelos de layout. En esta fase, mapea rápidamente entidades usando expresiones regulares y reglas heurísticas:

• nombre_completo (líneas con dos o más tokens alfabéticos).
• documento_identidad (DNI/INE/CC por patrón de país).
• fecha_nacimiento (ISO o dd/mm/aaaa).
• numero_poliza (alfanumérico con prefijo común).
• telefono y email.
• consentimiento (buscar “consiento”, “autorizo”, casillas marcadas si visibles).

Si tu operación requiere calidad adicional, implementa un umbral de confianza y una heurística de “fusión”: si Vision devuelve baja confianza para un campo, intenta una segunda pasada (p. ej., reescalar imagen, binarizar) antes de fallar. Mantén un contador de reintentos con backoff (p. ej., 1s, 10s, 30s).

Tras cualquier lista o bloque técnico, conviene subrayar que el OCR no es perfecto. Acepta la variabilidad de calidad de imagen y diseña el flujo para degradar con gracia (p. ej., marcar campos como “pendiente de revisión” en lugar de bloquear todo el registro).

Validación

Antes de grabar, valida con reglas claras y auditable. Comienza por lo mínimo viable:
El primer paso es obligatoriedad (nombre, documento, fecha de nacimiento), formato (regex), rango (fechas plausibles) y consentimiento. Para evitar falsos positivos, agrega filtros por canal (p. ej., si viene de WhatsApp, exige teléfono válido).

Implementa paths en Make: si pasa validación → registro; si falla → cola de revisión humana o notificación. Cuando un campo clave falla pero hay alternativas (p. ej., dos fechas detectadas), conserva ambas como candidatas y marca la prioridad. Loguea todas las decisiones con timestamp y ID de correlación.

Ejemplos de reglas (pseudo):

• documento_identidad coincide con ^[A-Z0-9.-]{6,20}$
• fecha_nacimiento entre 1920-01-01 y hoy-18 años
• telefono E.164 o patrón nacional
• email RFC básico
• consentimiento = true (si no, enviar a revisión)

Tras estas verificaciones, tendrás menos rechazos en el registro y un backlog limpio para revisión manual focalizada.

Registro

El registro debe ser transaccional, idempotente y auditable. Usa tu hash de archivo como clave natural o genera un id_admision. Si escribes en una base (p. ej., PostgreSQL) o en una hoja compartida, guarda estado de procesamiento: capturado, ocr_ok, validado, registrado, error.

En Make, agrupa el registro en un módulo atómico (p. ej., 1 transacción o 1 fila). Asegura reintentos ante fallos temporales (HTTP 429/5xx) y corta ante errores lógicos (422/validación). Emite alertas por Slack/Email cuando el estado quede en error o si el OCR supera un umbral de tiempo. Expone webhooks de callback para que otros sistemas puedan consultar el estado.

Para reporting, captura métricas: tiempo desde captura a registro, tasa de éxito por canal, top 5 motivos de error, tamaño promedio de archivo. Estas métricas alimentan mejoras continuas (p. ej., pedir mejor iluminación a los pacientes en instrucciones del formulario).

Plantilla mínima de campos (planilla OCR)

Incluye estos campos en tu planilla (hoja de cálculo) de control. Úsalos tal cual o como guía:

• id_registro
• hash_archivo
• canal_entrada (formulario/email/WhatsApp)
• timestamp_captura (ISO)
• paciente_nombre
• documento_identidad
• fecha_nacimiento (ISO)
• telefono
• email
• numero_poliza
• consentimiento (true/false)
• ocr_confianza_global (0–1)
• validacion_estado (ok/pendiente/error)
• validacion_motivo
• registro_estado (ok/error)
• registro_destino (HIS/CRM/Sheets)
• logs_referencia (URL/ID)

Después de llenar esta planilla en cada ejecución (o en batch), tendrás una fuente única de verdad para auditorías y mejora continua.

Errores comunes

• Aceptar cualquier canal sin límites: termina en caos de formatos y baja precisión.
• No aplicar idempotencia: mismos archivos procesados múltiples veces.
• Validaciones “todo o nada” que bloquean por campos secundarios dudosos.
• Falta de reintentos y backoff, generando fallos intermitentes.
• Olvidar logs y métricas, imposibilitando diagnosticar problemas.
• No definir responsables para la revisión manual y SLA de resolución.

En resumen, empieza con un flujo delgado pero robusto: una buena captura, OCR bien parametrizado, validaciones realistas y registro transaccional con trazabilidad. Desde ahí, podrás escalar a extracción por layout o modelos específicos de cada documento.

Checklist (versión resumida del asset)

• Canal único de captura definido y documentado
• Normalización a PNG/PDF + metadatos guardados
• Hash/idempotencia implementados
• Llamada a Google Vision (modo correcto)
• Mapeo de campos con regex/reglas
• Validaciones mínimas (obligatorio, formato, rango, consentimiento)
• Paths: pasar/pendiente → revisión manual
• Registro transaccional con reintentos e idempotencia
• Alertas de error + dashboard de métricas
• Planilla de control actualizada por ejecución

FAQ

1) ¿Qué diferencia hay entre Text Detection y Document Text Detection?
Document Text Detection maneja mejor páginas densas o múltiples, con estructura de bloques y mayor contexto; Text Detection es más rápido para casos simples.

2) ¿Necesito entrenar algo para empezar?
No. Con Vision puedes comenzar sin entrenamiento. Si luego quieres extraer campos por layout, evalúa modelos personalizados.

3) ¿Qué pasa si el documento está borroso o inclinado?
Normaliza: endereza, ajusta contraste y reintenta. Establece umbrales de confianza y paths de revisión manual.

4) ¿Dónde guardo los logs?
En una base o en un bucket con JSON por ejecución. Lo importante es tener correlación por hash_archivo y timestamps.

5) ¿Cómo evito duplicados?
Calcula un hash del binario y úsalo como clave idempotente. Antes de registrar, consulta si ya existe.