Modelos de visão locais 2026: LLaVA, Llama 3.2 Vision, Qwen3-VL e configuração multimodal com Ollama

Fatos rápidos

• O que os VLMs fazem: Aceitam imagem + texto como entrada → produzem texto. Não são geradores de imagens — esses modelos *compreendem* imagens.
• Suporte no Ollama: Todos os modelos desta comparação têm integração oficial ou comunitária no Ollama a partir de maio de 2026.
• Menor modelo utilizável: Moondream 2 com 1.9B parâmetros, ~2 GB de VRAM.
• Maior modelo local prático: Llama 3.2 Vision 90B com ~64 GB de memória unificada (Apple M-series ou multi-GPU).
• Formato de entrada de imagem: JPEG, PNG, WebP aceitos. A resolução máxima varia por modelo (tipicamente 1024×1024 a 4096×4096).
• Precisão OCR: Qwen3-VL 8B ≈ MiniCPM-V 4.5 > Llama 3.2 Vision 11B > LLaVA 1.6 13B > LLaVA 1.6 7B > Moondream 2.
• Multimodal ≠ rápido: Os modelos de visão adicionam um encoder visual ao LLM — espere uma geração de tokens ~30–60% mais lenta do que um modelo apenas de texto do mesmo número de parâmetros.

O que são os modelos visão-linguagem (VLMs)?

• Como se diferenciam dos geradores de imagens: Stable Diffusion, FLUX e DALL-E 3 são geradores de texto para imagem — produzem imagens a partir de prompts de texto. Os VLMs são modelos de imagem para texto — descrevem, analisam e respondem perguntas sobre imagens.
• Como se diferenciam das ferramentas OCR tradicionais: O OCR tradicional (Tesseract, PaddleOCR) extrai texto de documentos estruturados via reconhecimento de padrões. Os VLMs compreendem o contexto — podem descrever o significado de uma tabela, responder perguntas sobre um gráfico ou identificar objetos em uma fotografia.
• Por que executá-los localmente: Documentos privados (prontuários médicos, escaneamentos jurídicos, extratos financeiros), capturas de tela proprietárias (painéis internos, código-fonte), ou qualquer fluxo de trabalho onde enviar imagens para APIs na nuvem apresenta problemas de conformidade ou confidencialidade.
• O que não conseguem fazer: Gerar imagens, executar código mostrado em capturas de tela nem acessar a internet. Os VLMs apenas produzem texto baseado no que é visível na imagem.

Modelos de visão locais disponíveis — Tabela comparativa

Teste de precisão real: extração de faturas

Suporte multi-imagem

• MiniCPM-V 4.5 aceita até 4 imagens por prompt; Qwen3-VL suporta até 8. LLaVA e Moondream aceitam apenas uma imagem por solicitação.
• Quando o multi-imagem importa: Enviar todas as páginas de um PDF de várias páginas para extração completa do documento. Comparar duas fotos de produto lado a lado. Analisar capturas de tela antes/depois em um único prompt.

Configuração com Ollama — passo a passo

• Passo 1 — Instalar o Ollama: Baixe em ollama.com para macOS, Linux ou Windows. A instalação leva menos de 2 minutos.
• Passo 2 — Baixar um modelo de visão: ollama pull llama3.2-vision (11B, ~8 GB de download) ou ollama pull moondream (1.9B, ~2 GB) para configurações com pouca VRAM.
• Passo 3 — Usar via CLI: ollama run llama3.2-vision "O que há nesta imagem?" --image /caminho/para/foto.jpg
• Passo 4 — Usar a API HTTP: Faça um POST para http://localhost:11434/api/generate com a imagem como string em Base64 no array images.
• Passo 5 — Exemplo em Python: Use a biblioteca requests com codificação Base64 — veja o bloco de código abaixo.

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"]

# Exemplo de uso
result = ask_vision_model("fatura.png", "Extraia todas as linhas de itens e totais desta fatura.")
print(result)

Caso de uso 1: OCR e extração de documentos

• O que funciona bem: Faturas escaneadas, capturas de PDF, notas manuscritas em letra de forma, tabelas com bordas claras, cartões de visita.
• O que funciona pior: Texto manuscrito em cursiva, escaneamentos abaixo de 150 DPI, JPEG com muita compressão, texto sobreposto.
• Melhores modelos para OCR: MiniCPM-V 4.5 (maior precisão OCR na categoria de 6 GB), Llama 3.2 Vision 11B (melhor para tipos de documentos mistos).
• Prompt engineering para OCR: "Extraia todo o texto deste documento exatamente como está escrito, preservando as quebras de linha." Ou: "Retorne o conteúdo desta fatura como JSON com os campos: fornecedor, data, linhas[], total."
• Vs. OCR tradicional: Os VLMs são mais lentos, mas mais semânticos. Tesseract é mais rápido para a extração de texto puro de documentos limpos. Use VLMs quando precisar de extração de dados estruturados, não apenas texto simples.

