Modelos de visión locales 2026: LLaVA, Llama 3.2 Vision, Qwen2-VL y configuración multimodal con Ollama

Datos rápidos

• Qué hacen los VLMs: Aceptan imagen + texto como entrada → producen texto. No son generadores de imágenes — estos modelos *comprenden* imágenes.
• Soporte en Ollama: Todos los modelos de esta comparación tienen integración oficial o comunitaria en Ollama a partir de mayo de 2026.
• Modelo más pequeño utilizable: Moondream 2 con 1.9B parámetros, ~2 GB de VRAM.
• Modelo local práctico más grande: Llama 3.2 Vision 90B con ~64 GB de memoria unificada (Apple M-series o multi-GPU).
• Formato de entrada de imagen: JPEG, PNG, WebP aceptados. La resolución máxima varía por modelo (típicamente 1024×1024 a 4096×4096).
• Precisión OCR: Qwen2-VL 7B ≈ MiniCPM-V 2.6 > Llama 3.2 Vision 11B > LLaVA 1.6 13B > LLaVA 1.6 7B > Moondream 2.
• Multimodal ≠ rápido: Los modelos de visión añaden un encoder visual al LLM — espera una generación de tokens ~30–60% más lenta que un modelo solo de texto del mismo número de parámetros.

¿Qué son los modelos visión-lenguaje (VLMs)?

• Cómo se diferencian de los generadores de imágenes: Stable Diffusion, FLUX y DALL-E 3 son generadores de texto a imagen — producen imágenes a partir de prompts de texto. Los VLMs son modelos de imagen a texto — describen, analizan y responden preguntas sobre imágenes.
• Cómo se diferencian de las herramientas OCR tradicionales: El OCR tradicional (Tesseract, PaddleOCR) extrae texto de documentos estructurados mediante reconocimiento de patrones. Los VLMs comprenden el contexto — pueden describir el significado de una tabla, responder preguntas sobre un gráfico o identificar objetos en una fotografía.
• Por qué ejecutarlos en local: Documentos privados (registros médicos, escaneos legales, estados financieros), capturas de pantalla propietarias (paneles internos, código fuente), o cualquier flujo de trabajo donde enviar imágenes a APIs en la nube plantee problemas de cumplimiento o confidencialidad.
• Qué no pueden hacer: Generar imágenes, ejecutar código mostrado en capturas de pantalla ni acceder a internet. Los VLMs solo producen texto basado en lo que es visible en la imagen.

Modelos de visión locales disponibles — Tabla comparativa

Test de precisión real: extracción de facturas

Soporte multi-imagen

• MiniCPM-V 2.6 acepta hasta 4 imágenes por prompt; Qwen2-VL admite hasta 8. LLaVA y Moondream solo aceptan una imagen por solicitud.
• Cuándo importa el multi-imagen: Enviar todas las páginas de un PDF de varias páginas para extracción completa del documento. Comparar dos fotos de producto lado a lado. Analizar capturas de pantalla antes/después en un único prompt.

Configuración con Ollama — paso a paso

• Paso 1 — Instalar Ollama: Descarga desde ollama.com para macOS, Linux o Windows. La instalación tarda menos de 2 minutos.
• Paso 2 — Descargar un modelo de visión: ollama pull llama3.2-vision (11B, ~8 GB de descarga) o ollama pull moondream (1.9B, ~2 GB) para configuraciones con poco VRAM.
• Paso 3 — Usar desde la CLI: ollama run llama3.2-vision "¿Qué hay en esta imagen?" --image /ruta/a/foto.jpg
• Paso 4 — Usar la API HTTP: Haz un POST a http://localhost:11434/api/generate con la imagen como cadena en Base64 en el array images.
• Paso 5 — Ejemplo en Python: Usa la biblioteca requests con codificación Base64 — ver el bloque de código a continuación.

import base64
import requests

def ask_vision_model(image_path: str, prompt: str, model: str = "llama3.2-vision") -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "images": [image_b64],
            "stream": False,
        },
    )
    return response.json()["response"]

# Ejemplo de uso
result = ask_vision_model("factura.png", "Extrae todas las líneas de artículos y totales de esta factura.")
print(result)

Caso de uso 1: OCR y extracción de documentos

