Pipeline multimodal de IA local 2026: combine voz, visão e texto offline

Dados rápidos

• VRAM total para o stack completo: ~15 GB (Whisper 3 GB + LLaVA 7B 6 GB + Llama 3.3 8B 6 GB). O Piper roda na CPU.
• Stack simplificado (Llama 3.2 Vision 11B): ~8 GB VRAM — gerencia visão e raciocínio textual em um único modelo.
• Latência de voz (Whisper small, RTX 4070): STT ~200–500 ms. Primeiro token do LLM 500–1500 ms. Piper TTS 100 ms.
• Latência de processamento de imagem (LLaVA 7B, RTX 4070): ~2–5 segundos por imagem dependendo da resolução e do prompt.
• Sem vídeo em tempo real: Os VLMs processam frames individuais, não fluxos de vídeo contínuos. Para vídeo, extraia frames a 1 FPS e processe cada um.
• Mesma instância do Ollama para VLM + LLM: O Ollama pode servir o Llama 3.2 Vision como modelo de visão e modelo de texto ao mesmo tempo, economizando VRAM.
• Todos os componentes com licença MIT ou Apache 2.0 (whisper.cpp MIT, LLaVA MIT, Llama 3.3 8B Llama 3 Community License, Piper MIT).

O que é um pipeline multimodal de IA?

• Abordagem na nuvem (GPT-5.5): Um modelo gigante treinado em todas as modalidades simultaneamente. O raciocínio cross-modal é aprendido durante o treinamento — o modelo pode raciocinar nativamente sobre a relação entre o conteúdo da imagem e as consultas de voz.
• Abordagem local (este guia): Modelos especializados independentes para cada modalidade, conectados por um orquestrador. Mais modular e econômico de rodar, mas produz "costuras" — a saída do modelo de visão é serializada para texto antes de ser passada ao LLM.
• Por que construir localmente: Privacidade (imagens médicas, documentos proprietários, capturas de tela confidenciais), custo (zero taxas por consulta), capacidade offline (não requer internet após baixar o modelo), personalização (troque qualquer componente).
• Vantagem modular: Você pode atualizar qualquer componente de forma independente. Quando aparecer um melhor modelo STT local, substitua apenas a camada STT. Quando aparecer um melhor VLM, troque apenas o modelo de visão — o resto do pipeline não muda.

Custo: pipeline local vs APIs na nuvem (mensal)

Visão geral da arquitetura

• Tipos de entrada: Áudio de microfone (voz), imagem de câmera ou arquivo (visão), texto de teclado (texto).
• Lógica do router: Detecta o tipo de entrada no limite. Áudio → modelo STT. Imagem → VLM. Texto → LLM diretamente. Se chegarem áudio e imagem juntos, processar em paralelo e combinar.
• Registro de modelos: Cada tipo de entrada é mapeado para uma função handler que chama o modelo apropriado e retorna uma descrição/transcrição de texto.
• Orquestrador: Coleta todas as saídas dos modelos, combina-as em um único prompt para o LLM de texto, obtém a resposta do LLM e a direciona para o TTS para a saída de voz ou para a tela como texto.
• Tipos de saída: Resposta de voz (Piper TTS), texto na tela ou dados estruturados (JSON) para integração com outros sistemas.
• Processamento paralelo: STT e VLM podem processar simultaneamente — uma consulta de áudio sobre uma imagem pode ter ambos processados em paralelo, reduzindo a latência total em 40–60% frente ao processamento sequencial.

O stack de componentes

Níveis de hardware para multimodal

Caso de uso 1: Analisador de documentos controlado por voz

• Exemplo: Fotografe uma fatura e diga "Qual é o valor total a pagar e o prazo de pagamento?"
• Pipeline: O Whisper transcreve a pergunta → imagem enviada ao LLaVA ou Llama 3.2 Vision → o VLM extrai texto e estrutura da fatura → o LLM combina pergunta + saída do VLM → o Piper lê a resposta em voz alta.
• Prompt: "Aqui está uma imagem: [descrição do VLM]. O usuário pergunta: [transcrição]. Responda a pergunta com base no conteúdo da imagem."
• Melhor VLM: MiniCPM-V 2.6 ou Llama 3.2 Vision 11B para precisão de OCR em faturas e documentos.
• Valor de privacidade: Histórico médico, documentos jurídicos, demonstrações financeiras — processados completamente localmente, sem que nenhum dado saia da máquina.

Caso de uso 2: Assistente de Q&A visual

