Tabby: instalar un autocompletado de código en local autoalojada

#¿Por qué Tabby en lugar de Cline?

Tabby y Cline no son competidores: son complementarios. Cline (y Aider) destaca en el chat conversacional y el modo agente multiarchivo, pero ninguno de los dos ofrece autocompletado línea por línea mientras escribes. Tabby solo hace eso, y lo hace muy bien. El combo ganador en 2026: Cline para conversar y refactorizar, Tabby para la sugerencia en gris que aparece mientras escribes.

Texto en gris en línea

La sugerencia se muestra directamente después del cursor, en gris. Presiona Tab para aceptar y Escape para ignorar. Exactamente la experiencia de usuario de Copilot.

100 % autoalojado

El servidor corre en tu equipo (Docker). Ningún fragmento de código se envía a un tercero — ideal para NDA y código en sectores regulados.

Multi-utilisateurs

A diferencia de una extensión puramente local, Tabby es un servidor: una sola GPU puede dar servicio a todo un equipo a través de la red.

Telemetría desactivable

Tabby envía estadísticas anónimas por defecto; una variable de entorno desactiva por completo ese envío. El código fuente que escribes nunca se transmite.

#Prerrequisitos

Docker

Tabby se despliega en contenedor. Docker Desktop en Windows/macOS, Docker Engine en Linux.

GPU NVIDIA (recomendado)

Con NVIDIA Container Toolkit para acceder a CUDA. Tabby también funciona en CPU, pero la latencia del autocompletado en línea resulta incómoda.

~6 GB de VRAM

Suficiente para un modelo de completado de 1B–3B cuantizado. Más VRAM = un modelo más grande o más desarrolladores en paralelo.

Un editor

VS Code o un IDE JetBrains (IntelliJ, PyCharm, WebStorm, etc.). La extensión Tabby existe para los dos.

#¿Qué modelo de autocompletado?

El autocompletado en línea tiene una limitación que el chat no tiene: la latencia. La sugerencia debe aparecer en unos pocos cientos de milisegundos; de lo contrario, escribirás más rápido de lo que tarda en aparecer. Por eso se prefieren modelos Fill-In-the-Middle (FIM) compactos, en su variante -base, y no los grandes modelos instruct del chat.

#1. Iniciar Tabby en Docker

Se inicia el servidor Tabby con acceso a la GPU, un volumen persistente para los datos y un modelo de autocompletado elegido. El puerto 8080 expone la interfaz web y la 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 el arranque

   En la primera ejecución, Tabby descarga el modelo (tarda unos minutos). Sigue los logs con docker logs -f tabby hasta que aparezca el mensaje que indica que el servidor escucha en el puerto 8080.
2. 02
   Abrir la interfaz web

   Visita http://localhost:8080. La primera vez que accedas, se te pedirá que crees una cuenta de administrador (correo electrónico + contraseña). Todo es local: estas credenciales permanecen en tu volumen ~/.tabby.
3. 03
   Probar el autocompletado

   La pestaña « Playground » de la interfaz permite comprobar que el modelo responde antes de conectar un editor.

#2. Crear el token de acceso

Los editores se autentican ante el servidor Tabby mediante un token. Esto permite, cuando se trabaja en equipo, saber quién se conecta y revocar un acceso sin romperlo todo.