• Qué funciona bien: Facturas escaneadas, capturas de PDF, notas manuscritas en letra de molde, tablas con bordes claros, tarjetas de visita.
• Qué funciona peor: Texto manuscrito en cursiva, escaneos a menos de 150 DPI, JPEG con mucha compresión, texto superpuesto.
• Mejores modelos para OCR: MiniCPM-V 2.6 (mayor precisión OCR en la categoría de 6 GB), Llama 3.2 Vision 11B (mejor para tipos de documentos mixtos).
• Prompt engineering para OCR: "Extrae todo el texto de este documento exactamente como está escrito, conservando los saltos de línea." O: "Devuelve el contenido de esta factura como JSON con los campos: proveedor, fecha, líneas[], total."
• Vs. OCR tradicional: Los VLMs son más lentos pero más semánticos. Tesseract es más rápido para la extracción de texto puro de documentos limpios. Usa VLMs cuando necesites extracción de datos estructurados, no solo texto plano.

Caso de uso 2: Preguntas y respuestas sobre imágenes

• Descripción de escenas: "¿Qué hay en esta foto?" — objetos, personas, actividades, entorno, ambiente.
• Catalogación de productos: Procesa fotos de productos con una plantilla de prompt como "Describe este producto: color, forma, material, estado." Útil para inventario de comercio electrónico sin APIs en la nube.
• Accesibilidad: Genera texto alternativo para imágenes a escala. Con precisión suficiente para el cumplimiento de accesibilidad en fotos de productos estándar.
• Mejores modelos: LLaVA 1.6 13B o Llama 3.2 Vision 11B para Q&A general sobre fotos. LLaVA 1.6 7B para procesamiento en volumen donde la velocidad importa más que la precisión.
• Consideración de velocidad: En una GPU de 6 GB, Llama 3.2 Vision 11B Q4 genera ~8–12 tokens/segundo para respuestas sobre imágenes — procesar 100 imágenes tarda ~2–5 minutos según la longitud de la descripción.

Caso de uso 3: Capturas de pantalla y análisis de UI

• Flujos de trabajo para desarrolladores: Envía capturas de mensajes de error al modelo: "¿Qué está mal en esta captura de pantalla y cómo lo solucionarías?"
• Generación de informes de bugs: Genera automáticamente descripciones de bugs a partir de capturas de pantalla con un prompt estructurado.
• Monitoreo de paneles: Analiza capturas de pantalla de paneles de monitoreo en busca de anomalías — "¿Hay métricas en nivel de advertencia en esta captura de Grafana?"
• Pruebas de accesibilidad: Compara capturas antes y después de cambios en la UI para verificar las propiedades de accesibilidad visual.
• Mejores modelos: InternVL 2.5 8B (mejor comprensión de UI), MiniCPM-V 2.6 (segunda opción, con soporte de Ollama).

Caso de uso 4: Lectura de gráficos y diagramas

• Qué funciona: Leer etiquetas de ejes, identificar tendencias, comparar alturas relativas de barras, leer valores de tablas con fuentes claras.
• Qué no es fiable: Extracción numérica precisa de gráficos continuos (p. ej., "la barra del T3 es 43.7 unidades"), porcentajes de gráficos circulares sin etiquetas explícitas.
• Estrategia de prompt: "Describe la tendencia mostrada en este gráfico de líneas" funciona mejor que "¿Cuál es el valor exacto en marzo de 2026?"
• Mejores modelos para gráficos: InternVL 2.5 (mejor comprensión de gráficos), Llama 3.2 Vision 11B (bueno en gráficos con etiquetas claras).
• Nota sobre limitaciones: Ningún VLM local en 2026 extrae de forma fiable números precisos de gráficos visualmente complejos. Para datos de gráficos estructurados, extráelos de la fuente de datos subyacente si es posible.

Caso de uso 5: Análisis de fotogramas de video

• Extracción de fotogramas: Usa ffmpeg para extraer a 1fps: ffmpeg -i video.mp4 -vf fps=1 frames/frame_%04d.jpg
• Análisis por fotograma: Ejecuta cada fotograma a través del modelo de visión con un prompt consistente (p. ej., "Describe lo que ocurre en este fotograma en una frase").
• Resumen entre fotogramas: Recopila todas las descripciones de fotogramas y pásalas a un LLM de texto con un prompt de resumen.
• Casos de uso: Revisión de cámaras de seguridad (marcar fotogramas con actividad inusual), análisis de grabaciones de clases (generar notas diapositiva por diapositiva), inspección de calidad en fabricación (marcar fotogramas donde aparecen defectos).
• Mejores modelos para fotogramas de video: Llama 3.2 Vision 11B para calidad, LLaVA 1.6 7B para velocidad (mayor rendimiento de fotogramas).
• Realidad de velocidad: A 1 fotograma/segundo de extracción y ~1 segundo por fotograma de inferencia en una RTX 4070, un video de 10 minutos tarda ~20–30 minutos en procesarse completamente.

