### What Tabby Offers

- **Code Completion:** Real-time, context-aware suggestions supporting 80+ languages
- **Answer Engine:** Integrated Q&A that understands your codebase and docs
- **Inline Chat:** AI assistant inside your editor for refactoring, explanations, and reviews
- **Repository Context:** Connect Git repos for more relevant suggestions
- **Multi-IDE Support:** VS Code, JetBrains, Vim/Neovim, and Emacs
- **Enterprise Features:** Team management, SSO, usage analytics, and audit logging

### Prerequisites & VPS Sizing

#### Requirements

- [RamNode Account](/content/site-root.html) — up to $500 in annual credits for new accounts
- SSH client (Terminal, PuTTY, or Windows Terminal)
- Domain name (optional) — e.g. tabby.yourdomain.com for HTTPS
- IDE: VS Code, JetBrains, Vim/Neovim, or Emacs

#### Model Size → VPS Plan

| Model Size | Min RAM | Min CPU | Recommended Plan |
| --- | --- | --- | --- |
| 0.5B – 1.5B | 4 GB | 2 vCPUs | Premium KVM 4GB ($24/mo) |
| 3B | 8 GB | 4 vCPUs | Premium KVM 8GB ($48/mo) |
| 7B | 16 GB | 4+ vCPUs | Premium KVM 16GB ($96/mo) |
| 13B – 14B | 32 GB | 8 vCPUs | Premium KVM 32GB ($192/mo) |

**💡 Cost Savings:** New RamNode accounts receive up to $500 in annual credits. A Premium KVM 8GB plan running a 3B model provides excellent quality for small-to-medium teams and is fully covered by credits for over a year.

### Provision & Prepare Your VPS

Provision an Ubuntu 22.04 or 24.04 LTS VPS from RamNode, then SSH in:

SSH into your server

```
ssh root@YOUR_SERVER_IP
```

Update system packages

```
apt update && apt upgrade -y
apt install -y curl wget git ufw
```

### Install Docker

Install Docker Engine

```
# Add Docker's official GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
  | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add the Docker repository
echo "deb [arch=$(dpkg --print-architecture) \
  signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list

# Install Docker Engine
apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Verify installation
docker --version
```

### Configure Firewall

Set up UFW

```
ufw allow OpenSSH
ufw allow 8080/tcp
ufw enable
```

