> 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-platforms-and-agents/jan.md).

# Jan.ai Offline Assistant

## अवलोकन

[Jan.ai](https://github.com/janhq/jan) एक ओपन-सोर्स, गोपनीयता-प्रथम ChatGPT विकल्प है जिसे GitHub पर 40,000 से अधिक स्टार मिले हैं। जबकि Jan सबसे ज्यादा एक डेस्कटॉप एप्लिकेशन के रूप में जाना जाता है, इसका सर्वर घटक — **Jan सर्वर** — एक पूरी तरह OpenAI-संगत REST API उजागर करता है जिसे Clore.ai जैसे क्लाउड GPU इन्फ्रास्ट्रक्चर पर तैनात किया जा सकता है।

Jan Server का निर्माण किया गया है [Cortex.cpp](https://github.com/janhq/cortex.cpp) इनफरेंस इंजन पर, एक उच्च-प्रदर्शन रनटाइम जो का समर्थन करता है `llama.cpp`, `TensorRT-LLM`और ONNX बैकएंड्स। Clore.ai पर आप केवल **$0.20/hr**में एक GPU सर्वर किराये पर ले सकते हैं, Jan Server को Docker Compose से चला सकते हैं, कोई भी GGUF या GPTQ मॉडल लोड कर सकते हैं, और इसे OpenAI-संगत API के माध्यम से सर्व कर सकते हैं — और सब कुछ बिना आपके डेटा के मशीन छोड़ने के।

**मुख्य विशेषताएँ:**

* 🔒 100% ऑफलाइन — आपका कोई डेटा कभी भी आपके सर्वर से बाहर नहीं जाता
* 🤖 OpenAI-संगत API (`/v1/chat/completions`, `/v1/models`आदि.)
* 📦 एक-कमांड मॉडल डाउनलोड के साथ मॉडल हब
* 🚀 CUDA के माध्यम से GPU त्वरण (llama.cpp + TensorRT-LLM बैकएंड्स)
* 💬 बिल्ट-इन बातचीत प्रबंधन और थ्रेड हिस्ट्री
* 🔌 मौजूदा अनुप्रयोगों में OpenAI के लिए ड्रॉप-इन प्रतिस्थापन

***

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

### हार्डवेयर आवश्यकताएँ

| टियर          | GPU           | VRAM  | RAM    | स्टोरेज    | Clore.ai मूल्य |
| ------------- | ------------- | ----- | ------ | ---------- | -------------- |
| **न्यूनतम**   | RTX 3060 12GB | 12 GB | 16 GB  | 50 GB SSD  | \~$0.10/घं     |
| **अनुशंसित**  | RTX 3090      | 24 GB | 32 GB  | 100 GB SSD | \~$0.20/घंटा   |
| **हाई-एंड**   | RTX 4090      | 24 GB | 64 GB  | 200 GB SSD | \~$0.35/घंटा   |
| **बड़े मॉडल** | A100 80GB     | 80 GB | 128 GB | 500 GB SSD | \~$1.10/घंटा   |

### मॉडल VRAM संदर्भ

| मॉडल                | आवश्यक VRAM | अनुशंसित GPU |
| ------------------- | ----------- | ------------ |
| Llama 3.1 8B (Q4)   | \~5 GB      | RTX 3060     |
| Llama 3.1 8B (FP16) | \~16 GB     | RTX 3090     |
| Llama 3.3 70B (Q4)  | \~40 GB     | A100 40GB    |
| Llama 3.1 405B (Q4) | \~220 GB    | 4× A100 80GB |
| Mistral 7B (Q4)     | \~4 GB      | RTX 3060     |
| Qwen2.5 72B (Q4)    | \~45 GB     | A100 80GB    |

### सॉफ्टवेयर अनिवार्यताएँ

* Clore.ai खाता जिसमें फंडेड वॉलेट हो
* बुनियादी Docker ज्ञान
* (वैकल्पिक) पोर्ट फॉरवर्डिंग के लिए OpenSSH क्लाइंट

***

## त्वरित प्रारम्भ

### चरण 1 — Clore.ai पर एक GPU सर्वर किराये पर लें

1. ब्राउज़ करें [clore.ai](https://clore.ai) और लॉग इन करें
2. सर्वरों को फ़िल्टर करें: **GPU प्रकार** → RTX 3090 या बेहतर, **Docker** → सक्षम
3. एक सर्वर चुनें और **Docker** डिप्लॉयमेंट विकल्प चुनें
4. आधिकारिक का उपयोग करें `nvidia/cuda:12.1.0-devel-ubuntu22.04` बेस इमेज या कोई भी CUDA इमेज
5. खुले पोर्ट्स: **1337** (Jan Server API), **39281** (Cortex API), **22** (SSH)

### चरण 2 — अपने सर्वर से कनेक्ट करें

```bash
# अपने Clore.ai सर्वर में SSH करें
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# GPU उपलब्ध है यह सत्यापित करें
nvidia-smi
```

### चरण 3 — Docker Compose इंस्टॉल करें (यदि मौजूद नहीं है)

```bash
# जांचें कि Docker Compose उपलब्ध है या नहीं
docker compose version

# यदि गायब हो तो इंस्टॉल करें (Ubuntu/Debian)
apt-get update && apt-get install -y docker-compose-plugin

# सत्यापित करें
docker compose version
```

### चरण 4 — Docker Compose के साथ Jan Server तैनात करें

```bash
# वर्किंग डायरेक्टरी बनाएं
mkdir -p /workspace/jan-server && cd /workspace/jan-server

# आधिकारिक Jan Server docker-compose.yml डाउनलोड करें
curl -fsSL https://raw.githubusercontent.com/janhq/jan-server/main/docker-compose.yml \
  -o docker-compose.yml

# कॉन्फ़िगरेशन की समीक्षा और संपादन करें
cat docker-compose.yml
```

यदि अपस्ट्रीम compose फ़ाइल उपलब्ध नहीं है या आप पूर्ण नियंत्रण चाहते हैं, तो इसे मैन्युअल रूप से बनाएँ:

```yaml
# /workspace/jan-server/docker-compose.yml
version: '3.8'

services:
  jan-server:
    image: ghcr.io/janhq/cortex:latest
    container_name: jan-server
    restart: unless-stopped
    ports:
      - "1337:1337"
      - "39281:39281"
    volumes:
      - jan-data:/root/jan
      - jan-models:/root/cortex/models
    environment:
      - CUDA_VISIBLE_DEVICES=0
      - JAN_API_HOST=0.0.0.0
      - JAN_API_PORT=1337
      - CORTEX_API_PORT=39281
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:1337/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

volumes:
  jan-data:
    driver: local
  jan-models:
    driver: local
```

```bash
# Jan Server शुरू करें
docker compose up -d

# स्टार्टअप लॉग्स का पालन करें ("Server started" संदेश का इंतजार करें)
docker compose logs -f jan-server
```

### चरण 5 — सत्यापित करें कि सर्वर चल रहा है

```bash
# सर्वर स्वास्थ्य जांचें
curl http://localhost:1337/health

# उपलब्ध मॉडलों की सूची (प्रारम्भ में खाली)
curl http://localhost:1337/v1/models

# अपेक्षित प्रतिक्रिया:
# {"object":"list","data":[]}
```

### चरण 6 — अपना पहला मॉडल पुल करें

```bash
# Llama 3.2 3B खींचें (अच्छा स्टार्टर, ~2GB)
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# या Mistral 7B Instruct Q4 पुल करें
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

# डाउनलोड प्रगति की निगरानी करें
curl http://localhost:1337/v1/models
```

### चरण 7 — मॉडल शुरू करें और चैट करें

```bash
# मॉडल शुरू करें (इसे GPU VRAM में लोड करता है)
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# अपना पहला चैट अनुरोध भेजें
curl http://localhost:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "हैलो! आप मेरी किस तरह मदद कर सकते हैं?"}
    ],
    "temperature": 0.7,
    "max_tokens": 512,
    "stream": false
  }'
```

***

## कॉन्फ़िगरेशन

### पर्यावरण चर

| वैरिएबल                | डिफ़ॉल्ट              | विवरण                                                      |
| ---------------------- | --------------------- | ---------------------------------------------------------- |
| `JAN_API_HOST`         | `0.0.0.0`             | API सर्वर को बाइंड करने के लिए होस्ट                       |
| `JAN_API_PORT`         | `1337`                | Jan Server API पोर्ट                                       |
| `CORTEX_API_PORT`      | `39281`               | आंतरिक Cortex इंजन पोर्ट                                   |
| `CUDA_VISIBLE_DEVICES` | `all`                 | कौन से GPUs एक्सपोज़ करने हैं (कॉमा से अलग किए गए इंडिसेस) |
| `JAN_DATA_FOLDER`      | `/root/jan`           | Jan डेटा फ़ोल्डर का पथ                                     |
| `CORTEX_MODELS_PATH`   | `/root/cortex/models` | मॉडल स्टोरेज का पथ                                         |

### मल्टी-GPU कॉन्फ़िगरेशन

एकाधिक GPU वाले सर्वरों के लिए (उदा., Clore.ai पर 2× RTX 3090):

```yaml
environment:
  - CUDA_VISIBLE_DEVICES=0,1  # दोनों GPUs का उपयोग करें
```

या विशिष्ट GPUs समर्पित करने के लिए:

```bash
# केवल GPU 0 पर Jan Server चलाएँ
docker run -d \
  --name jan-server \
  --gpus '"device=0"' \
  -p 1337:1337 \
  -v jan-data:/root/jan \
  -v jan-models:/root/cortex/models \
  ghcr.io/janhq/cortex:latest
```

### कस्टम मॉडल कॉन्फ़िगरेशन

```bash
# सभी पुल किए गए मॉडल सूचीबद्ध करें
curl http://localhost:1337/v1/models | jq '.data[].id'

# मॉडल विवरण प्राप्त करें
curl http://localhost:1337/v1/models/llama3.2:3b-gguf-q4-km

# चल रहे मॉडल को रोकें (VRAM खाली करें)
curl -X POST http://localhost:1337/v1/models/stop \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# एक मॉडल हटाएँ (डिस्क स्पेस खाली करें)
curl -X DELETE http://localhost:1337/v1/models/llama3.2:3b-gguf-q4-km
```

### API को टोकन से सुरक्षित करना

Jan Server में डिफ़ॉल्ट रूप से प्रमाणीकरण शामिल नहीं है। रिवर्स प्रॉक्सी के रूप में Nginx का उपयोग करें:

```bash
apt-get install -y nginx apache2-utils

# पासवर्ड फ़ाइल बनाएँ
htpasswd -c /etc/nginx/.htpasswd admin

# Nginx कॉन्फ़िगर करें
cat > /etc/nginx/sites-available/jan-server << 'EOF'
server {
    listen 80;
    server_name _;

    location / {
        auth_basic "Jan Server";
        auth_basic_user_file /etc/nginx/.htpasswd;
        proxy_pass http://127.0.0.1:1337;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 300s;
    }
}
EOF

ln -s /etc/nginx/sites-available/jan-server /etc/nginx/sites-enabled/
nginx -t && systemctl restart nginx
```

***

## GPU त्वरक

### CUDA त्वरण सत्यापन

Jan Server का Cortex इंजन स्वचालित रूप से CUDA का पता लगाता है। सत्यापित करें कि यह GPU का उपयोग कर रहा है:

```bash
# किसी मॉडल को लोड करने के बाद GPU मेमोरी उपयोग जांचें
nvidia-smi

# cortex प्रोसेस VRAM का उपभोग करते हुए दिखना चाहिए
# उदाहरण आउटपुट:
# | Processes:                                                            |
# |  GPU   GI   CI        PID   Type   Process name            GPU Memory |
# |    0    N/A  N/A    12345    C   /usr/local/bin/cortex    8192MiB |
```

### इन्फरेंस बैकएंड्स बदलना

Cortex कई बैकएंड्स का समर्थन करता है:

```bash
# कंटेनर के अंदर कौन से बैकएंड उपलब्ध हैं यह जांचें
docker exec jan-server cortex engines list

# NVIDIA GPUs के लिए TensorRT-LLM बैकएंड का उपयोग करें (तेज़, अधिक सेटअप आवश्यक)
docker exec jan-server cortex engines install tensorrt-llm

# llama.cpp बैकएंड का उपयोग करें (डिफ़ॉल्ट, सबसे अधिक संगत)
docker exec jan-server cortex engines install llama-cpp
```

### कंटेक्स्ट विंडो और बैच साइज ट्यूनिंग

```bash
# GPU प्रदर्शन के लिए मॉडल पैरामीटर अनुकूलित करें
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "ctx_len": 8192,
    "ngl": 99,
    "n_batch": 512,
    "n_parallel": 4,
    "cpu_threads": 8
  }'
```

| पैरामीटर     | विवरण                                | अनुशंसा                                 |
| ------------ | ------------------------------------ | --------------------------------------- |
| `ngl`        | GPU परतें (ज़्यादा = अधिक GPU उपयोग) | सेट करें `99` GPU को अधिकतम करने के लिए |
| `ctx_len`    | कंटेक्स्ट विंडो आकार                 | VRAM के अनुसार 4096–32768               |
| `n_batch`    | प्रॉम्प्ट प्रोसेसिंग के लिए बैच साइज | RTX 3090 के लिए 512, छोटे के लिए 256    |
| `n_parallel` | समानांतर अनुरोध स्लॉट                | API सर्वर उपयोग के लिए 4–8              |

***

## टिप्स और सर्वोत्तम प्रथाएँ

### 🎯 Clore.ai बजट के लिए मॉडल चयन

```bash
# बजट टियर (~$0.10/hr, RTX 3060 12GB):
# 7B मॉडलों के Q4_K_M क्वांट्स का उपयोग करें
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

# स्टैंडर्ड टियर (~$0.20/hr, RTX 3090 24GB):
# 13B मॉडलों के Q5_K_M क्वांट्स या 30B के Q4 का उपयोग करें
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "llama3.1:8b-instruct-gguf-q5-km"}'

# हाई-एंड टियर (~$1.10/hr, A100 80GB):
# उच्च प्रिसिजन में पूर्ण 70B मॉडल चलाएँ
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "llama3.3:70b-instruct-gguf-q4-km"}'
```

### 💾 स्थायी मॉडल स्टोरेज

चूंकि Clore.ai इंस्टेंस क्षणभंगुर होते हैं, बाहरी स्टोरेज माउंट करने पर विचार करें:

```bash
# एक नामित वॉल्यूम का उपयोग करें (Docker के साथ स्थायी)
docker compose down
# मॉडल 'jan-models' नामित वॉल्यूम में बने रहते हैं

# वास्तविक स्थायी स्टोरेज के लिए इंस्टेंसों में,
# मॉडल ऑब्जेक्ट स्टोरेज में अपलोड करें और स्टार्टअप पर पुल करें:
cat > /workspace/startup.sh << 'EOF'
#!/bin/bash
docker compose up -d
sleep 30
# अपने अक्सर उपयोग किए जाने वाले मॉडलों को प्री-पुल करें
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'
EOF
chmod +x /workspace/startup.sh
```

### 🔗 Jan Server का उपयोग OpenAI ड्रॉप-इन के रूप में

```python
# Python — मौजूदा OpenAI क्लाइंट लाइब्रेरीज़ का उपयोग करें
from openai import OpenAI

client = OpenAI(
    base_url="http://<CLORE_IP>:1337/v1",
    api_key="not-required"  # Jan Server में डिफ़ॉल्ट रूप से कोई ऑथ नहीं है
)

response = client.chat.completions.create(
    model="llama3.2:3b-gguf-q4-km",
    messages=[{"role": "user", "content": "क्वांटम कंप्यूटिंग समझाइए"}],
    temperature=0.7
)
print(response.choices[0].message.content)
```

```bash
# स्ट्रीमिंग समर्थन
curl http://localhost:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "messages": [{"role": "user", "content": "GPUs के बारे में एक हाईकु लिखो"}],
    "stream": true
  }'
```

### 📊 संसाधन उपयोग की निगरानी

```bash
# रियल-टाइम में GPU उपयोग देखें
watch -n 1 nvidia-smi

# कंटेनर संसाधन उपयोग जांचें
docker stats jan-server

# विस्तृत लॉग देखें
docker compose logs --tail=100 jan-server

# मॉडल लोड समय जांचें
docker compose logs jan-server | grep -E "(loaded|started|error)"
```

***

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

### कंटेनर शुरू नहीं होता — GPU नहीं मिला

```bash
# सत्यापित करें कि NVIDIA Docker रनटाइम कॉन्फ़िगर है
docker info | grep -i nvidia

# GPU ऐक्सेस को सीधे टेस्ट करें
docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi

# यदि यह विफल होता है, तो Docker डैमॉन कॉन्फ़िग जांचें
cat /etc/docker/daemon.json
# इसमें होना चाहिए: {"runtimes": {"nvidia": {...}}}
```

### मॉडल डाउनलोड फंस गया या विफल हो गया

```bash
# डिस्क स्पेस जाँचें
df -h /root

# त्रुटि के लिए कंटेनर लॉग जांचें
docker compose logs jan-server | tail -50

# पुल को पुन: प्रयास करें
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'
```

### VRAM समाप्त (CUDA आउट ऑफ मेमोरी)

```bash
# वर्तमान VRAM उपयोग जांचें
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

# पहले सभी चल रहे मॉडल रोकें
curl http://localhost:1337/v1/models | jq -r '.data[].id' | while read model; do
  curl -X POST http://localhost:1337/v1/models/stop \
    -H "Content-Type: application/json" \
    -d "{\"model\": \"$model\"}"
done

# अधिक क्वांटाइज़्ड मॉडल का उपयोग करें (Q3 या Q4 Q8 के बजाय)
# Q4_K_M आमतौर पर Q8 VRAM आवश्यकता का ~50% उपयोग करता है
```

### कंटेनर के बाहर से API से कनेक्ट नहीं कर पाना

```bash
# सुनिश्चित करें कि पोर्ट 1337 सभी इंटरफेस पर बाइंड है
docker ps --format "table {{.Names}}\t{{.Ports}}"
# यह दिखना चाहिए: 0.0.0.0:1337->1337/tcp

# Clore.ai फ़ायरवॉल नियम जांचें — सर्वर सेटिंग्स में पोर्ट 1337 खोलें
# पहले लोकली टेस्ट करें:
curl http://127.0.0.1:1337/health

# फिर बाहर से टेस्ट करें:
curl http://<CLORE_SERVER_IP>:<MAPPED_PORT>/health
```

### धीमी इन्फरेंस (CPU फॉलबैक)

```bash
# पुष्टि करें कि CUDA उपयोग हो रहा है (CPU नहीं)
docker exec jan-server cortex ps
# GPU मेमोरी आवंटित दिखाई देनी चाहिए

# मॉडल स्टार्ट में GPU परतों को मजबूर करें
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km", "ngl": 99}'
```

***

## अधिक पढ़ने के लिए

* [Jan.ai आधिकारिक दस्तावेज़](https://jan.ai/docs) — पूर्ण प्लेटफ़ॉर्म डॉक्स
* [Jan GitHub रिपॉजिटरी](https://github.com/janhq/jan) — स्रोत कोड और इश्यूज़
* [Jan Server / Jan API](https://github.com/janhq/jan-server) — सर्वर-विशिष्ट डॉक्स
* [Cortex.cpp इंजन](https://github.com/janhq/cortex.cpp) — अंतर्निहित इनफरेंस इंजन
* [Clore.ai शुरू करना](/guides/guides_v2-hi/getting-started/getting-started.md) — प्लेटफ़ॉर्म बुनियादी बातें
* [GPU तुलना मार्गदर्शिका](/guides/guides_v2-hi/getting-started/gpu-comparison.md) — सही GPU चुनें
* [Clore.ai पर Ollama चलाना](/guides/guides_v2-hi/language-models/ollama.md) — वैकल्पिक LLM सर्वर
* [Clore.ai पर vLLM चलाना](/guides/guides_v2-hi/language-models/vllm.md) — उच्च-थ्रूपुट इनफरेंस सर्वर
* [Hugging Face मॉडल हब](https://huggingface.co/models?library=gguf) — GGUF मॉडल खोजें

> 💡 **खर्च सुझाव:** Clore.ai पर एक RTX 3090 (\~$0.20/hr) Llama 3.1 8B को चल सकता है **\~50 टोकन/सेकंड** — व्यक्तिगत उपयोग या कम-ट्रैफ़िक APIs के लिए पर्याप्त। प्रोडक्शन वर्कलोड के लिए, vLLM पर विचार करें (देखें [vLLM गाइड](/guides/guides_v2-hi/language-models/vllm.md)) एक A100 पर.


---

# 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-platforms-and-agents/jan.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.