import base64
import subprocess
import os
import requests

def extract_frames(video_path: str, output_dir: str, fps: int = 1) -> list[str]:
    os.makedirs(output_dir, exist_ok=True)
    subprocess.run([
        "ffmpeg", "-i", video_path,
        "-vf", f"fps={fps}",
        f"{output_dir}/frame_%04d.jpg",
        "-y"
    ], check=True)
    return sorted([
        os.path.join(output_dir, f)
        for f in os.listdir(output_dir)
        if f.endswith(".jpg")
    ])

def analyze_frame(image_path: str, model: str = "llama3.2-vision") -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": "Describe what is happening in this frame in one sentence.",
            "images": [image_b64],
            "stream": False,
        },
    )
    return response.json()["response"]

frames = extract_frames("clase.mp4", "frames/", fps=1)
descriptions = [analyze_frame(f) for f in frames]
print("\n".join(f"[{i+1}s] {d}" for i, d in enumerate(descriptions)))

VRAM y comprobación de rendimiento real

Cómo se comparan los modelos de visión locales con GPT-4o Vision

• Documentos estructurados (facturas, formularios): Los modelos locales al 80–90% de la calidad de GPT-4o — suficiente para uso en producción con documentos limpios y bien formateados.
• Escenas complejas, imágenes ambiguas: Los modelos locales al 50–70% de GPT-4o — brecha de calidad notable en imágenes con contexto inusual, iluminación o contenido ambiguo.
• Reconocimiento de escritura a mano: Los modelos locales son significativamente más débiles, especialmente con cursiva. GPT-4o Vision maneja la escritura a mano de forma sustancialmente mejor.
• Extracción de datos de gráficos: Poco fiable tanto en modelos locales como en GPT-4o, pero GPT-4o es más preciso en valores numéricos exactos.
• Costo: GPT-4o Vision a $0.01–0.03 por imagen vs $0 en local. 10,000 imágenes/mes = $100–300 ahorrados con modelos locales.
• Privacidad: Los modelos locales procesan imágenes en el dispositivo — ningún dato sale de la máquina. GPT-4o envía imágenes a los servidores de OpenAI.
• Velocidad: Los modelos locales a 10–20 tok/seg vs GPT-4o a 30–80 tok/seg, pero el local no tiene latencia de red para el procesamiento por lotes.

Análisis detallado de LLaVA

• Arquitectura: Encoder visual CLIP ViT-L/14 + decodificador de texto Llama-2 o Mistral, conectados por una capa de proyección lineal simple.
• LLaVA 1.5 vs 1.6: La versión 1.6 (lanzada a principios de 2024) añadió soporte para entrada en alta resolución mediante parches dinámicos, mejorando significativamente la precisión de OCR y la lectura de gráficos.
• Entrenamiento: Ajuste por instrucciones en LLaVA-Instruct-150K — un dataset de conversaciones visuales generadas a partir de descripciones de imágenes y anotaciones de detección de objetos.
• Fortalezas: Amplio conocimiento general, bien documentado, comunidad amplia, extensa integración con Ollama.
• Debilidades: OCR más débil que MiniCPM-V 2.6, análisis de UI más débil que InternVL 2.5, superado en general por Llama 3.2 Vision 11B en benchmarks de calidad.
• Por qué sigue siendo recomendado: LLaVA 1.6 tiene la comunidad más grande, la mayor cantidad de tutoriales y los más ejemplos de prompts de todos los VLMs locales. Si tienes problemas, es más fácil encontrar ayuda.

Qwen2-VL — Mejor OCR multilingüe y rendimiento en documentos

