Open WebUI: Executando Sua Própria Interface de IA Localmente e na Nuvem

Todo desenvolvedor que conheço tem pelo menos três abas de chat de IA abertas a qualquer momento. ChatGPT para uma coisa, Claude para outra, talvez uma janela do Gemini para tarefas multimodais. Cada um tem seu próprio histórico de conversas, seu próprio contexto, sua própria cobrança. Alternar entre eles é fricção que você para de notar até ela desaparecer.

O Open WebUI elimina essa fricção. É uma interface auto-hospedada que se conecta a múltiplos backends de IA — modelos locais via Ollama, APIs na nuvem como OpenAI e Anthropic, ou qualquer endpoint compatível com OpenAI. Uma interface, um histórico de conversas, um lugar para gerenciar tudo. E como você hospeda por conta própria, seus dados nunca saem da sua infraestrutura a menos que você explicitamente os envie para uma API na nuvem.

O Que É o Open WebUI

O Open WebUI (anteriormente Ollama WebUI) é uma interface web open-source e auto-hospedada para interagir com large language models. Começou como frontend para o Ollama — a ferramenta que executa LLMs localmente — mas evoluiu para uma plataforma de IA completa que suporta:

• Múltiplos backends de modelo (Ollama, OpenAI, Anthropic, qualquer API compatível com OpenAI)
• Histórico de conversas com busca e organização
• RAG (Retrieval-Augmented Generation) com upload de documentos
• Presets de modelo customizados e system prompts
• Gerenciamento de usuários e controles de acesso por equipe
• Function calling e uso de ferramentas
• Integração com geração de imagens
• Entrada e saída de voz

Não é um projeto de brinquedo. A interface é polida, o conjunto de funcionalidades é abrangente e a comunidade é ativa. No momento da escrita, o repositório no GitHub tem mais de 75.000 estrelas e uma cadência de releases de aproximadamente duas semanas.

A proposta de valor real é o controle. Você decide onde ele roda, a quais modelos se conecta, quem tem acesso e para onde os dados vão. Para desenvolvedores trabalhando com código sensível, dados proprietários de negócios ou indústrias regulamentadas, isso importa mais do que qualquer comparação de funcionalidades.

Configuração Local com Docker

A maneira mais rápida de colocar o Open WebUI funcionando localmente é com Docker. Um comando, sem dependências para instalar, sem arquivos de configuração para escrever:

docker run -d \
  -p 3000:8080 \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

É isso. Abra http://localhost:3000 no seu navegador, crie uma conta de admin, e você tem uma interface de IA funcionando. A flag -v open-webui:/app/backend/data cria um volume Docker para armazenamento persistente — suas conversas, configurações e documentos enviados sobrevivem a reinicializações do container.

Conectando ao Ollama

Para usar modelos locais, você precisa do Ollama rodando na sua máquina. Instale de ollama.com, depois baixe um modelo:

ollama pull llama3.1
ollama pull codellama
ollama pull mistral

Se o Open WebUI e o Ollama estão rodando na mesma máquina, o Open WebUI detecta automaticamente o Ollama em http://host.docker.internal:11434 (no macOS e Windows) ou http://localhost:11434 (no Linux com --network host).

Para Linux, o comando Docker precisa do modo network host para alcançar o Ollama:

docker run -d \
  -p 3000:8080 \
  --network host \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

Uma vez conectado, todo modelo que você baixou no Ollama aparece no dropdown de modelos no Open WebUI. Você pode alternar entre eles no meio da conversa, comparar saídas e definir system prompts por modelo.

Conectando a APIs na Nuvem

O Open WebUI também se conecta a provedores de modelos na nuvem. Nas configurações de admin em "Connections", adicione suas chaves de API:

• OpenAI: Adicione sua chave de API e todos os modelos GPT ficam disponíveis
• Anthropic: Adicione sua chave de API para modelos Claude (via proxy compatível com OpenAI ou integração direta dependendo da versão)
• Endpoints customizados: Qualquer serviço que exponha uma API compatível com OpenAI — Azure OpenAI, Together AI, Groq, instâncias locais de vLLM

É aqui que o Open WebUI se torna genuinamente útil como ferramenta diária. Você tem uma interface para modelos Llama locais (gratuitos, privados, bons para experimentação) e modelos na nuvem (mais capazes, cobrança por uso). O custo de troca de contexto cai para zero — você apenas muda o modelo no dropdown.

Docker Compose para Stack Completo

Para uma configuração local mais robusta, use Docker Compose para executar Open WebUI e Ollama juntos:

# docker-compose.yml
version: "3.8"

services:
  ollama:
    image: ollama/ollama
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    volumes:
      - open-webui-data:/app/backend/data
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    depends_on:
      - ollama

