Pipeline multimodal de IA local 2026: combina voz, visión y texto sin conexión

Datos rápidos

• VRAM total para el stack completo: ~15 GB (Whisper 3 GB + LLaVA 7B 6 GB + Llama 3.1 8B 6 GB). Piper corre en CPU.
• Stack simplificado (Llama 3.2 Vision 11B): ~8 GB VRAM — maneja visión y razonamiento textual en un solo modelo.
• Latencia de voz (Whisper small, RTX 4070): STT ~200–500 ms. Primer token LLM 500–1500 ms. Piper TTS 100 ms.
• Latencia de procesamiento de imagen (LLaVA 7B, RTX 4070): ~2–5 segundos por imagen dependiendo de la resolución y el prompt.
• Sin video en tiempo real: Los VLM procesan frames individuales, no flujos de video continuos. Para video, extrae frames a 1 FPS y procesa cada uno.
• Misma instancia de Ollama para VLM + LLM: Ollama puede servir Llama 3.2 Vision como modelo de visión y modelo de texto a la vez, ahorrando VRAM.
• Todos los componentes con licencia MIT o Apache 2.0 (whisper.cpp MIT, LLaVA MIT, Llama 3.1 8B Llama 3 Community License, Piper MIT).

¿Qué es un pipeline multimodal de IA?

• Enfoque en la nube (GPT-4o): Un modelo gigante entrenado en todas las modalidades simultáneamente. El razonamiento cross-modal se aprende durante el entrenamiento — el modelo puede razonar nativamente sobre la relación entre el contenido de la imagen y las consultas de voz.
• Enfoque local (esta guía): Modelos especializados independientes para cada modalidad, conectados por un orquestador. Más modular y económico de ejecutar, pero produce "costuras" — la salida del modelo de visión se serializa a texto antes de pasarse al LLM.
• Por qué construir localmente: Privacidad (imágenes médicas, documentos propietarios, capturas de pantalla confidenciales), costo (cero tarifas por consulta), capacidad sin conexión (no se requiere internet después de descargar el modelo), personalización (intercambia cualquier componente).
• Ventaja modular: Puedes actualizar cualquier componente de forma independiente. Cuando aparezca un mejor modelo STT local, reemplaza solo la capa STT. Cuando aparezca un mejor VLM, intercambia solo el modelo de visión — el resto del pipeline no cambia.

Costo: pipeline local vs APIs en la nube (mensual)

Visión general de la arquitectura

• Tipos de entrada: Audio de micrófono (voz), imagen de cámara o archivo (visión), texto de teclado (texto).
• Lógica del router: Detecta el tipo de entrada en el límite. Audio → modelo STT. Imagen → VLM. Texto → LLM directamente. Si llegan tanto audio como imagen juntos, procesar en paralelo y combinar.
• Registro de modelos: Cada tipo de entrada se mapea a una función manejadora que llama al modelo apropiado y devuelve una descripción/transcripción de texto.
• Orquestador: Recoge todas las salidas de los modelos, las combina en un único prompt para el LLM de texto, obtiene la respuesta del LLM y la dirige al TTS para la salida de voz o a la pantalla como texto.
• Tipos de salida: Respuesta de voz (Piper TTS), texto en pantalla, o datos estructurados (JSON) para integración con otros sistemas.
• Procesamiento paralelo: STT y VLM pueden procesar simultáneamente — una consulta de audio sobre una imagen puede tener ambos procesados en paralelo, reduciendo la latencia total en un 40–60 % frente al procesamiento secuencial.

El stack de componentes

Niveles de hardware para multimodal

Caso de uso 1: Analizador de documentos controlado por voz

• Ejemplo: Fotografía una factura y di "¿Cuál es el importe total a pagar y el plazo de pago?"
• Pipeline: Whisper transcribe la pregunta → imagen enviada a LLaVA o Llama 3.2 Vision → VLM extrae texto y estructura de la factura → LLM combina pregunta + salida del VLM → Piper lee la respuesta en voz alta.
• Prompt: "Aquí hay una imagen: [descripción VLM]. El usuario pregunta: [transcripción]. Responde la pregunta basándote en el contenido de la imagen."
• Mejor VLM: MiniCPM-V 2.6 o Llama 3.2 Vision 11B para precisión de OCR en facturas y documentos.
• Valor de privacidad: Historial médico, documentos legales, estados financieros — procesados completamente en local sin que ningún dato salga de la máquina.