• Aplicações: Inventário de almoxarifado (fotografe uma prateleira, pergunte "Quantas unidades de SKU-4429 há?"), inspeção de campo (fotografe danos em máquinas, pergunte "É seguro operar isto?"), acessibilidade (descreva objetos para usuários com deficiência visual).
• Implementação: Capture um frame de câmera (OpenCV cv2.VideoCapture(0).read()), salve como JPEG, passe-o ao VLM junto com a transcrição do Whisper.
• Melhores modelos: LLaVA 1.6 7B ou Llama 3.2 Vision 11B para compreensão geral de objetos e cenas.
• Latência: 3–6 segundos para captura de imagem + processamento do VLM + LLM + TTS na RTX 4070. Reduza com um VLM menor (Moondream 2 para identificação simples de objetos).

Caso de uso 3: Transcrição de reunião + análise de slides

• STT: Rode o faster-whisper em modo de streaming durante a reunião. Acumule segmentos em um buffer de transcrição.
• Visão: Cada vez que aparecer um novo slide (detectar via diff de captura de tela), capture uma imagem e passe-a ao LLaVA para descrição.
• Combinação: Ao final da reunião (ou sob demanda), passe transcrição + descrições de slides ao Llama 3.3 8B: "Resuma esta reunião e liste os itens de ação. Aqui está a transcrição: [...]. Aqui estão os conteúdos dos slides: [...]."
• Saída: Resumo lido em voz alta (Piper TTS) + arquivo de texto salvo localmente.
• Valor GDPR: Todo o processamento da reunião é local. Nenhum áudio, transcrição ou slide é enviado a qualquer serviço na nuvem. Em conformidade para contextos jurídicos, médicos e corporativos.

Caso de uso 4: Ferramenta de acessibilidade local

• Leitor de tela: Capture uma captura de tela a cada 2 segundos → o LLaVA descreve o que há na tela → o Piper lê em voz alta. Adicione comandos de voz (Whisper) para controlar o que descrever em seguida.
• Navegação por voz: O Whisper transcreve comandos de voz → o LLM interpreta a intenção → executa ações de teclado/mouse via pyautogui. Não requer internet.
• Benefício de privacidade: Usuários com deficiências costumam usar ferramentas de acessibilidade em contextos sensíveis (portais médicos, contas financeiras). Uma ferramenta local garante que nenhum conteúdo de tela seja transmitido a terceiros.
• Uso com conectividade limitada: Funciona em hospitais, prédios governamentais e áreas com internet restrita — importante para implantações institucionais de acessibilidade.
• Escolha de modelo para acessibilidade: Moondream 2 para descrições de tela rápidas (2 GB VRAM, ~1 seg por frame). LLaVA 7B para descrições mais ricas (6 GB VRAM, ~3 seg por frame).

Caso de uso 5: Análise local de câmera de segurança

• Captura de frames: Use o OpenCV para capturar um frame a cada 5–10 segundos de uma câmera IP via RTSP (cv2.VideoCapture("rtsp://camera-ip:554/stream")). Para câmeras USB, use o índice de dispositivo 0.
• Detecção de movimento: Calcule a diferença entre frames consecutivos com cv2.absdiff(). Pule frames abaixo do limiar de movimento — isso evita chamadas VLM desnecessárias em cenas estáticas e vazias.
• Análise VLM: Quando o movimento for detectado, envie o frame ao VLM: "Descreva o que está acontecendo. Há uma pessoa? O que ela está fazendo?"
• Saída de alerta: Se a resposta indicar uma pessoa ou anomalia, acione uma notificação de desktop local e um anúncio do Piper TTS ("Pessoa detectada na porta principal"). Não requer serviço de notificação na nuvem.
• Vantagem de privacidade: Ring e Nest enviam vídeo para os servidores da AWS e do Google respectivamente. Esta configuração mantém toda a gravação no seu hardware — sem assinatura, sem armazenamento de vídeo de terceiros, sem compartilhamento de dados com serviços externos.
• Melhor VLM para velocidade: Moondream 2 para processamento rápido de frames (~1 segundo por frame, ~2 GB VRAM) ou LLaVA 7B para descrições de cena mais ricas (~3 segundos por frame, ~6 GB VRAM).
• Nota de hardware: Um Mac Mini M5 dedicado (~$600) rodando este stack 24/7 consome ~15–25W em repouso — menos eletricidade anualmente do que uma assinatura do Ring Doorbell Pro.

Construindo o orquestrador 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())

