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

# Jan.ai ऑफ़लाइन असिस्टेंट

Clore.ai पर Jan.ai Server डिप्लॉय करें — मॉडल हब, बातचीत प्रबंधन, और Cortex इंजन द्वारा संचालित GPU-त्वरित इन्फ़रेंस के साथ पूरी तरह ऑफ़लाइन, OpenAI-संगत LLM सर्वर।

## अवलोकन

[Jan.ai](https://github.com/janhq/jan) यह एक ओपन-सोर्स, प्राइवेसी-फर्स्ट ChatGPT विकल्प है, जिसके GitHub पर 40,000 से अधिक स्टार हैं। जबकि Jan सबसे अधिक एक डेस्कटॉप एप्लिकेशन के रूप में जाना जाता है, इसका सर्वर घटक — **Jan Server** — एक पूर्णतः 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/घंटा**में GPU सर्वर किराये पर ले सकते हैं, Jan Server को Docker Compose के साथ चला सकते हैं, किसी भी GGUF या GPTQ मॉडल को लोड कर सकते हैं, और उसे OpenAI-संगत API के माध्यम से सर्व कर सकते हैं — और यह सब तब भी जब आपका डेटा मशीन से बाहर न जाए।

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

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

***

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

{% hint style="warning" %}
**Clore.ai marketplace पर multi-GPU 80GB-class rigs सूचीबद्ध नहीं हैं।** आज सूचीबद्ध सबसे बड़े boxes 4× RTX PRO 6000 Blackwell (प्रत्येक 96GB, कुल 380GB) और 8–11× RTX 5090 (प्रत्येक 32GB) हैं। A100 / H200 / B200 क्षमता [bare metal](https://clore.ai/bare-metal) के रूप में अनुरोध पर बेची जाती है। देखें [GPU मूल्य और उपलब्धता](/guides/guides_v2-hi/getting-started/pricing.md) किसी deployment का आकार तय करने से पहले।
{% endhint %}

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

| टियर            | GPU           | VRAM  | RAM    | स्टोरेज    | Clore.ai मूल्य                            |
| --------------- | ------------- | ----- | ------ | ---------- | ----------------------------------------- |
| **न्यूनतम**     | RTX 3060 12GB | 12 GB | 16 GB  | 50 GB SSD  | $0.03–0.07/घंटा                           |
| **अनुशंसित**    | RTX 3090      | 24 GB | 32 GB  | 100 GB SSD | $0.07–0.21/hr                             |
| **उच्च श्रेणी** | RTX 4090      | 24 GB | 64 GB  | 200 GB SSD | $0.14–0.42/hr                             |
| **बड़े मॉडल**   | A100 80GB     | 80 GB | 128 GB | 500 GB SSD | [bare metal](https://clore.ai/bare-metal) |

### मॉडल 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.8.1-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
```

यदि upstream 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
# server स्वास्थ्य जांचें
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": "आप एक सहायक सहायक हैं."},
      {"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`                 | कौन-से GPU एक्सपोज़ करने हैं (कॉमा से अलग किए गए इंडेक्स) |
| `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  # दोनों GPU का उपयोग करें
```

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

```bash
# Jan Server केवल GPU 0 पर चलाएँ
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 को reverse proxy के रूप में उपयोग करें:

```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.03–0.07/घंटा, 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.07–0.21/घंटा, 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"}'

# उच्च श्रेणी ([bare metal](https://clore.ai/bare-metal), 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' नामित वॉल्यूम में सुरक्षित रहते हैं

# इंस्टेंसों के बीच वास्तव में स्थायी स्टोरेज के लिए,
# मॉडल्स को object storage में अपलोड करें और स्टार्टअप पर डाउनलोड करें:
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 client लाइब्रेरीज़ का उपयोग करें
from openai import OpenAI

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

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": "GPU पर एक हाइकु लिखें"}],
    "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 runtime कॉन्फ़िगर है
docker info | grep -i nvidia

# सीधे GPU एक्सेस का परीक्षण करें
docker run --rm --gpus all nvidia/cuda:12.8.1-base-ubuntu22.04 nvidia-smi

# यदि यह विफल हो, तो Docker daemon कॉन्फ़िगरेशन जाँचें
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 out of memory)

```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

# अधिक भारी क्वांटाइज़्ड मॉडल का उपयोग करें (Q8 के बजाय Q3 या Q4)
# 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.07–0.21/घंटा) 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/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.