Caso de uso 2: Perguntas e respostas sobre imagens

• Descrição de cenas: "O que há nesta foto?" — objetos, pessoas, atividades, ambiente, atmosfera.
• Catalogação de produtos: Processe fotos de produtos com um template de prompt como "Descreva este produto: cor, forma, material, estado." Útil para inventário de e-commerce sem APIs na nuvem.
• Acessibilidade: Gere texto alternativo para imagens em escala. Com precisão suficiente para conformidade de acessibilidade em fotos de produtos padrão.
• Melhores modelos: LLaVA 1.6 13B ou Llama 3.2 Vision 11B para Q&A geral sobre fotos.
• Consideração de velocidade: Em uma GPU de 6 GB, Llama 3.2 Vision 11B Q4 gera ~8–12 tokens/segundo para respostas sobre imagens.

Caso de uso 3: Capturas de tela e análise de UI

• Fluxos de trabalho para desenvolvedores: Envie capturas de mensagens de erro ao modelo: "O que está errado nesta captura de tela e como você corrigiria?"
• Geração de relatórios de bugs: Gere automaticamente descrições de bugs a partir de capturas de tela com um prompt estruturado.
• Monitoramento de painéis: Analise capturas de tela de painéis de monitoramento em busca de anomalias.
• Testes de acessibilidade: Compare capturas antes e depois de mudanças na UI para verificar as propriedades de acessibilidade visual.
• Melhores modelos: InternVL 2.5 8B (melhor compreensão de UI), MiniCPM-V 4.5 (segunda opção, com suporte do Ollama).

Caso de uso 4: Leitura de gráficos e diagramas

• O que funciona: Ler rótulos de eixos, identificar tendências, comparar alturas relativas de barras, ler valores de tabelas com fontes claras.
• O que não é confiável: Extração numérica precisa de gráficos contínuos, porcentagens de gráficos de pizza sem rótulos explícitos.
• Estratégia de prompt: "Descreva a tendência mostrada neste gráfico de linhas" funciona melhor do que "Qual é o valor exato em março de 2026?"
• Melhores modelos para gráficos: InternVL 2.5 (melhor compreensão de gráficos), Llama 3.2 Vision 11B (bom em gráficos com rótulos claros).
• Nota sobre limitações: Nenhum VLM local em 2026 extrai de forma confiável números precisos de gráficos visualmente complexos.

Caso de uso 5: Análise de quadros de vídeo

• Extração de quadros: Use ffmpeg para extrair a 1fps: ffmpeg -i video.mp4 -vf fps=1 frames/frame_%04d.jpg
• Análise por quadro: Execute cada quadro pelo modelo de visão com um prompt consistente.
• Resumo entre quadros: Colete todas as descrições de quadros e passe-as a um LLM de texto com um prompt de resumo.
• Casos de uso: Revisão de câmeras de segurança, análise de gravações de aulas, inspeção de qualidade na fabricação.
• Melhores modelos para quadros de vídeo: Llama 3.2 Vision 11B para qualidade, LLaVA 1.6 7B para velocidade.
• Realidade de velocidade: A 1 quadro/segundo de extração e ~1 segundo por quadro de inferência em uma RTX 4070, um vídeo de 10 minutos leva ~20–30 minutos para ser completamente processado.

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": "Descreva o que está acontecendo neste quadro em uma frase.",
            "images": [image_b64],
            "stream": False,
        },
    )
    return response.json()["response"]