• Arquitectura: Soporte de resolución dinámica hasta 4096×4096 — significativamente mayor que LLaVA 1.6 (672×672) o Llama 3.2 Vision (1120×1120). Esto permite leer escaneos de alto DPI sin necesidad de submuestreo.
• OCR multilingüe: Lo mejor de su clase para chino, japonés, coreano e inglés. Los datos de entrenamiento incluyeron corpus de documentos multilingües a gran escala — una ventaja significativa sobre LLaVA y Llama 3.2 Vision para documentos en idiomas distintos al inglés.
• 7B vs 72B: El 7B cabe en ~6 GB de VRAM (Q4) y es competitivo con Llama 3.2 Vision 11B en la mayoría de tareas con documentos. El 72B usa ~48 GB y lidera la mayoría de benchmarks de código abierto.
• Instalación en Ollama: ollama pull qwen2-vl:7b — disponible directamente desde la biblioteca de modelos de Ollama.
• Soporte multi-imagen: Acepta hasta 8 imágenes por solicitud — la mayor capacidad multi-imagen de todos los modelos de esta comparación.
• Página del modelo: Qwen2-VL 7B en Hugging Face

Cómo elegir tu modelo de visión

• Menos de 4 GB de VRAM: Moondream 2 (1.9B) — única opción viable a 2 GB. Más allá de Moondream 2, PaliGemma 2 (3B) y SmolVLM (2.2B) son alternativas viables. PaliGemma 2 tiene mejor comprensión de documentos que Moondream con un ligero costo adicional de VRAM (~3 GB). SmolVLM sacrifica calidad por eficiencia extrema. Ninguno es adecuado para OCR de texto denso.
• 6 GB de VRAM: MiniCPM-V 2.6 para OCR de documentos y procesamiento de facturas. LLaVA 1.6 7B para Q&A general sobre fotos donde el soporte comunitario importa. Qwen2-VL 7B para OCR multilingüe o cuando se necesita la mayor precisión OCR posible.
• 8–16 GB de VRAM: Llama 3.2 Vision 11B es la recomendación clara — mejor calidad general en esta categoría de VRAM, amplio soporte en Ollama.
• 16+ GB de VRAM: LLaVA 1.6 13B añade más capacidad para la comprensión de escenas complejas frente a la variante de 7B. InternVL 2.5 8B si tu caso de uso principal son capturas de UI o código.
• 64+ GB de memoria unificada (Apple M-Max/Ultra, multi-GPU): Llama 3.2 Vision 90B para la mejor calidad de VLM local disponible, acercándose al rendimiento de nivel nube para tareas con documentos. Qwen2-VL 72B es una alternativa con las mejores puntuaciones en benchmarks de código abierto.
• Verifica siempre los números: Independientemente del modelo, contrasta cualquier valor numérico extraído de gráficos o tablas con los datos originales. Los VLMs locales alucinan números precisos a partir de gráficos visuales.

Preguntas frecuentes

Fuentes

• Página del proyecto LLaVA — Tarjetas de modelo LLaVA 1.5 y 1.6, detalles de arquitectura y descripción del dataset de entrenamiento.
• Llama 3.2 Vision en Hugging Face — Lanzamiento oficial del modelo de Meta, tarjeta de modelo y cifras de benchmark.
• MiniCPM-V 2.6 en Hugging Face — Tarjeta de modelo de OpenBMB, benchmarks de OCR e instrucciones de fine-tuning.
• Moondream en GitHub — Descripción de arquitectura, scripts de inferencia y descarga del modelo.
• InternVL 2.5 en Hugging Face — Tarjeta de modelo de OpenGVLab, puntuaciones de benchmark en documentos y tareas de UI.
• Documentación de Ollama — Soporte de modelos de visión, referencia de API y biblioteca de modelos.
• Qwen2-VL en Hugging Face — Tarjeta de modelo Qwen2-VL de Alibaba, detalles de arquitectura y benchmarks de OCR multilingüe.
• PaliGemma 2 en Hugging Face — Tarjeta de modelo PaliGemma 2 3B de Google.
• SmolVLM en Hugging Face — Tarjeta de modelo SmolVLM de HuggingFace e instrucciones de inferencia.

Lectura relacionada

• Pipeline de IA multimodal local 2026 — Combina modelos de visión con STT y TTS en un stack multimodal local completo.
• Reconocimiento de voz local 2026: Whisper.cpp vs faster-whisper — Añade entrada de voz para complementar la salida de visión.
• TTS local y clonación de voz 2026 — Añade salida de voz para leer en voz alta las respuestas del VLM.
• Cómo instalar Ollama — Requisito previo: configuración e instalación de Ollama.
• Guía de hardware para LLMs locales 2026 — Requisitos de VRAM y RAM para la inferencia de modelos de visión.