Tabby: instalar um recurso de autocompletar código localmente auto-hospedada

#Por que Tabby em vez de Cline

Tabby e Cline não são concorrentes: são complementares. Cline (e Aider) se destaca no chat conversacional e no modo de agente que trabalha com vários arquivos, mas nenhum dos dois faz o preenchimento automático linha por linha durante a digitação. Tabby, por sua vez, faz apenas isso — e faz muito bem. O combo vencedor em 2026: Cline para conversar e refatorar, Tabby para a sugestão em cinza que aparece à medida que você digita.

Texto em cinza inline

A sugestão aparece diretamente após o cursor, em cinza. Tab para aceitar, Esc para ignorar. Exatamente a UX do Copilot.

100 % auto-hospedado

O servidor roda na sua própria infraestrutura (Docker). Nenhum trecho de código é enviado a terceiros — ideal para NDAs e código em setores regulados.

Multi-utilisateurs

Diferentemente de uma extensão puramente local, o Tabby é um servidor: um único GPU pode atender toda uma equipe via rede.

Telemetria desativável

O Tabby envia estatísticas anônimas por padrão; uma variável de ambiente desativa tudo. O código-fonte que você digita nunca é transmitido.

#Pré-requisitos

Docker

Tabby se instala em contêiner. Docker Desktop no Windows/macOS, Docker Engine no Linux.

GPU NVIDIA (recomendado)

Com o NVIDIA Container Toolkit para acesso ao CUDA. O Tabby também roda em CPU, mas a latência inline torna-se desconfortável.

~6 GB de VRAM

Suficiente para um modelo quantizado de 1B–3B para completar texto. Mais VRAM = modelo maior ou mais desenvolvedores em paralelo.

Um editor

VS Code ou um IDE JetBrains (IntelliJ, PyCharm, WebStorm, etc.). A extensão Tabby está disponível para os dois.

#Qual modelo de autocompletação

O preenchimento automático inline tem uma restrição que o chat não tem: a latência. A sugestão deve aparecer em algumas centenas de milissegundos; caso contrário, você digita mais rápido do que ela. Por isso, priorizamos modelos Fill-In-the-Middle (FIM) compactos, na variante -base, e não os grandes modelos instruct usados no chat.

#1. Iniciar o Tabby via Docker

Iniciamos o servidor Tabby com acesso à GPU, um volume persistente para os dados e um modelo de completamento escolhido. A porta 8080 expõe a interface web e a API.

docker run -d \
  --name tabby \
  --gpus all \
  -p 8080:8080 \
  -v $HOME/.tabby:/data \
  registry.tabbyml.com/tabbyml/tabby \
  serve --model StarCoder2-3B --device cuda

1. 01
   Verificar a inicialização

   Na primeira execução, Tabby baixa o modelo (alguns minutos). Monitore os logs com docker logs -f tabby até aparecer a mensagem indicando que o servidor está ouvindo na porta 8080.
2. 02
   Abrir a interface web

   Acesse http://localhost:8080. No primeiro acesso, será solicitado que você crie uma conta de administrador (e-mail + senha). É local: essas credenciais permanecem no seu volume ~/.tabby.
3. 03
   Testar o autocompletar

   A aba « Playground » da interface permite verificar se o modelo responde antes mesmo de conectar um editor.

#2. Criar o token de acesso

Os editores se autenticam no servidor Tabby com um token. É isso que permite, em equipe, saber quem se conecta e revogar um acesso sem quebrar tudo.

