Módulo 8: Document Analyzer Multimodal

1. Introducción: Proyecto Integrador

Descripción

Este es el Módulo 8 de la Guía de IA Multimodal: el proyecto integrador final. Los módulos 1-7 enseñaron las piezas individuales — vision, documentos, generación de imágenes, audio, RAG y patrones de uso. Este módulo las combina en un sistema completo y funcional: Document Analyzer Multimodal. Un sistema que recibe documentos (PDF, imágenes escaneadas), los procesa automáticamente, extrae información estructurada con vision, indexa el contenido para preguntas y respuestas, y opcionalmente genera un resumen en audio.

Por qué un proyecto integrador: Dominar APIs individuales es necesario pero no suficiente. La diferencia entre un developer que "sabe usar GPT-4 Vision" y uno que "construye sistemas multimodales" está en la integración: cómo conectar procesamiento de documentos con vision, vision con RAG, RAG con audio, y todo empaquetado en una API REST lista para producción. Este módulo cierra esa brecha.

Qué hace el Document Analyzer: Imagina que trabajas en una empresa que recibe cientos de documentos diarios — facturas, contratos, manuales técnicos, informes. El Document Analyzer automatiza su procesamiento completo:

Recibe un PDF o imagen
Detecta si tiene texto extraíble o es escaneado (necesita OCR/vision)
Clasifica el tipo de documento (factura, contrato, manual, otro)
Extrae datos estructurados según el tipo (fecha, total, proveedor para facturas)
Genera un resumen ejecutivo
Indexa el contenido para Q&A posterior
Responde preguntas específicas sobre el documento
Opcionalmente genera el resumen en audio (TTS)
Expone todo como API REST con FastAPI

Resultado: Al terminar el módulo, tendrás un sistema portfolio-worthy y production-ready que demuestra dominio real de IA multimodal.

¿Dónde Estamos en la Guía?

Contexto

Esta guía tiene 8 módulos organizados en 3 fases:

Phase 1: Fundamentos Multimodales (Módulos 1-3)
├── Módulo 1: Introducción a IA Multimodal         ✅ Completado
├── Módulo 2: Vision + LLMs                        ✅ Completado
└── Módulo 3: Comprensión de Documentos            ✅ Completado

Phase 2: Generación y Audio (Módulos 4-5)
├── Módulo 4: Generación de Imágenes               ✅ Completado
└── Módulo 5: Procesamiento de Audio               ✅ Completado

Phase 3: RAG, Casos de Uso y Proyecto (Módulos 6-8)
├── Módulo 6: RAG Multimodal                       ✅ Completado
├── Módulo 7: Casos de Uso                         ✅ Completado
└── Módulo 8: Proyecto Final — Document Analyzer   ← ESTÁS AQUÍ

Duración total de la guía: 6-7 horas. Duración de este módulo: ~90 minutos (el más largo, por ser integrador).

Cómo se conecta todo

Cada módulo anterior aportó una capacidad que ahora integras:

Módulo 1 (Fundamentos)      → Clasificador de input: detectar tipo de archivo
Módulo 2 (Vision)           → Extracción estructurada: analizar imágenes de documentos
Módulo 3 (Documentos)       → Procesamiento PDF: extraer texto e imágenes
Módulo 4 (Gen. Imágenes)    → [No se usa directamente en este proyecto]
Módulo 5 (Audio)            → TTS: generar resumen hablado
Módulo 6 (RAG)              → Indexación y Q&A: responder preguntas sobre documentos
Módulo 7 (Casos de Uso)     → Patrones: selector de caso de uso, fallbacks, costos

El Módulo 4 (generación de imágenes) no se integra directamente — el Document Analyzer consume imágenes, no las genera. Pero el conocimiento de formatos, resolución y encoding que aprendiste allí sí aplica al procesamiento de imágenes de documentos.

Arquitectura del Document Analyzer