Caso de uso 2: Asistente de Q&A visual

• Aplicaciones: Inventario de almacén (fotografía un estante, pregunta "¿Cuántas unidades de SKU-4429 hay?"), inspección de campo (fotografía daños en maquinaria, pregunta "¿Es seguro operar esto?"), accesibilidad (describe objetos para usuarios con discapacidad visual).
• Implementación: Captura un frame de cámara (OpenCV cv2.VideoCapture(0).read()), guárdalo como JPEG, pásalo al VLM junto con la transcripción de Whisper.
• Mejores modelos: LLaVA 1.6 7B o Llama 3.2 Vision 11B para comprensión general de objetos y escenas.
• Latencia: 3–6 segundos para captura de imagen + procesamiento VLM + LLM + TTS en RTX 4070. Reduce con VLM más pequeño (Moondream 2 para identificación simple de objetos).

Caso de uso 3: Transcripción de reunión + análisis de diapositivas

• STT: Ejecuta faster-whisper en modo de streaming durante la reunión. Acumula segmentos en un buffer de transcripción.
• Visión: Cada vez que aparezca una nueva diapositiva (detectar mediante diff de captura de pantalla), captura una imagen y pásala a LLaVA para descripción.
• Combinación: Al final de la reunión (o bajo demanda), pasa transcripción + descripciones de diapositivas a Llama 3.1 8B: "Resume esta reunión y lista los puntos de acción. Aquí está la transcripción: [...]. Aquí están los contenidos de las diapositivas: [...]."
• Salida: Resumen leído en voz alta (Piper TTS) + archivo de texto guardado localmente.
• Valor GDPR: Todo el procesamiento de la reunión es local. No se envía audio, transcripción ni diapositivas a ningún servicio en la nube. Cumple para contextos legales, médicos y corporativos.

Caso de uso 4: Herramienta de accesibilidad local

• Lector de pantalla: Captura una captura de pantalla cada 2 segundos → LLaVA describe lo que hay en pantalla → Piper lo lee en voz alta. Agrega comandos de voz (Whisper) para controlar qué describir a continuación.
• Navegación por voz: Whisper transcribe comandos de voz → LLM interpreta la intención → ejecuta acciones de teclado/ratón mediante pyautogui. No se requiere internet.
• Beneficio de privacidad: Los usuarios con discapacidades suelen usar herramientas de accesibilidad en contextos sensibles (portales médicos, cuentas financieras). Una herramienta local garantiza que ningún contenido de pantalla se transmita a terceros.
• Uso con conectividad limitada: Funciona en hospitales, edificios gubernamentales y áreas con internet restringido — importante para implementaciones institucionales de accesibilidad.
• Elección de modelo para accesibilidad: Moondream 2 para descripciones de pantalla rápidas (2 GB VRAM, ~1 seg por frame). LLaVA 7B para descripciones más ricas (6 GB VRAM, ~3 seg por frame).

Caso de uso 5: Análisis local de cámara de seguridad

• Captura de frames: Usa OpenCV para capturar un frame cada 5–10 segundos desde una cámara IP vía RTSP (cv2.VideoCapture("rtsp://camera-ip:554/stream")). Para cámaras USB, usa el índice de dispositivo 0.
• Detección de movimiento: Calcula la diferencia entre frames consecutivos con cv2.absdiff(). Omite frames por debajo del umbral de movimiento — esto evita llamadas VLM innecesarias en escenas estáticas.
• Análisis VLM: Cuando se detecta movimiento, envía el frame al VLM: "Describe qué está pasando. ¿Hay una persona? ¿Qué están haciendo?"
• Salida de alerta: Si la respuesta indica una persona o anomalía, activa una notificación de escritorio local y un anuncio de Piper TTS ("Persona detectada en la puerta principal"). No se requiere servicio de notificación en la nube.
• Ventaja de privacidad: Ring y Nest envían video a los servidores de AWS y Google respectivamente. Esta configuración mantiene toda la grabación en tu hardware — sin suscripción, sin almacenamiento de video de terceros, sin compartición de datos con servicios externos.
• Mejor VLM para velocidad: Moondream 2 para procesamiento rápido de frames (~1 segundo por frame, ~2 GB VRAM) o LLaVA 7B para descripciones de escena más ricas (~3 segundos por frame, ~6 GB VRAM).
• Nota de hardware: Un Mac Mini M5 dedicado (~$600) ejecutando este stack 24/7 consume ~15–25W en reposo — menos electricidad anualmente que una suscripción a Ring Doorbell Pro.