1. 01
   Ir a los ajustes

   En la interfaz web (http://localhost:8080), abre la sección cuentas/seguridad. Allí se muestra el token del usuario actual.
2. 02
   Copiar el token

   Recupera la cadena de caracteres (a menudo prefijada con auth_). Es esta la que las extensiones de VS Code y JetBrains pedirán.
3. 03
   Regenerar si es necesario

   En caso de fugas o salida de un colaborador, regenera el token desde la interfaz: el anterior se invalida inmediatamente.

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

#3. Conectar VS Code

1. 01
   Instalar la extensión

   Extensions (Ctrl+Shift+X) → buscar «Tabby» (editor TabbyML) → Install.
2. 02
   Especificar el endpoint

   La primera vez que se inicia, la extensión pide la URL del servidor. Introduce http://localhost:8080 (o la IP del servidor compartido en la red).
3. 03
   Pegar el token

   Introduce el token de acceso copiado en la etapa anterior. El icono Tabby en la barra de estado debe pasar a verde (conectado).
4. 04
   Coder

   Escribe código: la sugerencia en gris aparece después del cursor. Presiona Tab para aceptarla, continúa escribiendo para ignorarla.

#4. Conectar JetBrains

La misma configuración funciona en toda la gama de JetBrains: IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, etc. La extensión Tabby es un plugin único compatible con la plataforma.

1. 01
   Instalar el plugin

   Settings → Plugins → Marketplace → buscar «Tabby» → Install, luego reiniciar el IDE.
2. 02
   Configurar la conexión

   Settings → Tools → Tabby: introduce el endpoint (http://localhost:8080) y el token de acceso.
3. 03
   Verificar

   El indicador Tabby en la barra de estado confirma la conexión. Las sugerencias en línea aparecen como en VS Code.

#5. Configurar Tabby para que apunte a tu Ollama

Si ya estás ejecutando Ollama para Cline o Aider, no es necesario cargar un segundo motor de inferencia: Tabby puede utilizar un backend de Ollama a través de su protocolo compatible con OpenAI. Así, compartes un único servidor de modelos para el autocompletado y el chat.

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

En cuanto a Tabby, se declara el backend HTTP en lugar de un modelo local. La configuración se realiza en el archivo config.toml del volumen de datos (~/.tabby/config.toml), donde se apunta el motor de completado hacia la 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. Compartir la tarjeta gráfica entre varios desarrolladores

Esta es la ventaja decisiva de Tabby sobre una extensión puramente local: un solo servidor, una sola GPU, varios desarrolladores. Instalas Tabby en una máquina equipada con una GPU (un equipo dedicado, un servidor del equipo de desarrollo) y cada desarrollador configura su editor para conectarse a esa dirección de red.

Exponer en red

El puerto 8080 debe ser accesible desde los ordenadores de los desarrolladores. Internamente, la IP local del servidor es suficiente (http://192.168.x.x:8080).

Un token por dev

Crea una cuenta/token por desarrollador en la interfaz. Mantienes la trazabilidad y puedes revocar cada acceso de forma individual.

Dimensionar el GPU

Un modelo compacto de autocompletado (1.5B–3B) atiende a varios desarrolladores en paralelo sin saturarse. Como el autocompletado es breve, las peticiones rara vez se solapan.

Reverse proxy + HTTPS

Para acceder desde fuera de la LAN, coloca Tabby detrás de un proxy inverso (Caddy, Nginx) con TLS. Nunca expongas el puerto 8080 directamente a Internet sin protección.

#Ajustes de rendimiento y solución de problemas

Latencia demasiado alta

Baja un nivel de modelo (3B → 1.5B), verifica que --device cuda esté activo (no un fallback a CPU) y limita la longitud máxima de las sugerencias.

Sin sugerencias

Revisa el icono de estado de la extensión (token y endpoint correctos) y comprueba que el contenedor esté funcionando (docker ps). El Playground web permite determinar si el problema está en el servidor o en el editor.

Sugerencias fuera de tema

Casi siempre se debe a un prompt_template FIM incorrecto o a una variante instruct en lugar de -base. Vuelve a usar un modelo base y la plantilla FIM correcta.

Indexación del repositorio (RAG)

Tabby puede indexar tu código para ofrecer sugerencias más contextuales. Actívalo en la interfaz si la GPU tiene margen; desactívalo si la latencia empeora.

Memoria GPU saturada

Si varios modelos coexisten (Tabby + Cline a través de Ollama), cuantiza la caché KV y supervisa la VRAM con 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

#Preguntas frecuentes

#Conclusión

Ahora tienes un servidor de autocompletado de código 100 % autoalojado: Tabby en Docker en tu GPU, un modelo StarCoder o Qwen-Coder en Fill-In-the-Middle, un token de acceso y las sugerencias en gris al estilo de Copilot tanto en VS Code como en JetBrains, con la posibilidad adicional de dar servicio a todo un equipo desde una sola GPU. Combinado con Cline para el chat y el agente, el conjunto está completo y tu código nunca sale de tu infraestructura. Si quieres evitar horas de ajustes (plantillas FIM, configuraciones de Ollama, modelos por rol), la guía de pago «Copiloto de código local» ofrece un paquete Ollama + Cline + Aider listo para usar, que puedes complementar con Tabby para el autocompletado en línea.