Diagrama de flujo completo

                         ┌──────────────────────────────────┐
                         │     API REST (FastAPI)           │
                         │     POST /analyze                │
                         │     POST /ask                    │
                         │     GET  /health                 │
                         └──────────┬───────────────────────┘
                                    │
                                    ▼
                    ┌───────────────────────────────┐
                    │     Input Validator            │
                    │  - Tipo de archivo (PDF/img)   │
                    │  - Tamaño máximo               │
                    │  - Formato válido              │
                    └───────────┬───────────────────┘
                                │
                                ▼
                    ┌───────────────────────────────┐
                    │     DocumentProcessor (M3)     │
                    │  - Extraer texto de PDF        │
                    │  - Detectar págs. escaneadas   │
                    │  - Convertir a imágenes        │
                    │  - Chunking para RAG           │
                    └───────────┬───────────────────┘
                                │
                    ┌───────────┴───────────┐
                    ▼                       ▼
        ┌───────────────────┐   ┌───────────────────┐
        │  VisionAnalyzer   │   │   RAGModule (M6)   │
        │  (M2)             │   │  - Indexar chunks   │
        │  - Clasificar doc │   │  - Embeddings       │
        │  - Extraer datos  │   │  - Retrieval        │
        │  - Fallback multi │   │  - Q&A generation   │
        └────────┬──────────┘   └────────┬──────────┘
                 │                        │
                 ▼                        ▼
        ┌───────────────────┐   ┌───────────────────┐
        │  Summarizer       │   │   AudioModule (M5) │
        │  - Resumen texto  │   │  - TTS del resumen │
        │  - Puntos clave   │   │  - Voz configurable│
        └───────────────────┘   └───────────────────┘

Flujo de datos simplificado

PDF/Imagen → Validar → Procesar documento → ┬→ Clasificar tipo (Vision)
                                             ├→ Extraer datos estructurados (Vision)
                                             ├→ Generar resumen (LLM)
                                             ├→ Indexar para Q&A (RAG + ChromaDB)
                                             ├→ Responder pregunta (si se envió)
                                             └→ Generar audio del resumen (TTS, opcional)

Componentes y su Origen

Mapa de reutilización

Componente	Clase/Función	Módulo de origen	Qué aporta
Input Validator	`validate_input()`	Módulo 1	Detectar tipo de archivo, validar formato y tamaño
DocumentProcessor	`DocumentProcessor`	Módulo 3	Extraer texto/imágenes de PDFs, detectar páginas escaneadas
VisionAnalyzer	`VisionAnalyzer`	Módulo 2	Clasificar documentos, extraer datos estructurados de imágenes
RAGModule	`RAGModule`	Módulo 6	Indexar chunks en ChromaDB, buscar y generar respuestas
AudioModule	`AudioModule`	Módulo 5	Generar audio del resumen con TTS de OpenAI
UseCaseSelector	`classify_document()`	Módulo 7	Determinar tipo de documento para aplicar schema correcto
API Router	FastAPI endpoints	Módulo 7	REST API para integración externa

Adaptaciones respecto a los módulos originales

No es "copiar y pegar" de módulos anteriores. Cada componente se adapta:

DocumentProcessor ahora detecta páginas mixtas (texto + escaneadas) dentro del mismo PDF
VisionAnalyzer incluye fallback multi-proveedor (OpenAI → Anthropic → Google)
RAGModule indexa tanto texto como descripciones de imágenes (multimodal RAG)
AudioModule maneja resúmenes largos dividiendo en chunks de audio
API integra todo en un solo endpoint con opciones configurables

Roadmap del Módulo 8

Mapa de cápsulas

#	Cápsula	Qué construirás	Duración
01	Introducción (esta)	Contexto, arquitectura, setup	10 min
02	Especificaciones técnicas	Inputs, outputs, modelos de datos, endpoints	10 min
03	Procesamiento de documentos	`DocumentProcessor` completo	15 min
04	Análisis con vision	`VisionAnalyzer` con fallback	15 min
05	RAG y Q&A	`RAGModule` con indexación y respuestas	15 min
06	Integración de audio	`AudioModule` con TTS	10 min
07	Deployment y optimización	Docker, FastAPI, monitoring, costos	10 min
08	Proyecto: Document Analyzer	Sistema completo integrado, tests, demo	15 min

Flujo de construcción

