# Autocompletado de código TabbyML

TabbyML es un servidor de completado de código de IA autoalojado: un reemplazo directo de GitHub Copilot que mantiene tu código completamente en tu propia infraestructura. Con licencia Apache 2.0, se ejecuta en GPUs de Clore.ai y se conecta a VS Code, JetBrains y Vim/Neovim mediante extensiones oficiales. Los modelos van desde StarCoder2-1B (cabe en 4 GB de VRAM) hasta StarCoder2-15B y DeepSeek-Coder para máxima calidad.

{% hint style="success" %}
Todos los ejemplos se ejecutan en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Características clave

* **Alternativa autoalojada a Copilot** — tu código nunca abandona tu servidor
* **Licencia Apache 2.0** — gratis para uso comercial, sin restricciones
* **Extensiones de IDE** — VS Code, JetBrains (IntelliJ, PyCharm, WebStorm), Vim/Neovim
* **Múltiples modelos** — StarCoder2 (1B/3B/7B/15B), DeepSeek-Coder, CodeLlama
* **Contexto del repositorio** — recuperación de código impulsada por RAG para completados con conciencia del proyecto
* **Despliegue con Docker** — un solo comando para lanzar con soporte GPU
* **Panel de administración** — análisis de uso, gestión de modelos, gestión de usuarios
* **Interfaz de chat** — haz preguntas de programación más allá del autocompletado

## Requisitos

| Componente | Mínimo         | Recomendado     |
| ---------- | -------------- | --------------- |
| GPU        | RTX 3060 12 GB | RTX 3080 10 GB+ |
| VRAM       | 4 GB           | 10 GB           |
| RAM        | 8 GB           | 16 GB           |
| Disco      | 20 GB          | 50 GB           |
| CUDA       | 11.8           | 12.1+           |

**Precios de Clore.ai:** RTX 3080 ≈ $0.3–1/día · RTX 3060 ≈ $0.15–0.3/día

TabbyML es liviano: incluso una RTX 3060 ejecuta StarCoder2-7B con inferencia rápida.

## Inicio rápido

### 1. Desplegar con Docker

```bash
# StarCoder2-7B en GPU (equilibrio recomendado entre calidad y velocidad)
docker run -d \
  --name tabby \
  --gpus all \
  -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby \
  serve \
  --model StarCoder2-7B \
  --device cuda

# Verifica que esté en funcionamiento
curl http://localhost:8080/v1/health
```

### 2. Elige un modelo

| Modelo              | VRAM    | Velocidad     | Calidad | Mejor para                   |
| ------------------- | ------- | ------------- | ------- | ---------------------------- |
| StarCoder2-1B       | \~3 GB  | El más rápido | Básico  | RTX 3060, borradores rápidos |
| StarCoder2-3B       | \~5 GB  | Rápido        | Bueno   | Desarrollo general           |
| StarCoder2-7B       | \~8 GB  | Medio         | Alto    | Predeterminado recomendado   |
| StarCoder2-15B      | \~16 GB | Más lento     | Mejor   | Bases de código complejas    |
| DeepSeek-Coder-6.7B | \~8 GB  | Medio         | Alto    | Python, JS, TypeScript       |
| CodeLlama-7B        | \~8 GB  | Medio         | Bueno   | Propósito general            |

Cambia de modelo cambiando el `--model` indicador:

```bash
# Modelo más ligero para menor VRAM
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve --model StarCoder2-3B --device cuda

# Modelo más grande para mejor calidad
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve --model StarCoder2-15B --device cuda
```

### 3. Instalar extensiones de IDE

**VS Code:**

1. Abrir Extensiones (Ctrl+Shift+X)
2. Buscar "Tabby" e instalar la extensión oficial
3. Abrir Configuración → buscar "Tabby"
4. Configurar el endpoint del servidor: `http://<tu-clore-ip>:8080`

**JetBrains (IntelliJ, PyCharm, WebStorm):**

1. Configuración → Plugins → Marketplace
2. Buscar "Tabby" e instalar
3. Configuración → Tools → Tabby → Endpoint del servidor: `http://<tu-clore-ip>:8080`

**Vim/Neovim:**

```vim
" Usando vim-plug
Plug 'TabbyML/vim-tabby'

" Configuración en init.vim / .vimrc
let g:tabby_server_url = 'http://<tu-clore-ip>:8080'
```

### 4. Accede al panel de administración

