> 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-hi/ai-coding-tools/tabby.md).

# TabbyML Code Completion

TabbyML एक स्वयं-होस्टेड एआई कोड पूर्णता सर्वर है — GitHub Copilot का ड्रॉप-इन विकल्प जो आपका कोड पूरी तरह से आपकी अपनी इंफ्रास्ट्रक्चर पर रखता है। Apache 2.0 के तहत लाइसेंस प्राप्त, यह Clore.ai GPUs पर चलता है और आधिकारिक एक्सटेंशनों के माध्यम से VS Code, JetBrains और Vim/Neovim से जुड़ता है। मॉडल StarCoder2-1B (4 GB VRAM पर फिट होता है) से लेकर StarCoder2-15B और सर्वोत्तम गुणवत्ता के लिए DeepSeek-Coder तक हैं।

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलते हैं जो कि के माध्यम से किराये पर लिए गए हैं [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

## प्रमुख विशेषताएँ

* **स्वयं-होस्टेड Copilot विकल्प** — आपका कोड कभी भी आपके सर्वर से बाहर नहीं जाता
* **Apache 2.0 लाइसेंस** — व्यावसायिक उपयोग के लिए मुफ्त, कोई प्रतिबंध नहीं
* **IDE एक्सटेंशन** — VS Code, JetBrains (IntelliJ, PyCharm, WebStorm), Vim/Neovim
* **कई मॉडल** — StarCoder2 (1B/3B/7B/15B), DeepSeek-Coder, CodeLlama
* **रिपॉजिटरी संदर्भ** — प्रोजेक्ट-सचेत पूर्णताओं के लिए RAG- संचालित कोड पुनर्प्राप्ति
* **Docker परिनियोजन** — GPU समर्थन के साथ लॉन्च करने के लिए एक कमांड
* **एडमिन डैशबोर्ड** — उपयोग विश्लेषिकी, मॉडल प्रबंधन, उपयोगकर्ता प्रबंधन
* **चैट इंटरफ़ेस** — ऑटोकम्पलीशन से परे कोडिंग प्रश्न पूछें

## आवश्यकताएँ

| घटक   | न्यूनतम        | अनुशंसित        |
| ----- | -------------- | --------------- |
| GPU   | RTX 3060 12 GB | RTX 3080 10 GB+ |
| VRAM  | 4 GB           | 10 GB           |
| RAM   | 8 GB           | 16 GB           |
| डिस्क | 20 GB          | 50 GB           |
| CUDA  | 11.8           | 12.1+           |

**Clore.ai मूल्य निर्धारण:** RTX 3080 ≈ $0.3–1/दिन · RTX 3060 ≈ $0.15–0.3/दिन

TabbyML हल्का है — यहाँ तक कि एक RTX 3060 भी StarCoder2-7B को तेज़ इन्फ़रेंस के साथ चला सकता है।

## त्वरित आरंभ

### 1. Docker से परिनियोजित करें

```bash
# GPU पर StarCoder2-7B (गुणवत्ता और गति का अनुशंसित संतुलन)
docker run -d \
  --name tabby \
  --gpus all \
  -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby \
  serve \
  --model StarCoder2-7B \
  --device cuda

# पुष्टि करें कि यह चल रहा है
curl http://localhost:8080/v1/health
```

### 2. एक मॉडल चुनें

| मॉडल                | VRAM    | स्पीड    | गुणवत्ता  | उत्तम हेतु                       |
| ------------------- | ------- | -------- | --------- | -------------------------------- |
| StarCoder2-1B       | \~3 GB  | सबसे तेज | बेसिक     | RTX 3060, तेज़ प्रारूप / ड्राफ्ट |
| StarCoder2-3B       | \~5 GB  | तेज़     | अच्छा     | सामान्य विकास के लिए             |
| StarCoder2-7B       | \~8 GB  | मध्यम    | उच्च      | अनुशंसित डिफ़ॉल्ट                |
| StarCoder2-15B      | \~16 GB | धीमा     | सर्वोत्तम | जटिल कोडबेस के लिए               |
| DeepSeek-Coder-6.7B | \~8 GB  | मध्यम    | उच्च      | Python, JS, TypeScript           |
| CodeLlama-7B        | \~8 GB  | मध्यम    | अच्छा     | सामान्य प्रयोजन                  |

मॉडल बदलने के लिए बदलें `--model` फ्लैग:

```bash
# कम VRAM के लिए हल्का मॉडल
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve --model StarCoder2-3B --device cuda

# सर्वश्रेष्ठ गुणवत्ता के लिए सबसे बड़ा मॉडल
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve --model StarCoder2-15B --device cuda
```

### 3. IDE एक्सटेंशन इंस्टॉल करें

**VS Code:**

1. एक्सटेंशन्स खोलें (Ctrl+Shift+X)
2. "Tabby" खोजें और आधिकारिक एक्सटेंशन इंस्टॉल करें
3. सेटिंग्स खोलें → "Tabby" खोजें
4. सर्वर एंडपॉइंट सेट करें: `http://<your-clore-ip>:8080`

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

1. Settings → Plugins → Marketplace
2. "Tabby" खोजें और इंस्टॉल करें
3. Settings → Tools → Tabby → Server endpoint: `http://<your-clore-ip>:8080`

**Vim/Neovim:**

```vim
" vim-plug का उपयोग करते हुए
Plug 'TabbyML/vim-tabby'

" init.vim / .vimrc में कॉन्फ़िगरेशन
let g:tabby_server_url = 'http://<your-clore-ip>:8080'
```

### 4. एडमिन डैशबोर्ड तक पहुँचें

खोलें `http://<your-clore-ip>:8080` ब्राउज़र में। डैशबोर्ड प्रदान करता है:

* पूर्णता उपयोग सांख्यिकी
* मॉडल स्थिति और प्रदर्शन मीट्रिक्स
* उपयोगकर्ता और API टोकन प्रबंधन
* रिपॉजिटरी इंडेक्सिंग कॉन्फ़िगरेशन

## उपयोग के उदाहरण

### रिपॉजिटरी संदर्भ (RAG) जोड़ें

प्रोजेक्ट-सचेत पूर्णताओं के लिए अपनी रिपॉजिटरी को इंडेक्स करें:

```bash
# एडमिन API के माध्यम से
curl -X POST http://localhost:8080/v1beta/repositories \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-project",
    "git_url": "file:///workspace/my-project"
  }'

# Tabby रिपो को इंडेक्स करता है और संदर्भ-सचेत पूर्णताओं के लिए इसका उपयोग करता है
```

### चैट API का उपयोग करें

```bash
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "त्रुटि हैंडलिंग के साथ CSV फ़ाइलों को पार्स करने के लिए एक Python फ़ंक्शन लिखें"}
    ]
  }'
```

### प्रमाणीकरण के साथ चलाएँ

```bash
# एडमिन डैशबोर्ड के माध्यम से एक ऑथ टोकन जनरेट करें, फिर:
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve \
  --model StarCoder2-7B \
  --device cuda

# अपने IDE एक्सटेंशन सेटिंग्स में टोकन सेट करें
# या Authorization हेडर का उपयोग करें:
curl -H "Authorization: Bearer <token>" http://localhost:8080/v1/health
```

### Docker के बिना चलाएँ (प्रत्यक्ष इंस्टॉल)

```bash
# Homebrew के माध्यम से इंस्टॉल करें (Linux)
curl -fsSL https://raw.githubusercontent.com/TabbyML/tabby/main/install.sh | bash

# या cargo install
cargo install tabby

# सीधे चलाएँ
tabby serve --model StarCoder2-7B --device cuda --port 8080
```

## लागत तुलना

| समाधान              | मासिक लागत     | गोपनीयता | लेटेंसी  |
| ------------------- | -------------- | -------- | -------- |
| GitHub Copilot      | $19/उपयोगकर्ता | ❌ क्लाउड | \~200 ms |
| RTX 3060 पर TabbyML | \~$5–9/माह     | ✅ स्वयं  | \~50 ms  |
| RTX 3080 पर TabbyML | \~$9–30/माह    | ✅ स्वयं  | \~30 ms  |
| RTX 4090 पर TabbyML | \~$15–60/माह   | ✅ स्वयं  | \~15 ms  |

एक छोटी टीम (3–5 डेवलपर्स) के लिए, Clore.ai पर एक अकेला RTX 3080 कई Copilot सब्सक्रिप्शनों की जगह ले सकता है और लागत का केवल एक अंश खर्च होता है।

## टिप्स

* **StarCoder2-7B सबसे उपयुक्त है** — अधिकांश टीमों के लिए VRAM के मुकाबले सर्वोत्तम गुणवत्ता
* **रिपॉजिटरी संदर्भ सक्षम करें** — बड़े कोडबेस के लिए RAG इंडेक्सिंग पूर्णता की प्रासंगिकता को नाटकीय रूप से सुधारता है
* **पोर्ट 8080 को सुरक्षित रूप से एक्सपोज़ करें** — प्रोडक्शन परिनियोजन के लिए SSH टनेलिंग या TLS के साथ रिवर्स प्रॉक्सी का उपयोग करें
* **VRAM उपयोग की निगरानी करें** — `nvidia-smi` ताकि यह सुनिश्चित हो कि मॉडल इन्फ़रेंस बैचिंग के लिए हेडरूम के साथ फिट हो
* **पूर्णता API का उपयोग करें** CI/CD एकीकरण के लिए — कोड समीक्षा सुझावों को स्वचालित करें
* **Tabby कई उपयोगकर्ताओं का समर्थन करता है** — एडमिन डैशबोर्ड आपको प्रत्येक डेवलपर के लिए API टोकन बनाने देता है
* **लेटेंसी मायने रखती है** — सबसे तेज़ पूर्णताओं के लिए अपनी टीम के भौगोलिक रूप से नजदीक Clore.ai सर्वर चुनें

## समस्याओं का निवारण

| समस्या                             | समाधान                                                                       |
| ---------------------------------- | ---------------------------------------------------------------------------- |
| Docker कंटेनर तुरंत बाहर निकलता है | लॉग जांचें: `docker logs tabby`। संभावना है कि मॉडल के लिए VRAM अपर्याप्त है |
| IDE एक्सटेंशन कनेक्ट नहीं हो रहा   | एंडपॉइंट URL सत्यापित करें, Clore.ai पर फ़ायरवॉल/पोर्ट फ़ॉरवर्डिंग जांचें    |
| पूर्णताएँ धीमी हैं                 | छोटा मॉडल उपयोग करें, या सुनिश्चित करें कि GPU अन्य कार्यों के साथ साझा न हो |
| `CUDA में आउट ऑफ मेमोरी`           | छोटे मॉडल (StarCoder2-3B या 1B) पर स्विच करें                                |
| रिपॉजिटरी इंडेक्सिंग अटकी हुई है   | डिस्क स्थान जांचें और सुनिश्चित करें कि git रिपो पहुँच योग्य है              |
| ऑथ टोकन अस्वीकार कर दिया गया       | एडमिन डैशबोर्ड में टोकन पुनःजनरेट करें, IDE एक्सटेंशन अपडेट करें             |
| रिमोट IDE से उच्च विलंबता          | SSH टनल का उपयोग करें: `ssh -L 8080:localhost:8080 root@<clore-ip>`          |

## संसाधन

* [TabbyML GitHub](https://github.com/TabbyML/tabby)
* [TabbyML प्रलेखन](https://tabby.tabbyml.com)
* [VS Code एक्सटेंशन](https://marketplace.visualstudio.com/items?itemName=TabbyML.vscode-tabby)
* [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-hi/ai-coding-tools/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.