Cápsula 02: Defines QUÉ va a hacer el sistema (especificaciones)
    ↓
Cápsulas 03-06: Construyes CADA módulo individualmente
    ↓
Cápsula 07: Preparas el DEPLOYMENT (Docker, API, monitoring)
    ↓
Cápsula 08: INTEGRAS todo en DocumentAnalyzer y ejecutas el demo completo

Cada cápsula es independiente: puedes construir y probar cada módulo por separado antes de integrar. Esto es deliberado — en sistemas reales, primero construyes y validas componentes, luego los conectas.

Duración total estimada: 90 minutos.

Objetivos del Módulo

Al terminar este módulo serás capaz de:

✅ Diseñar la arquitectura de un sistema multimodal de múltiples componentes
✅ Implementar procesamiento de documentos con detección de páginas escaneadas vs texto
✅ Integrar vision APIs con fallback multi-proveedor para extracción estructurada
✅ Construir un pipeline RAG que indexa texto y descripciones de imágenes
✅ Agregar generación de audio (TTS) como output opcional
✅ Desplegar el sistema como API REST con FastAPI y Docker
✅ Aplicar patrones de producción: logging, validación, manejo de errores, costos
✅ Tener un proyecto portfolio-worthy que demuestra dominio de IA multimodal

Objetivo profesional

Cuando alguien te pregunte "¿puedes construir un sistema que procese documentos con IA?", tu respuesta no será "sí, puedo llamar a la API de OpenAI". Será "sí, aquí está el sistema: procesa PDFs y imágenes, extrae datos estructurados, responde preguntas, genera resúmenes en audio, tiene API REST, fallbacks por proveedor, y está listo para Docker". Ese es el nivel que este módulo te da.

Prerrequisitos

Conocimientos necesarios (de módulos anteriores)

Módulo	Concepto clave	Necesitas saber
Módulo 1	Clasificación de inputs	Detectar tipo de archivo, modalidad
Módulo 2	Vision APIs	Enviar imágenes a GPT-4o/Claude, obtener análisis
Módulo 3	Procesamiento de documentos	Extraer texto/imágenes de PDFs con PyMuPDF
Módulo 5	Audio/TTS	Generar audio desde texto con OpenAI TTS
Módulo 6	RAG	Indexar en ChromaDB, embeddings, retrieval
Módulo 7	Patrones de uso	Selección de caso de uso, fallbacks

Si no completaste módulos anteriores

Puedes seguir este módulo, pero te recomendamos al menos haber leído:

Módulo 3 (documentos) — La base del procesamiento de input
Módulo 2 (vision) — La extracción con modelos de visión
Módulo 6 (RAG) — El sistema de preguntas y respuestas

Los demás módulos aportan funcionalidad opcional o patrones que puedes revisar después.

Herramientas necesarias

Python 3.11+
API key de OpenAI (obligatoria)
API key de Anthropic (opcional, para fallback de vision)
Editor con terminal (VS Code, Cursor, PyCharm)
Docker (opcional, para deployment)

Setup Técnico

Dependencias

python -m venv venv
source venv/bin/activate

pip install openai>=1.0.0 \
            pymupdf>=1.24.0 \
            pillow>=10.0.0 \
            pydantic>=2.0.0 \
            chromadb>=0.5.0 \
            langchain>=0.2.0 \
            langchain-openai>=0.1.0 \
            fastapi>=0.110.0 \
            uvicorn>=0.29.0 \
            python-multipart>=0.0.9 \
            python-dotenv>=1.0.0

Dependencias opcionales:

pip install anthropic>=0.25.0    # Fallback vision con Claude
pip install pydub>=0.25.0        # Concatenar audios largos
pip install slowapi>=0.1.9       # Rate limiting

Variables de entorno

Crea un archivo .env:

OPENAI_API_KEY=sk-...

# Opcionales
ANTHROPIC_API_KEY=sk-ant-...
LOG_LEVEL=INFO
MAX_FILE_SIZE_MB=50
REQUEST_TIMEOUT=120

Carga en tu código:

from dotenv import load_dotenv
import os

load_dotenv()