Abrir `http://<tu-clore-ip>:8080` en un navegador. El panel proporciona:

* Estadísticas de uso de completado
* Estado del modelo y métricas de rendimiento
* Gestión de usuarios y tokens API
* Configuración de indexado de repositorios

## Ejemplos de uso

### Agregar contexto de repositorio (RAG)

Indexa tu repositorio para completados sensibilizados al proyecto:

```bash
# A través de la API de administración
curl -X POST http://localhost:8080/v1beta/repositories \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-project",
    "git_url": "file:///workspace/my-project"
  }'

# Tabby indexa el repo y lo usa para completados con contexto
```

### Usa la API de Chat

```bash
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "Write a Python function to parse CSV files with error handling"}
    ]
  }'
```

### Ejecutar con autenticación

```bash
# Genera un token de autenticación desde el panel de administración, luego:
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve \
  --model StarCoder2-7B \
  --device cuda

# Establece el token en la configuración de la extensión del IDE
# o usa el encabezado Authorization:
curl -H "Authorization: Bearer <token>" http://localhost:8080/v1/health
```

### Ejecutar sin Docker (Instalación directa)

```bash
# Instalar vía Homebrew (Linux)
curl -fsSL https://raw.githubusercontent.com/TabbyML/tabby/main/install.sh | bash

# O cargo install
cargo install tabby

# Ejecutar directamente
tabby serve --model StarCoder2-7B --device cuda --port 8080
```

## Comparación de costos

| Solución            | Costo mensual | Privacidad    | Latencia |
| ------------------- | ------------- | ------------- | -------- |
| GitHub Copilot      | $19/usuario   | ❌ Nube        | \~200 ms |
| TabbyML en RTX 3060 | \~$5–9/mes    | ✅ Autoalojado | \~50 ms  |
| TabbyML en RTX 3080 | \~$9–30/mes   | ✅ Autoalojado | \~30 ms  |
| TabbyML en RTX 4090 | \~$15–60/mes  | ✅ Autoalojado | \~15 ms  |

Para un equipo pequeño (3–5 desarrolladores), una sola RTX 3080 en Clore.ai reemplaza múltiples suscripciones a Copilot por una fracción del costo.

## Consejos

* **StarCoder2-7B es el punto óptimo** — mejor relación calidad-VRAM para la mayoría de los equipos
* **Habilita el contexto del repositorio** — el indexado RAG mejora drásticamente la relevancia de los completados para grandes bases de código
* **Expón el puerto 8080 de forma segura** — utiliza tunelización SSH o un proxy inverso con TLS para despliegues en producción
* **Monitorea el uso de VRAM** — `nvidia-smi` para asegurar que el modelo quepa con margen para el batching de inferencia
* **Usa la API de completado** para integración CI/CD — automatiza sugerencias de revisión de código
* **Tabby admite múltiples usuarios** — el panel de administración te permite crear tokens API por desarrollador
* **La latencia importa** — elige un servidor Clore.ai geográficamente cercano a tu equipo para los completados más rápidos

## Solución de problemas

| Problema                                 | Solución                                                                                 |
| ---------------------------------------- | ---------------------------------------------------------------------------------------- |
| El contenedor Docker sale inmediatamente | Revisa los logs: `docker logs tabby`. Probablemente VRAM insuficiente para el modelo     |
| La extensión del IDE no se conecta       | Verifica la URL del endpoint, revisa el firewall/reenvío de puertos en Clore.ai          |
| Completados lentos                       | Usa un modelo más pequeño, o asegúrate de que la GPU no esté compartida con otras tareas |
| `CUDA fuera de memoria`                  | Cambia a un modelo más pequeño (StarCoder2-3B o 1B)                                      |
| Indexado de repositorio atascado         | Revisa el espacio en disco y asegúrate de que el repositorio git sea accesible           |
| Token de autenticación rechazado         | Regenera el token en el panel de administración, actualiza la extensión del IDE          |
| Alta latencia desde el IDE remoto        | Usa túnel SSH: `ssh -L 8080:localhost:8080 root@<clore-ip>`                              |

## Recursos

* [TabbyML en GitHub](https://github.com/TabbyML/tabby)
* [Documentación de TabbyML](https://tabby.tabbyml.com)
* [Extensión para VS Code](https://marketplace.visualstudio.com/items?itemName=TabbyML.vscode-tabby)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/herramientas-de-codificacion-de-ia/tabby.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.