> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/herramientas-de-codificacion-con-ia/tabby.md).

# TabbyML Autocompletado de código

Autoalojar TabbyML como una alternativa privada a GitHub Copilot en Clore.ai

TabbyML es un servidor de completado de código con 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 la máxima calidad.

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

## Características clave

* **Alternativa a Copilot autoalojada** — tu código nunca sale de 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 conscientes del proyecto
* **Despliegue con Docker** — un solo comando para iniciar con soporte de GPU
* **Panel de administración** — analíticas 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       | 12.8+          | 12.8+           |

**Precios de Clore.ai:** RTX 3080 ≈ $0.05–0.19/h · RTX 3060 ≈ $0.03–0.07/h

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

## Inicio rápido

### 1. Despliega 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 ejecución
curl http://localhost:8080/v1/health
```

### 2. Elige un modelo

| Modelo              | VRAM    | Velocidad     | Calidad | Ideal 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         | Alta    | Predeterminado recomendado   |
| StarCoder2-15B      | \~16 GB | Más lento     | Mejor   | Bases de código complejas    |
| DeepSeek-Coder-6.7B | \~8 GB  | Medio         | Alta    | Python, JS, TypeScript       |
| CodeLlama-7B        | \~8 GB  | Medio         | Bueno   | Uso general                  |

Cambia de modelo cambiando la `--model` bandera:

```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 la mejor calidad
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve --model StarCoder2-15B --device cuda
```

### 3. Instala las extensiones del IDE

**VS Code:**

1. Abre Extensiones (Ctrl+Shift+X)
2. Busca "Tabby" e instala la extensión oficial
3. Abre Configuración → busca "Tabby"
4. Establece el endpoint del servidor: `http://<tu-clore-ip>:8080`

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

1. Configuración → Plugins → Marketplace
2. Busca "Tabby" e instala
3. Configuración → Herramientas → 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

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

* Estadísticas de uso de completados
* Estado del modelo y métricas de rendimiento
* Gestión de usuarios y tokens API
* Configuración de indexación del repositorio

## Ejemplos de uso

### Añadir contexto del repositorio (RAG)

Indexa tu repositorio para completados conscientes del proyecto:

```bash
# Mediante 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 repositorio y lo usa para completados con conciencia de contexto
```

### Usa la API de chat

```bash
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "messages": [
      {"role": "user", "content": "Escribe una función en Python para analizar archivos CSV con manejo de errores"}
    ]
  }'
```

### Ejecutar con autenticación

```bash
# Genera un token de autenticación mediante 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 tu 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 mediante Homebrew (Linux)
curl -fsSL https://raw.githubusercontent.com/TabbyML/tabby/main/install.sh | bash

# O con 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    | ✅ Autogestionado | \~50 ms  |
| TabbyML en RTX 3080 | \~$9–30/mes   | ✅ Autogestionado | \~30 ms  |
| TabbyML en RTX 4090 | \~$15–60/mes  | ✅ Autogestionado | \~15 ms  |

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

## Consejos

* **StarCoder2-7B es el punto ideal** — la mejor relación calidad/VRAM para la mayoría de los equipos
* **Activa el contexto del repositorio** — la indexación RAG mejora drásticamente la relevancia de los completados para bases de código grandes
* **Expón el puerto 8080 de forma segura** — usa túnel SSH o un proxy inverso con TLS para despliegues en producción
* **Supervisa el uso de VRAM** — `nvidia-smi` para asegurarte de que el modelo cabe con margen para el batching de inferencia
* **Usa la API de completado** para integración CI/CD — automatiza las 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 de Clore.ai geográficamente cercano a tu equipo para obtener los completados más rápidos

## Solución de problemas

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

## Recursos

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