assert os.getenv("OPENAI_API_KEY"), "Falta OPENAI_API_KEY en .env"

Verificación del setup

from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Responde solo 'OK'."}],
    max_tokens=5
)
print(response.choices[0].message.content)

Si ves OK, tu entorno está listo.

Estructura de archivos del proyecto

document-analyzer/
├── .env                         # API keys (NO commitear)
├── requirements.txt             # Dependencias
├── Dockerfile                   # Containerización
├── docker-compose.yml           # Orquestación
├── main.py                      # FastAPI app + endpoints
├── modules/
│   ├── __init__.py
│   ├── document_processor.py    # Cápsula 03
│   ├── vision_analyzer.py       # Cápsula 04
│   ├── rag_module.py            # Cápsula 05
│   └── audio_module.py          # Cápsula 06
├── models/
│   ├── __init__.py
│   └── schemas.py               # Modelos Pydantic (Cápsula 02)
├── tests/
│   ├── test_processor.py
│   ├── test_vision.py
│   └── test_integration.py
└── samples/
    ├── factura_ejemplo.pdf       # PDF de prueba
    ├── contrato_ejemplo.pdf      # PDF de prueba
    └── imagen_documento.png      # Imagen de prueba

Costos estimados del módulo

Operación	Modelo	Costo por documento
Clasificación	gpt-4o-mini	~$0.001
Extracción estructurada (texto)	gpt-4o-mini	~$0.003
Extracción estructurada (imagen)	gpt-4o	~$0.01-0.03
Resumen	gpt-4o-mini	~$0.002
Embeddings (indexación)	text-embedding-3-small	~$0.001
Q&A (generación)	gpt-4o	~$0.01
TTS (resumen audio)	tts-1	~$0.015/1K chars
Total por documento (con audio)	—	~$0.05-0.10

Para desarrollo y pruebas de este módulo: ~$1-3 USD total.

Evidencia de Éxito

Al terminar este módulo, sabrás que tuviste éxito si:

✅ Tu DocumentProcessor procesa PDFs con páginas de texto y escaneadas correctamente
✅ Tu VisionAnalyzer extrae datos estructurados y tiene fallback funcional
✅ Tu RAGModule indexa documentos y responde preguntas con fuentes
✅ Tu AudioModule genera audio del resumen
✅ Tu API REST responde a POST /analyze con el resultado completo
✅ Puedes ejecutar docker build y levantar el servicio en un contenedor
✅ El sistema procesa un PDF de ejemplo end-to-end sin errores

Test rápido de autoevaluación

Si puedes responder estas preguntas antes de empezar, vas bien preparado:

¿Cómo extraes texto de un PDF con PyMuPDF?
¿Qué formato necesitas para enviar una imagen a GPT-4o Vision?
¿Qué hace ChromaDB y cómo indexas un documento?
¿Cómo generas audio desde texto con la API de OpenAI?
¿Qué es un endpoint POST en FastAPI y cómo recibe archivos?

Si alguna te cuesta, revisa el módulo correspondiente antes de continuar. O avanza y consulta el módulo relevante cuando llegues a esa cápsula.

Resumen

Módulo 8 es el proyecto integrador final de la Guía de IA Multimodal.
Construirás un Document Analyzer Multimodal que procesa PDFs/imágenes, extrae datos, hace Q&A y genera audio.
El sistema integra componentes de los 7 módulos anteriores: clasificación (M1), vision (M2), documentos (M3), audio (M5), RAG (M6), patrones (M7).
La arquitectura tiene 6 componentes principales: DocumentProcessor, VisionAnalyzer, RAGModule, AudioModule, Summarizer, API REST.
Cada cápsula construye un componente independiente; la cápsula 08 los integra.
Duración estimada: 90 minutos. Costo estimado: $1-3 USD.

Recursos Adicionales

FastAPI — Framework para la API REST
PyMuPDF — Procesamiento de PDFs
ChromaDB — Base de datos vectorial para RAG
OpenAI Vision — Análisis de imágenes
OpenAI TTS — Text-to-speech
Docker — Containerización

← Anterior8. Proyecto: Use Case Selector Siguiente →2. Especificaciones Técnicas