Otimização do desempenho

• STT + VLM paralelos: Use asyncio.gather(transcribe_audio(), describe_image()) para rodar ambos simultaneamente. Economiza 0,3–2 segundos dependendo do tamanho do modelo STT.
• Mantenha os modelos quentes: O Ollama mantém os modelos na VRAM automaticamente entre solicitações. O whisper.cpp em modo stream permanece carregado. Nunca recarregue entre consultas.
• Transmita LLM → TTS: Detecte os limites de frase na saída do LLM em streaming (., !, ?). Passe cada frase concluída ao Piper enquanto o LLM continua gerando.
• Gestão de VRAM: Se a VRAM total estiver apertada, descarregue o VLM após o processamento de imagem (endpoint HTTP de exclusão do Ollama) antes de carregar o LLM de texto. Adiciona ~2–3 segundos, mas permite que uma GPU de 8 GB gerencie o stack completo.
• Use o Llama 3.2 Vision como VLM + LLM combinado: Elimina completamente o overhead da troca de modelo — um modelo gerencia tanto a descrição visual quanto o raciocínio textual. Contrapartida: raciocínio de texto puro ligeiramente mais fraco em comparação com o Llama 3.3 8B dedicado.
• Meta de primeiro áudio do TTS: O Piper gera o primeiro áudio em 50–100 ms após receber texto. Transmita uma frase por vez para uma latência TTS percebida de menos de um segundo.

Limitações e avaliação honesta

• Costuras de modalidade: A saída de visão é serializada para texto antes de ser passada ao LLM de texto. O LLM não pode raciocinar diretamente sobre as características da imagem — ele raciocina sobre uma descrição textual da imagem. Isso perde informação em tarefas que exigem raciocínio visual sutil.
• Sem vídeo em tempo real: Os VLMs locais processam frames individuais, não vídeo contínuo. Para vídeo, extraia frames a 0,5–2 FPS e processe sequencialmente. Isso significa que você não pode perguntar "o que acabou de acontecer nos últimos 5 segundos deste vídeo".
• Lacuna de qualidade do VLM: Os modelos de visão locais (LLaVA 7B, Llama 3.2 Vision 11B) ficam atrás do GPT-5.5 Vision em infográficos complexos, texto manuscrito, cenas ambíguas e tarefas que exigem amplo conhecimento do mundo junto à compreensão visual.
• Pressão de VRAM: Rodar três modelos simultaneamente em uma única GPU exige uma gestão cuidadosa da VRAM. Em GPUs de 12 GB você está no limite — os tamanhos dos modelos devem ser escolhidos cuidadosamente para evitar erros OOM (sem memória).
• Latência vs. nuvem: Uma chamada multimodal na nuvem (GPT-5.5) leva 1–3 segundos para áudio + imagem + texto. Um pipeline local leva 3–8 segundos em hardware comparável — mais lento, mas com total privacidade e custo zero por consulta.
• Consistência: Os modelos locais produzem qualidade de saída mais variável do que os modelos na nuvem com extenso RLHF. Espere alucinações ocasionais tanto em descrições de visão quanto em respostas do LLM.

Perguntas frequentes

Fontes

• whisper.cpp no GitHub — Fonte e documentação do componente STT.
• faster-whisper no GitHub — Alternativa STT em Python com VAD integrado para streaming.
• Página do projeto LLaVA — Arquitetura do modelo de visão e fichas de modelo.
• Ficha do modelo Llama 3.2 Vision — Modelo multimodal da Meta que suporta raciocínio com imagem + texto.
• Documentação do Ollama — API de modelos de visão, formato de solicitação multimodal.
• Piper TTS no GitHub — Componente de saída TTS, biblioteca de packs de voz.
• Coqui TTS no GitHub — TTS alternativo com suporte a clonagem de voz.

Leitura relacionada

• Reconhecimento de voz local 2026: Whisper.cpp vs faster-whisper — Análise detalhada do componente STT.
• Modelos de visão locais 2026: LLaVA, Llama 3.2 Vision e Ollama — Análise detalhada do componente de visão.
• TTS local e clonagem de voz 2026 — Análise detalhada do componente TTS.
• Como construir um assistente de voz totalmente offline em 2026 — A versão só de voz (mais simples, voz + LLM + TTS sem visão).
• Guia de hardware para LLM local 2026 — Seleção de hardware para pipelines multi-modelo.
• Quantização de LLM explicada — Como encaixar múltiplos modelos em VRAM limitada via quantização.