volumes:
  ollama-data:
  open-webui-data:

docker compose up -d

A seção de reserva de GPU é opcional — remova se estiver rodando apenas em CPU. Em Macs Apple Silicon, o Ollama usa o framework GPU Metal automaticamente sem passthrough de GPU pelo Docker (execute o Ollama nativamente no macOS para melhor performance).

Opções de Deploy na Nuvem

Executar o Open WebUI localmente é ótimo para uso individual. Mas quando você quer que sua equipe acesse, ou quando quer usá-lo de qualquer dispositivo, você precisa de um deploy na nuvem.

Deploy em VPS (Hetzner, DigitalOcean, etc.)

O caminho mais simples para a nuvem é um VPS com Docker instalado. Um servidor de US$ 20/mês da Hetzner ou DigitalOcean é suficiente para a interface do Open WebUI em si. Se você quiser rodar modelos no servidor também, vai precisar de uma instância com GPU (US$ 50-150/mês dependendo da GPU).

# On your VPS
apt update && apt install docker.io docker-compose-plugin -y

# Create docker-compose.yml (same as above, minus GPU reservation)
docker compose up -d

# Set up a reverse proxy with SSL
apt install nginx certbot python3-certbot-nginx -y

Configuração de reverse proxy Nginx:

server {
    server_name ai.yourdomain.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Depois certbot --nginx -d ai.yourdomain.com para SSL gratuito do Let's Encrypt. Agora você tem uma interface de IA privada, protegida por SSL e acessível de qualquer lugar.

Deploy Railway / Fly.io

Para um deploy gerenciado sem administração de servidor:

# Using Railway
railway login
railway init
railway up

Ou com Fly.io:

fly launch --image ghcr.io/open-webui/open-webui:main
fly secrets set OLLAMA_BASE_URL=http://your-ollama-server:11434
fly deploy

Essas plataformas lidam com SSL, escalabilidade e reinicializações automaticamente. O trade-off é menos controle sobre a infraestrutura e custo maior em escala comparado a um VPS.

Decisão de Arquitetura: Onde Executar os Modelos

A decisão arquitetural chave para deploys na nuvem é se você vai rodar modelos no mesmo servidor que o Open WebUI ou se conectar a provedores de API externos.

Mesmo servidor: Menor latência, sem custos de API por token, privacidade total dos dados. Mas você precisa de um servidor equipado com GPU (US$ 100-300/mês para uma instância de GPU decente), e a seleção de modelos é limitada pelo seu hardware.

Apenas APIs externas: Sem necessidade de GPU, acesso aos melhores modelos de todos os provedores, pague por token. O servidor do Open WebUI é leve e barato de hospedar. Mas toda conversa passa por uma API de terceiros, e os custos escalam com o uso.

Híbrido: Execute um modelo local para tarefas rotineiras e trabalho sensível à privacidade, conecte a APIs na nuvem para tarefas que requerem modelos mais capazes. É isso que eu uso — Llama 3.1 para perguntas rápidas e completação de código onde privacidade importa, Claude ou GPT-4o para tarefas de raciocínio complexo e geração.

Comparando com Interfaces Comerciais

ChatGPT Plus (US$ 20/mês)

O ChatGPT te dá GPT-4o, integração com DALL-E, navegação, code interpreter e GPTs customizados. A interface é polida e o app mobile é excelente.

Onde o Open WebUI ganha: flexibilidade de modelos (você não está preso à OpenAI), privacidade de dados (conversas ficam no seu servidor), customização (system prompts customizados, pipelines RAG, function calling). Sem limites de uso em modelos locais.

Onde o ChatGPT ganha: integrações nativas de ferramentas, sandbox de code interpreter, experiência mobile, zero configuração. O ecossistema de plugins e GPT Store não tem equivalente no Open WebUI.

Veredicto: O ChatGPT Plus é difícil de superar para usuários não técnicos que querem uma experiência pronta para usar. O Open WebUI é melhor para desenvolvedores que querem controle e flexibilidade.

Claude Pro (US$ 20/mês)

O Claude Pro te dá modelos Claude Sonnet e Opus com janelas de contexto estendidas, criação de artefatos e projetos com contexto persistente. O seguimento de instruções e tratamento de documentos longos do Claude são os melhores da categoria.

Onde o Open WebUI ganha: você ainda pode usar modelos Claude através da API enquanto também tem acesso a todos os outros modelos. Você é dono do seu histórico de conversas. Você pode adicionar RAG e ferramentas customizadas.

Onde o Claude ganha: o recurso de Projects com contexto persistente, o sistema de artefatos para código e documentos, a exibição nativa de thinking/reasoning. Esses são profundamente integrados na interface do Claude e não têm equivalente no Open WebUI.

Veredicto: Se o Claude é seu modelo principal, a interface nativa é difícil de abandonar. O Open WebUI é melhor como interface unificada quando você usa múltiplos provedores.

Para Equipes

O caso mais convincente para o Open WebUI é o uso em equipe. Interfaces comerciais de IA oferecem planos de equipe, mas tipicamente cobram por assento (US$ 25-30/usuário/mês), conversas são armazenadas na infraestrutura do provedor, e você não pode customizar a experiência.

O Open WebUI com acesso para equipe te dá: um custo de hospedagem independente da quantidade de usuários, conversas armazenadas na sua infraestrutura, presets de modelo customizados por equipe ou projeto, coleções de documentos RAG compartilhadas e controles de admin sobre quais modelos e funcionalidades estão disponíveis.

Para uma equipe de 10 desenvolvedores, assinaturas comerciais de chat de IA custam US$ 200-300/mês. Uma instância auto-hospedada do Open WebUI com acesso a API na nuvem custa US$ 20-40/mês de hospedagem mais uso de API pago por demanda. A economia fica ainda maior conforme a equipe cresce.

Configuração de Pipeline RAG

Retrieval-Augmented Generation é uma das funcionalidades mais poderosas do Open WebUI. Faça upload de documentos, e a IA pode referenciá-los ao responder perguntas. Isso transforma o Open WebUI de um chat de propósito geral em uma base de conhecimento que entende sua documentação específica, base de código ou dados de negócios.

Upload de Documentos

O Open WebUI suporta upload direto de documentos pela interface. Arraste um PDF, arquivo markdown ou arquivo de texto para o chat, e ele é automaticamente dividido em chunks, embedado e indexado para recuperação. A IA referencia os documentos enviados ao responder perguntas.

Para ingestão de documentos em massa, use a seção de gerenciamento de documentos no painel de admin. Você pode organizar documentos em coleções e controlar quais coleções estão disponíveis em quais chats.

Configuração de Embedding

O Open WebUI usa modelos de embedding para converter documentos em vetores para busca semântica. Por padrão, ele usa um modelo de embedding local, mas você pode configurá-lo para usar a API de embedding da OpenAI para melhor qualidade:

Nas configurações de admin em "Documents", configure:

• Modelo de embedding: text-embedding-3-small (OpenAI) ou um modelo local via Ollama
• Tamanho do chunk: 1000 tokens (padrão, ajuste baseado nos seus documentos)
• Sobreposição de chunk: 100 tokens (ajuda a manter contexto entre chunks)
• Top K: 5 (número de chunks relevantes a recuperar por consulta)

Casos de Uso Práticos de RAG

Documentação da base de código: Faça upload do README do seu projeto, docs de arquitetura e documentação de API. Faça perguntas à IA sobre seu próprio projeto e receba respostas fundamentadas na sua documentação real em vez dos dados gerais de treinamento do modelo.

Notas de reunião e decisões: Faça upload de transcrições de reuniões e logs de decisões. "O que foi decidido sobre o cronograma de migração de banco de dados na reunião da semana passada?" recebe uma resposta precisa em vez de uma alucinada.

Artigos de pesquisa e especificações técnicas: Faça upload de PDFs de papers ou especificações com as quais está trabalhando. A IA pode resumir, comparar e responder perguntas sobre conteúdo que não está nos dados de treinamento dela.

A qualidade das respostas RAG depende fortemente da divisão em chunks e da qualidade do embedding. Se as respostas parecem perder informações relevantes, tente reduzir o tamanho do chunk (para que cada chunk seja mais focado) ou aumentar o Top K (para que mais chunks sejam recuperados).

Configurações Customizadas de Modelo

O Open WebUI permite criar presets de modelo — configurações salvas com system prompts customizados, configurações de temperatura e seleções de modelo. Isso é útil para criar assistentes de propósito específico sem modificar os modelos subjacentes.

Criando um Preset de Code Review

Nas configurações do Open WebUI, crie um novo preset de modelo:

• Nome: Code Reviewer
• Modelo base: Claude Sonnet (ou seu modelo preferido)
• System prompt: "You are a senior code reviewer. Analyze the provided code for bugs, security issues, performance problems, and style violations. Be specific about line numbers and provide corrected code snippets. Prioritize issues by severity."
• Temperatura: 0.3 (menor para saída mais consistente e focada)

Criando um Preset de Assistente de Escrita

• Nome: Technical Writer
• Modelo base: GPT-4o
• System prompt: "You are a technical writing assistant. Help draft clear, concise technical documentation. Use active voice. Avoid jargon unless the audience is technical. Structure content with headers, lists, and code examples where appropriate."
• Temperatura: 0.7 (maior para saída mais criativa)

Esses presets aparecem no dropdown de modelos junto com seus modelos regulares. Você alterna para o preset "Code Reviewer" ao revisar código e para o "Technical Writer" ao escrever docs. O system prompt é aplicado automaticamente.

Vantagens de Privacidade

O argumento de privacidade para IA auto-hospedada não é teórico. Ele tem implicações concretas para diferentes casos de uso.

Código Sensível

Quando você cola código proprietário no ChatGPT ou Claude, está enviando para um servidor de terceiros. Os provedores têm políticas de tratamento de dados — OpenAI e Anthropic ambos declaram que não treinam com dados de API — mas os dados ainda saem da sua infraestrutura. Para empresas com políticas rigorosas de propriedade intelectual, indústrias regulamentadas ou contratos governamentais, isso pode ser inaceitável.

Com Open WebUI conectado ao Ollama, seu código nunca sai da sua máquina. O modelo roda localmente, a inferência acontece localmente, e o histórico de conversas é armazenado localmente. Para deploys na nuvem, os dados ficam no seu servidor.

Dados de Clientes

Se você é consultor ou agência trabalhando com dados de clientes, usar interfaces comerciais de IA cria uma questão de tratamento de dados que você precisa responder para cada cliente. O Open WebUI auto-hospedado te dá uma resposta clara: os dados ficam na sua infraestrutura, sob seu controle, sujeitos às suas políticas de segurança.

Compliance

HIPAA, SOC 2, LGPD — esses frameworks se preocupam com onde os dados são processados e armazenados. Uma interface de IA auto-hospedada na sua infraestrutura em conformidade é inerentemente mais fácil de incluir no seu escopo de compliance do que uma ferramenta SaaS de terceiros.

Isso não significa que local é sempre melhor. APIs de IA na nuvem têm suas próprias certificações de compliance, e para muitos casos de uso, a postura de compliance das ofertas enterprise da OpenAI ou Anthropic é mais forte do que o que você pode construir sozinho. O ponto é que a auto-hospedagem te dá a opção quando você precisa.

Considerações de Performance

Performance de Modelo Local

Executar modelos localmente significa que seu hardware determina a experiência. Aqui estão benchmarks aproximados para o Llama 3.1 8B:

• Apple M1 Pro (16GB RAM): ~15 tokens/segundo — utilizável para interações curtas
• Apple M2 Ultra (64GB RAM): ~40 tokens/segundo — confortável para conversas estendidas
• NVIDIA RTX 4090: ~80 tokens/segundo — respostas quase instantâneas
• Apenas CPU (sem GPU): ~2-5 tokens/segundo — dolorosamente lento, não recomendado

Para modelos maiores como o Llama 3.1 70B, você precisa de pelo menos 48GB de RAM (M2 Max ou superior no Mac, ou uma GPU server-grade). A melhoria de qualidade é significativa, mas o requisito de hardware é alto.

Comparação de Latência

Para conexões de API na nuvem, o Open WebUI adiciona overhead mínimo — tipicamente 10-30ms em cima da latência nativa da API. O gargalo é sempre a inferência do modelo, não a interface.

Para modelos locais, a latência é função do tamanho do modelo e hardware. A latência do primeiro token (o tempo antes do modelo começar a gerar) varia de 100ms para modelos pequenos em hardware rápido a vários segundos para modelos grandes em hardware limitado. A exibição em streaming esconde a maior parte disso do usuário.

Quando Auto-Hospedar vs. Usar Comercial

Auto-hospede quando:

• Você trabalha com dados sensíveis ou proprietários
• Quer usar modelos locais por privacidade ou custo
• Precisa de uma interface de IA para equipe sem licenciamento por assento
• Quer customizar o pipeline RAG ou adicionar ferramentas customizadas
• Usa múltiplos provedores de modelos e quer uma interface unificada

Use interfaces comerciais quando:

• Precisa da integração mais estreita possível com um modelo específico (Claude Projects, ChatGPT plugins)
• Valoriza apps mobile e sincronização entre dispositivos
• Não quer gerenciar infraestrutura
• Seu caso de uso não envolve dados sensíveis
• Precisa da experiência mais polida e com as funcionalidades mais recentes

Para a maioria dos desenvolvedores, a resposta é ambos. Eu uso a interface nativa do Claude para trabalho profundo que se beneficia de Claude Projects, ChatGPT para tarefas que precisam de code interpreter, e Open WebUI para todo o resto — especialmente quando quero usar modelos locais, comparar saídas entre provedores ou trabalhar com documentos que não quero enviar para uma API na nuvem.

O Open WebUI não é sobre substituir interfaces comerciais. É sobre ter a opção de controlar sua infraestrutura de IA quando esse controle importa. A configuração leva 30 minutos. Os benefícios de privacidade e flexibilidade são permanentes.