Construyendo el orquestador Python

#!/usr/bin/env python3
"""Local multimodal orchestrator: voice + vision + text, all offline."""

import asyncio
import base64
import subprocess
import tempfile
import sounddevice as sd
import soundfile as sf
import numpy as np
import requests

OLLAMA_URL = "http://localhost:11434/api/generate"
WHISPER_BIN = "./whisper.cpp/main"
WHISPER_MODEL = "./whisper.cpp/models/ggml-small.bin"
VISION_MODEL = "llava:7b"        # or "llama3.2-vision" for combined VLM+LLM
TEXT_MODEL = "llama3.1:8b"
PIPER_VOICE = "voices/en_US-lessac-medium.onnx"
SAMPLE_RATE = 16000

async def transcribe_audio(audio: np.ndarray) -> str:
    """Convert audio array to text using whisper.cpp."""
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        sf.write(f.name, audio, SAMPLE_RATE)
        loop = asyncio.get_event_loop()
        result = await loop.run_in_executor(None, lambda: subprocess.run(
            [WHISPER_BIN, "-m", WHISPER_MODEL, "-f", f.name, "--no-timestamps", "--no-prints"],
            capture_output=True, text=True
        ))
    return result.stdout.strip()

async def describe_image(image_path: str) -> str:
    """Get text description of an image using local VLM via Ollama."""
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, lambda: requests.post(
        OLLAMA_URL,
        json={
            "model": VISION_MODEL,
            "prompt": "Describe the content of this image in detail, including any text visible.",
            "images": [image_b64],
            "stream": False,
        },
    ))
    return response.json()["response"]

async def reason(transcript: str, image_description: str | None = None) -> str:
    """Generate a response combining transcript and optional image description."""
    if image_description:
        prompt = (
            f"The user asked (via voice): {transcript}\n\n"
            f"The image shows: {image_description}\n\n"
            "Answer the question based on the image content. Be concise — 2-3 sentences."
        )
    else:
        prompt = transcript
    # Note: /api/generate is for single-turn queries.
    # For multi-turn conversation with context, use
    # /api/chat with a messages array instead.
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, lambda: requests.post(
        OLLAMA_URL,
        json={"model": TEXT_MODEL, "prompt": prompt, "stream": False},
    ))
    return response.json()["response"]

async def speak(text: str) -> None:
    """Convert text to speech using Piper TTS."""
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        await asyncio.get_event_loop().run_in_executor(None, lambda: subprocess.run(
            f'echo "{text}" | piper --model {PIPER_VOICE} --output_file {f.name}',
            shell=True, check=True
        ))
        data, sr = sf.read(f.name)
        sd.play(data, sr)
        sd.wait()

async def process_query(audio: np.ndarray, image_path: str | None = None) -> None:
    """Process a multimodal query: transcribe audio and optionally describe image in parallel."""
    if image_path:
        # Run STT and vision in parallel
        transcript, image_desc = await asyncio.gather(
            transcribe_audio(audio),
            describe_image(image_path),
        )
    else:
        transcript = await transcribe_audio(audio)
        image_desc = None

    if not transcript or len(transcript) < 3:
        return

    print(f"You: {transcript}")
    if image_desc:
        print(f"Image: {image_desc[:100]}...")

    response = await reason(transcript, image_desc)
    print(f"Assistant: {response}")
    await speak(response)