1. 01
   Ir para as configurações

   Na interface web (http://localhost:8080), abra a seção contas/segurança. O token do usuário atual é exibido ali.
2. 02
   Copiar o token

   Recupere a string (geralmente prefixada com auth_). É essa que as extensões do VS Code e JetBrains pedirão.
3. 03
   Regenerar se necessário

   Em caso de vazamento ou saída de um colaborador, gere novamente o token pela interface: o antigo é imediatamente invalidado.

Endpoint : http://localhost:8080
Token    : auth_xxxxxxxxxxxxxxxxxxxxxxxx

#3. Conectar o VS Code

1. 01
   Instalar a extensão

   Extensions (Ctrl+Shift+X) → procurar “Tabby” (publicado pela TabbyML) → Install.
2. 02
   Informar o endpoint

   Na primeira execução, a extensão pede a URL do servidor. Insira http://localhost:8080 (ou o IP do servidor compartilhado na rede).
3. 03
   Colar o token

   Insira o token de acesso copiado na etapa anterior. O ícone Tabby na barra de status deve passar para verde (conectado).
4. 04
   Coder

   Digite código: a sugestão em cinza aparece após o cursor. Pressione Tab para aceitá-la, continue digitando para ignorá-la.

#4. Conectar o JetBrains

A mesma configuração funciona em toda a linha JetBrains: IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, etc. A extensão Tabby é um plugin único compatível com a plataforma.

1. 01
   Instalar o plugin

   Settings → Plugins → Marketplace → procurar “Tabby” → Install e, em seguida, reiniciar o IDE.
2. 02
   Configurar a conexão

   Settings → Tools → Tabby: preencha o endpoint (http://localhost:8080) e o token de acesso.
3. 03
   Verificar

   O indicador Tabby na barra de status confirma a conexão. As sugestões em linha aparecem como no VS Code.

#5. Apontar o Tabby para o seu Ollama

Se você já está rodando o Ollama para Cline ou Aider, não há necessidade de carregar um segundo motor de inferência: o Tabby pode usar um backend Ollama por meio de seu protocolo compatível com OpenAI. Assim, você compartilha um único servidor de modelos para a autocompletação e o chat.

# Tirez un modèle de complétion FIM dans Ollama
ollama pull qwen2.5-coder:1.5b-base
# ou
ollama pull starcoder2:3b

No Tabby, declara-se o backend HTTP em vez de um modelo local. A configuração é feita no arquivo config.toml do volume de dados (~/.tabby/config.toml), no qual o mecanismo de autocompletar é configurado para usar a API Ollama.

[model.completion.http]
kind = "ollama/completion"
model_name = "qwen2.5-coder:1.5b-base"
api_endpoint = "http://localhost:11434"
prompt_template = "<|fim_prefix|>{prefix}<|fim_suffix|>{suffix}<|fim_middle|>"

#6. Compartilhar a GPU entre vários desenvolvedores

Esta é a vantagem decisiva do Tabby em relação a uma extensão puramente local: um único servidor, uma única GPU, vários desenvolvedores. Você instala o Tabby em uma máquina com GPU (um computador dedicado, um servidor de equipe) e cada desenvolvedor configura seu editor para usar esse endereço de rede.

Expor na rede

A porta 8080 deve estar acessível a partir dos computadores dos desenvolvedores. Na rede interna, o IP local do servidor é suficiente (http://192.168.x.x:8080).

Um token por dev

Crie uma conta/token por desenvolvedor na interface. Você mantém a rastreabilidade e pode revogar cada acesso individualmente.

Dimensionar a GPU

Um modelo compacto de autocompletação (1,5B–3B) atende vários desenvolvedores em paralelo sem saturar. Como as sugestões de autocompletação são curtas, as requisições raramente se sobrepõem.

Reverse proxy + HTTPS

Para acesso fora da LAN, coloque o Tabby atrás de um proxy reverso (Caddy, Nginx) com TLS. Nunca exponha a porta 8080 diretamente na Internet sem proteção.

#Configurações de desempenho e solução de problemas

Latência muito alta

Passe para um modelo um nível menor (3B → 1.5B), verifique se --device cuda está realmente ativo (sem recorrer à CPU como alternativa) e limite o comprimento máximo das sugestões.

Sem sugestão

Verifique o ícone de status da extensão (token e endpoint corretos) e se o contêiner está rodando (docker ps). O Playground web permite identificar se o problema está no servidor ou no editor.

Sugestões fora do assunto

Quase sempre um prompt_template FIM errado ou uma variante instruct em vez de -base. Volte para um modelo base e o template FIM correto.

Indexação do repositório (RAG)

Tabby pode indexar seu código para sugestões mais contextuais. Ative a indexação na interface se a GPU tiver capacidade disponível; desative-a se a latência piorar.

Memória da GPU saturada

Se vários modelos coexistirem (Tabby + Cline via Ollama), quantize o cache KV e monitore a VRAM com nvidia-smi.

# Le conteneur tourne-t-il ?
docker ps | grep tabby
# Logs en direct
docker logs -f tabby
# Le GPU est-il bien vu ?
docker exec tabby nvidia-smi

#Perguntas frequentes

#Conclusão

Você agora tem um servidor de autocompletar código 100% auto-hospedado: Tabby em Docker na sua GPU, um modelo StarCoder ou Qwen-Coder em Fill-In-the-Middle, um token de acesso e sugestões em cinza no estilo Copilot tanto no VS Code quanto no JetBrains — com o bônus de poder atender uma equipe inteira a partir de uma única GPU. Com o Cline para chat e funções de agente, a solução fica completa e seu código nunca sai da sua infraestrutura. Se você quiser evitar horas de ajustes (templates FIM, configurações do Ollama, modelos por função), o guia pago «Copilote de código local» fornece um pacote pronto para uso com Ollama + Cline + Aider, que você pode complementar com Tabby para autocompletar inline.