frames = extract_frames("aula.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 e verificação de desempenho real

Como os modelos de visão locais se comparam ao GPT-5.5 Vision

• Documentos estruturados (faturas, formulários): Os modelos locais a 80–90% da qualidade do GPT-5.5 — suficiente para uso em produção com documentos limpos e bem formatados.
• Cenas complexas, imagens ambíguas: Os modelos locais a 50–70% do GPT-5.5 — lacuna de qualidade notável.
• Reconhecimento de escrita à mão: Os modelos locais são significativamente mais fracos, especialmente com cursiva.
• Extração de dados de gráficos: Pouco confiável tanto em modelos locais quanto no GPT-5.5, mas o GPT-5.5 é mais preciso em valores numéricos exatos.
• Custo: GPT-5.5 Vision a $0,01–0,03 por imagem vs $0 localmente. 10.000 imagens/mês = $100–300 economizados com modelos locais.
• Privacidade: Os modelos locais processam imagens no dispositivo — nenhum dado sai da máquina.
• Velocidade: Os modelos locais a 10–20 tok/s vs GPT-5.5 a 30–80 tok/s, mas o local não tem latência de rede para processamento em lote.

Análise detalhada do LLaVA

• Arquitetura: Encoder visual CLIP ViT-L/14 + decodificador de texto Llama-2 ou Mistral, conectados por uma camada de projeção linear simples.
• LLaVA 1.5 vs 1.6: A versão 1.6 (lançada no início de 2024) adicionou suporte para entrada em alta resolução via patches dinâmicos, melhorando significativamente a precisão de OCR e a leitura de gráficos.
• Forças: Amplo conhecimento geral, bem documentado, comunidade ampla, extensa integração com Ollama.
• Fraquezas: OCR mais fraco do que MiniCPM-V 4.5, análise de UI mais fraca do que InternVL 2.5, superado em geral por Llama 3.2 Vision 11B em benchmarks de qualidade.
• Por que ainda é recomendado: LLaVA 1.6 tem a comunidade mais grande, a maior quantidade de tutoriais e os mais exemplos de prompts de todos os VLMs locais.

Qwen3-VL — Melhor OCR multilíngue e desempenho em documentos

• Arquitetura: Suporte de resolução dinâmica até 4096×4096 — significativamente maior do que LLaVA 1.6 (672×672) ou Llama 3.2 Vision (1120×1120).
• OCR multilíngue: O melhor da categoria para chinês, japonês, coreano e inglês.
• 7B vs 72B: O 7B cabe em ~6 GB de VRAM (Q4) e é competitivo com Llama 3.2 Vision 11B na maioria das tarefas com documentos. O 72B usa ~48 GB e lidera a maioria dos benchmarks de código aberto.
• Instalação no Ollama: ollama pull qwen3-vl:7b — disponível diretamente na biblioteca de modelos do Ollama.
• Suporte multi-imagem: Aceita até 8 imagens por solicitação — a maior capacidade multi-imagem de todos os modelos desta comparação.
• Página do modelo: Qwen3-VL 8B no Hugging Face

Como escolher seu modelo de visão

• Menos de 4 GB de VRAM: Moondream 2 (1.9B) — única opção viável a 2 GB. Além do Moondream 2, PaliGemma 2 (3B) e SmolVLM (2.2B) são alternativas viáveis.
• 6 GB de VRAM: MiniCPM-V 4.5 para OCR de documentos e processamento de faturas. LLaVA 1.6 7B para Q&A geral sobre fotos onde o suporte comunitário importa. Qwen3-VL 8B para OCR multilíngue.
• 8–16 GB de VRAM: Llama 3.2 Vision 11B é a recomendação clara — melhor qualidade geral nesta categoria de VRAM.
• 16+ GB de VRAM: LLaVA 1.6 13B adiciona mais capacidade para a compreensão de cenas complexas. InternVL 2.5 8B se seu caso de uso principal são capturas de UI ou código.
• 64+ GB de memória unificada (Apple M-Max/Ultra, multi-GPU): Llama 3.2 Vision 90B para a melhor qualidade de VLM local disponível. Qwen3-VL 72B é uma alternativa com as melhores pontuações em benchmarks de código aberto.
• Sempre verifique os números: Independentemente do modelo, contraste qualquer valor numérico extraído de gráficos ou tabelas com os dados originais.

Perguntas frequentes

Fontes

• Página do projeto LLaVA — Fichas de modelo LLaVA 1.5 e 1.6, detalhes de arquitetura e descrição do dataset de treinamento.
• Llama 3.2 Vision no Hugging Face — Lançamento oficial do modelo pela Meta, ficha de modelo e cifras de benchmark.
• MiniCPM-V 4.5 no Hugging Face — Ficha de modelo da OpenBMB, benchmarks de OCR e instruções de fine-tuning.
• Moondream no GitHub — Descrição de arquitetura, scripts de inferência e download do modelo.
• InternVL 2.5 no Hugging Face — Ficha de modelo da OpenGVLab, pontuações de benchmark em documentos e tarefas de UI.
• Documentação do Ollama — Suporte de modelos de visão, referência de API e biblioteca de modelos.
• Qwen3-VL no Hugging Face — Ficha de modelo Qwen3-VL da Alibaba, detalhes de arquitetura e benchmarks de OCR multilíngue.
• PaliGemma 2 no Hugging Face — Ficha de modelo PaliGemma 2 3B do Google.
• SmolVLM no Hugging Face — Ficha de modelo SmolVLM da HuggingFace e instruções de inferência.

Leitura relacionada

• Pipeline de IA multimodal local 2026 — Combine modelos de visão com STT e TTS em um stack multimodal local completo.
• Reconhecimento de voz local 2026: Whisper.cpp vs faster-whisper — Adicione entrada de voz para complementar a saída de visão.
• TTS local e clonagem de voz 2026 — Adicione saída de voz para ler em voz alta as respostas do VLM.
• Como instalar Ollama — Pré-requisito: configuração e instalação do Ollama.
• Guia de hardware para LLMs locais 2026 — Requisitos de VRAM e RAM para a inferência de modelos de visão.