**💡 HTTPS:** If exposing Tabby publicly, place it behind a reverse proxy with TLS. See the [HTTPS with Caddy](/content/guides/tabby#https/index.html) section below.

### Deploy with Docker Compose

Create data directory

```
mkdir -p /opt/tabby/data
```

Create /opt/tabby/docker-compose.yml

```
version: '3.5'

services:
  tabby:
    image: registry.tabbyml.com/tabbyml/tabby
    container_name: tabby
    restart: always
    command: >
      serve
      --model StarCoder-1B
      --chat-model Qwen2-1.5B-Instruct
      --device cpu
    volumes:
      - "/opt/tabby/data:/data"
    ports:
      - "8080:8080"
    environment:
      - TABBY_WEBSERVER_JWT_TOKEN_SECRET=CHANGE_ME_TO_RANDOM_STRING
```

**⚠️ Security:** Replace `CHANGE_ME_TO_RANDOM_STRING` with a strong secret. Generate one with: `openssl rand -hex 32`

Start Tabby

```
cd /opt/tabby
docker compose up -d

# Monitor first launch (model download may take several minutes)
docker compose logs -f tabby
```

Wait until you see a message indicating the server is listening on port 8080.

### Initial Admin Setup

Open your browser and navigate to `http://YOUR_SERVER_IP:8080`. On first access, Tabby will prompt you to create an admin account. Complete the registration to access the admin dashboard where you can manage users, configure repository context, and monitor usage statistics.

### Model Selection Guide

#### Completion Models

Real-time code suggestions as you type:

| Model | Size | Best For | License |
| --- | --- | --- | --- |
| Qwen2.5-Coder-1.5B | 1.5B | Low-resource deployments | Apache 2.0 |
| StarCoder2-3B | 3B | Balanced quality/speed | BigCode-OpenRAIL-M |
| Qwen2.5-Coder-7B | 7B | High-quality completions | Apache 2.0 |
| DeepSeekCoder-6.7B | 6.7B | Python/JS focused | Deepseek License |
| CodeLlama-13B | 13B | Maximum quality (high RAM) | Llama 2 |

#### Chat Models

Power the Answer Engine and inline chat:

| Model | Size | Notes | License |
| --- | --- | --- | --- |
| Qwen2-1.5B-Instruct | 1.5B | Lightweight default | Apache 2.0 |
| Qwen2.5-Coder-7B-Instruct | 7B | Code-specialized chat | Apache 2.0 |
| Qwen3-8B | 8B | Latest generation quality | Apache 2.0 |
| CodeGemma-7B-Instruct | 7B | Google's code model | Gemma License |

Swap models

```
# Update --model and --chat-model in docker-compose.yml, then:
cd /opt/tabby
docker compose down && docker compose up -d
# Tabby will automatically download the new model on startup
```

### IDE Extension Setup

#### VS Code

1. Open Extensions marketplace → search "Tabby" → install by TabbyML
2. Settings (Ctrl+,) → search "Tabby" → set Server Endpoint to `http://YOUR_SERVER_IP:8080`
3. Status bar shows a Tabby icon when connected — start typing to see suggestions

#### JetBrains IDEs

1. Settings → Plugins → Marketplace → search "Tabby" → install and restart
2. Settings → Tools → Tabby → enter server endpoint URL

#### Vim / Neovim

vim-plug setup

```
" Add to your plugin manager
Plug 'TabbyML/vim-tabby'

" Configure endpoint in vimrc or init.lua
let g:tabby_server_url = 'http://YOUR_SERVER_IP:8080'
```

### Configure Repository Context

Tabby can index your Git repositories for more contextually relevant completions — one of its most powerful features for teams.

#### Via Admin UI

1. Log in to the admin dashboard at `http://YOUR_SERVER_IP:8080`
2. Navigate to Repositories → add Git URLs (GitHub, GitLab, or self-hosted)
3. Tabby clones and indexes repositories in the background

#### Via Configuration File

/opt/tabby/data/config.toml

```
[[repositories]]
name = "my-project"
git_url = "https://github.com/your-org/your-repo.git"

[[repositories]]
name = "internal-api"
git_url = "https://git.yourdomain.com/team/internal-api.git"
```

Trigger indexing

```
docker exec tabby /opt/tabby/bin/tabby-cpu scheduler --now
```

### Optional: HTTPS with Caddy

Install Caddy

```
apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf https://dl.cloudsmith.io/public/caddy/stable/gpg.key \
  | gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt \
  | tee /etc/apt/sources.list.d/caddy-stable.list
apt update && apt install -y caddy
```

Create /etc/caddy/Caddyfile

```
tabby.yourdomain.com {
    reverse_proxy localhost:8080
}
```

Enable and open firewall

```
systemctl reload caddy

ufw allow 443/tcp
ufw allow 80/tcp
```

Caddy automatically obtains and renews Let's Encrypt certificates. Update your IDE extensions to use `https://tabby.yourdomain.com`.

### Maintenance & Performance Tuning

#### Update Tabby

Pull latest version

```
cd /opt/tabby
docker compose pull
docker compose down
docker compose up -d
```

#### Backup Strategy

Daily compressed backup

```
tar czf /backups/tabby-$(date +%F).tar.gz /opt/tabby/data
```

#### Monitoring

Check health and resources

```
# Container status
docker compose ps

# Live logs
docker compose logs -f tabby

# Resource usage
docker stats tabby
```

#### Performance Tuning

**Parallelism:** Add `--parallelism 4` to the serve command to handle concurrent requests (match to your vCPU count).

Add swap space (recommended for larger models)

```
fallocate -l 4G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
echo "/swapfile none swap sw 0 0" >> /etc/fstab
```

### Troubleshooting

#### Container Fails to Start (OOM)

Your VPS may lack RAM for the selected model. Try a smaller model (e.g., StarCoder-1B) or upgrade your plan.

#### Slow Completions (>2–3 seconds)

Model too large for CPU. Switch to a smaller model, stop competing processes, and check swap usage with `free -h`.

#### IDE Cannot Connect

Verify container is running (`docker compose ps`), port 8080 is open (`ufw status`), and you can reach the web UI in a browser.

#### Model Download Fails

Pre-download the model before starting:

Pre-download model

```
docker run --rm -v /opt/tabby/data:/data \
  --entrypoint /opt/tabby/bin/tabby-cpu \
  registry.tabbyml.com/tabbyml/tabby \
  download --model StarCoder-1B
```

### Quick Reference

#### Essential Commands

| Action | Command |
| --- | --- |
| Start Tabby | `docker compose up -d` |
| Stop Tabby | `docker compose down` |
| View logs | `docker compose logs -f tabby` |
| Update | `docker compose pull && docker compose up -d` |
| Check status | `docker compose ps` |
| Monitor resources | `docker stats tabby` |
| Index repos | `docker exec tabby /opt/tabby/bin/tabby-cpu scheduler --now` |

#### Key URLs

- Web UI: `http://YOUR_SERVER_IP:8080`
- API Docs: `http://YOUR_SERVER_IP:8080/swagger-ui`
- Health Check: `http://YOUR_SERVER_IP:8080/v1/health`
- Tabby Docs: [tabby.tabbyml.com/docs](https://tabby.tabbyml.com/docs/)
- Model Registry: [tabby.tabbyml.com/docs/models](https://tabby.tabbyml.com/docs/models/)

### Tabby Deployed Successfully!

Your self-hosted AI coding assistant is now running. Connect your IDE and enjoy private, context-aware code completions powered by your own infrastructure.