async def main():
    print("Multimodal assistant ready. Ctrl+C to stop.")
    while True:
        audio = sd.rec(int(5 * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=1, dtype="int16")
        sd.wait()
        await process_query(audio)  # Pass image_path="photo.jpg" for image queries

if __name__ == "__main__":
    asyncio.run(main())

Optimización del rendimiento

• STT + VLM paralelos: Usa asyncio.gather(transcribe_audio(), describe_image()) para ejecutar ambos simultáneamente. Ahorra 0,3–2 segundos dependiendo del tamaño del modelo STT.
• Mantén los modelos calientes: Ollama mantiene los modelos en VRAM automáticamente entre solicitudes. whisper.cpp en modo stream permanece cargado. Nunca recargues entre consultas.
• Transmite LLM → TTS: Detecta los límites de oración en la salida del LLM en streaming (., !, ?). Pasa cada oración completada a Piper mientras el LLM continúa generando.
• Gestión de VRAM: Si la VRAM total es ajustada, descarga el VLM después del procesamiento de imagen (endpoint HTTP de eliminación de Ollama) antes de cargar el LLM de texto. Agrega ~2–3 segundos pero permite que una GPU de 8 GB maneje el stack completo.
• Usa Llama 3.2 Vision como VLM + LLM combinado: Elimina por completo el overhead del cambio de modelo — un modelo maneja tanto la descripción visual como el razonamiento textual. Contrapartida: razonamiento de texto puro ligeramente más débil en comparación con Llama 3.1 8B dedicado.
• Objetivo de primer audio TTS: Piper genera el primer audio en 50–100 ms tras recibir texto. Transmite una oración a la vez para una latencia TTS percibida de menos de un segundo.

Limitaciones y evaluación honesta

• Costuras de modalidad: La salida de visión se serializa a texto antes de pasarse al LLM de texto. El LLM no puede razonar directamente sobre las características de la imagen — razona sobre una descripción textual de la imagen. Esto pierde información en tareas que requieren razonamiento visual sutil.
• Sin video en tiempo real: Los VLM locales procesan frames individuales, no video continuo. Para video, extrae frames a 0,5–2 FPS y procésalos secuencialmente. Esto significa que no puedes preguntar "qué acaba de pasar en los últimos 5 segundos de este video".
• Brecha de calidad del VLM: Los modelos de visión locales (LLaVA 7B, Llama 3.2 Vision 11B) están por detrás de GPT-4o Vision en infografías complejas, texto manuscrito, escenas ambiguas y tareas que requieren amplio conocimiento del mundo junto a la comprensión visual.
• Presión de VRAM: Ejecutar tres modelos simultáneamente en una única GPU requiere una gestión cuidadosa de la VRAM. En GPUs de 12 GB estás en el límite — los tamaños de los modelos deben elegirse cuidadosamente para evitar errores OOM (sin memoria).
• Latencia vs. nube: Una llamada multimodal en la nube (GPT-4o) tarda 1–3 segundos para audio + imagen + texto. Un pipeline local tarda 3–8 segundos en hardware comparable — más lento, pero con total privacidad y costo cero por consulta.
• Consistencia: Los modelos locales producen calidad de salida más variable que los modelos en la nube con extenso RLHF. Espera alucinaciones ocasionales tanto en descripciones de visión como en respuestas del LLM.

Preguntas frecuentes

Fuentes

• whisper.cpp en GitHub — Fuente y documentación del componente STT.
• faster-whisper en GitHub — Alternativa STT en Python con VAD integrado para streaming.
• Página del proyecto LLaVA — Arquitectura del modelo de visión y tarjetas de modelo.
• Tarjeta del modelo Llama 3.2 Vision — Modelo multimodal de Meta que soporta razonamiento con imagen + texto.
• Documentación de Ollama — API de modelos de visión, formato de solicitud multimodal.
• Piper TTS en GitHub — Componente de salida TTS, biblioteca de packs de voz.
• Coqui TTS en GitHub — TTS alternativo con soporte de clonación de voz.

Lectura relacionada

• Reconocimiento de voz local 2026: Whisper.cpp vs faster-whisper — Análisis detallado del componente STT.
• Modelos de visión locales 2026: LLaVA, Llama 3.2 Vision y Ollama — Análisis detallado del componente de visión.
• TTS local y clonación de voz 2026 — Análisis detallado del componente TTS.
• Cómo construir un asistente de voz completamente offline en 2026 — La versión solo de voz (más simple, voz + LLM + TTS sin visión).
• Guía de hardware para LLM local 2026 — Selección de hardware para pipelines multi-modelo.
• Cuantización de LLM explicada — Cómo encajar múltiples modelos en VRAM limitada mediante cuantización.