> 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/language-models/vllm.md).

# vLLM

उत्पादन वर्कलोड के लिए CLORE.AI GPUs पर उच्च-थ्रूपुट LLM इनफ़ेरेंस सर्वर।

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

{% hint style="info" %}
**वर्तमान संस्करण: v0.7.x** — यह गाइड vLLM v0.7.3+ को कवर करती है। नई सुविधाओं में DeepSeek-R1 सपोर्ट, स्वचालित टूल चयन के साथ संरचित आउटपुट, मल्टी-LoRA सर्विंग, और बेहतर मेमोरी दक्षता शामिल हैं।
{% endhint %}

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

| पैरामीटर         | न्यूनतम   | अनुशंसित |
| ---------------- | --------- | -------- |
| RAM              | **16GB**  | 32GB+    |
| VRAM             | 16GB (7B) | 24GB+    |
| नेटवर्क          | 500Mbps   | 1Gbps+   |
| शुरू होने का समय | 5-15 मिनट | -        |

{% hint style="info" %}
मिलता-जुलता GPU चाहिए? एक [RTX 4090 (24GB)](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=vllm) 7B–13B को आराम से संभालता है; 70B+ मॉडलों के लिए एक [H100 (80GB)](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=vllm) सबसे सुरक्षित विकल्प है।
{% endhint %}

{% hint style="danger" %}
**महत्वपूर्ण:** vLLM को पर्याप्त RAM और VRAM की आवश्यकता होती है। 16GB से कम RAM वाले सर्वर 7B मॉडल भी नहीं चला पाएंगे।
{% endhint %}

{% hint style="warning" %}
**शुरू होने का समय:** पहला लॉन्च मॉडल को HuggingFace से डाउनलोड करता है (मॉडल के आकार और नेटवर्क स्पीड के अनुसार 5-15 मिनट)। इस दौरान HTTP 502 सामान्य है।
{% endhint %}

## vLLM क्यों?

* **सबसे तेज़ थ्रूपुट** - 24x अधिक थ्रूपुट के लिए PagedAttention
* **उत्पादन-तैयार** - OpenAI-संगत API तुरंत उपलब्ध
* **निरंतर बैचिंग** - कुशल बहु-उपयोगकर्ता सर्विंग
* **स्ट्रीमिंग** - रीयल-टाइम टोकन जनरेशन
* **मल्टी-GPU** - बड़े मॉडलों के लिए टेन्सर पैरेललिज़्म
* **मल्टी-LoRA** - एक साथ कई फ़ाइन-ट्यून किए गए एडाप्टर सर्व करें (v0.7+)
* **संरचित आउटपुट** - JSON schema enforcement और tool calling (v0.7+)

## CLORE.AI पर त्वरित परिनियोजन

**Docker इमेज:**

```
vllm/vllm-openai:v0.7.3
```

**पोर्ट्स:**

```
22/tcp
8000/http
```

**कमांड:**

```bash
vllm serve mistralai/Mistral-7B-Instruct-v0.2 --host 0.0.0.0 --port 8000
```

### जाँचें कि यह काम कर रहा है

परिनियोजन के बाद, अपना खोजें `http_pub` URL में **My Orders**:

```bash
# हेल्थ जाँचें (पहली बार चलने पर 5-15 मिनट लग सकते हैं)
curl https://your-http-pub.clorecloud.net/health

# मॉडल सूची देखें (केवल मॉडल लोड होने के बाद काम करेगा)
curl https://your-http-pub.clorecloud.net/v1/models
```

{% hint style="warning" %}
यदि आपको 15 मिनट से अधिक समय तक HTTP 502 मिलता है, तो जाँचें:

1. सर्वर में 16GB+ RAM है
2. सर्वर में मॉडल के लिए पर्याप्त VRAM है
3. गेटेड मॉडलों के लिए HuggingFace टोकन सेट है
   {% endhint %}

## अपनी सेवा तक पहुँच

CLORE.AI पर परिनियोजित होने पर, vLLM को इस के माध्यम से एक्सेस करें `http_pub` URL:

```bash
# चैट पूर्णता
curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

{% hint style="info" %}
सभी `localhost:8000` नीचे दिए गए उदाहरण SSH के माध्यम से कनेक्ट होने पर काम करते हैं। बाहरी पहुँच के लिए, इसे अपने से बदलें `https://your-http-pub.clorecloud.net/` URL।
{% endhint %}

## स्थापना

### Docker का उपयोग करके (अनुशंसित)

```bash
docker run -d --gpus all \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:v0.7.3 \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0
```

### pip का उपयोग करके

```bash
pip install vllm==0.7.3

# सर्वर चलाएँ
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2
```

## समर्थित मॉडल

| मॉडल                          | पैरामीटर | आवश्यक VRAM       | आवश्यक RAM |
| ----------------------------- | -------- | ----------------- | ---------- |
| Mistral 7B                    | 7B       | 14GB              | 16GB+      |
| Llama 3.1 8B                  | 8B       | 16GB              | 16GB+      |
| Llama 3.1 70B                 | 70B      | 140GB (या 2x80GB) | 64GB+      |
| Mixtral 8x7B                  | 47B      | 90GB              | 32GB+      |
| Qwen2.5 7B                    | 7B       | 14GB              | 16GB+      |
| Qwen2.5 72B                   | 72B      | 145GB             | 64GB+      |
| DeepSeek-V3                   | 236B MoE | मल्टी-GPU         | 128GB+     |
| DeepSeek-R1-Distill-Qwen-7B   | 7B       | 14GB              | 16GB+      |
| DeepSeek-R1-Distill-Qwen-32B  | 32B      | 64GB              | 32GB+      |
| DeepSeek-R1-Distill-Llama-70B | 70B      | 140GB             | 64GB+      |
| Phi-4                         | 14B      | 28GB              | 32GB+      |
| Gemma 2 9B                    | 9B       | 18GB              | 16GB+      |
| CodeLlama 34B                 | 34B      | 68GB              | 32GB+      |

## सर्वर विकल्प

### बेसिक सर्वर

```bash
vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000
```

### प्रोडक्शन सर्वर

```bash
vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 1 \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.9 \
    --max-num-seqs 256 \
    --enable-prefix-caching
```

### क्वांटाइज़ेशन के साथ (कम VRAM)

```bash
# AWQ क्वांटाइज़्ड मॉडल (कम VRAM उपयोग करता है)
vllm serve TheBloke/Mistral-7B-Instruct-v0.2-AWQ \
    --host 0.0.0.0 \
    --quantization awq
```

### संरचित आउटपुट और टूल कॉलिंग (v0.7+)

स्वचालित टूल चयन और संरचित JSON आउटपुट सक्षम करें:

```bash
vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --enable-auto-tool-choice \
    --tool-call-parser mistral
```

Python में उपयोग करें:

```python
from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "किसी शहर के लिए वर्तमान मौसम प्राप्त करें",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "शहर का नाम"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "पेरिस में मौसम कैसा है?"}],
    tools=tools,
    tool_choice="auto"
)

# टूल कॉल को पार्स करें
tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
print(f"Tool: {tool_call.function.name}, Args: {args}")
```

response format के माध्यम से संरचित JSON आउटपुट:

```python
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "निकालें: John Smith, 30 years old, software engineer"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "occupation": {"type": "string"}
                },
                "required": ["name", "age", "occupation"]
            }
        }
    }
)
print(response.choices[0].message.content)
```

### मल्टी-LoRA सर्विंग (v0.7+)

एक बेस मॉडल को एक साथ कई LoRA एडाप्टरों के साथ सर्व करें:

```bash
vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --enable-lora \
    --lora-modules \
        sql-adapter=path/to/sql-lora \
        code-adapter=path/to/code-lora \
        chat-adapter=path/to/chat-lora \
    --max-lora-rank 64
```

मॉडल नाम द्वारा किसी विशिष्ट LoRA एडाप्टर को क्वेरी करें:

```python
# SQL एडाप्टर का उपयोग करें
response = client.chat.completions.create(
    model="sql-adapter",
    messages=[{"role": "user", "content": "शीर्ष 10 ग्राहकों को खोजने के लिए एक SQL query लिखें"}]
)

# कोड एडाप्टर का उपयोग करें
response = client.chat.completions.create(
    model="code-adapter",
    messages=[{"role": "user", "content": "सूची को sort करने के लिए एक Python function लिखें"}]
)
```

## DeepSeek-R1 सपोर्ट (v0.7+)

vLLM v0.7+ में DeepSeek-R1 distill मॉडलों के लिए मूल सपोर्ट है। ये reasoning मॉडल उत्पन्न करते हैं `<think>` टैग जो उनकी reasoning प्रक्रिया दिखाते हैं।

### DeepSeek-R1-Distill-Qwen-7B (एकल GPU)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 16384
```

### DeepSeek-R1-Distill-Qwen-32B (डुअल GPU)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90
```

### DeepSeek-R1-Distill-Llama-70B (क्वाड GPU)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768
```

### DeepSeek-R1 को क्वेरी करना

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[
        {
            "role": "user",
            "content": "हल करें: यदि एक ट्रेन 1.5 घंटे में 120km चलती है, तो उसकी गति m/s में कितनी है?"
        }
    ],
    max_tokens=2048,
    temperature=0.6
)

content = response.choices[0].message.content
# उत्तर से पहले <think>...</think> reasoning block शामिल होता है
print(content)
```

think टैग्स को पार्स करना:

```python
import re

def parse_deepseek_r1_response(content: str) -> dict:
    """DeepSeek-R1 response से thinking और answer निकालें."""
    think_match = re.search(r'<think>(.*?)</think>', content, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
    return {"thinking": thinking, "answer": answer}

result = parse_deepseek_r1_response(content)
print("Thinking:", result["thinking"][:200], "...")
print("Answer:", result["answer"])
```

## API उपयोग

### चैट पूर्णताएँ (OpenAI-संगत)

```python
from openai import OpenAI

# बाहरी पहुँच के लिए, अपना http_pub URL उपयोग करें:
client = OpenAI(
    base_url="https://your-http-pub.clorecloud.net/v1",
    api_key="not-needed"
)

# या SSH टनल के माध्यम से:
# client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "user", "content": "क्वांटम कंप्यूटिंग समझाएँ"}
    ],
    max_tokens=500,
    temperature=0.7
)

print(response.choices[0].message.content)
```

### स्ट्रीमिंग

```python
stream = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "एक कविता लिखें"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")
```

### cURL

```bash
curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 100
  }'
```

### टेक्स्ट पूर्णताएँ

```bash
curl https://your-http-pub.clorecloud.net/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "फ़्रांस की राजधानी है",
    "max_tokens": 50
  }'
```

## पूर्ण API संदर्भ

vLLM OpenAI-संगत endpoints के साथ अतिरिक्त utility endpoints भी प्रदान करता है।

### मानक endpoints

| एंडपॉइंट               | मेथड | विवरण                        |
| ---------------------- | ---- | ---------------------------- |
| `/v1/models`           | GET  | उपलब्ध मॉडल सूचीबद्ध करें    |
| `/v1/chat/completions` | POST | चैट पूर्णता                  |
| `/v1/completions`      | POST | टेक्स्ट पूर्णता              |
| `/health`              | GET  | हेल्थ चेक (खाली लौट सकता है) |

### अतिरिक्त endpoints

| एंडपॉइंट      | मेथड | विवरण                     |
| ------------- | ---- | ------------------------- |
| `/tokenize`   | POST | टेक्स्ट को टोकनाइज़ करें  |
| `/detokenize` | POST | टोकन को टेक्स्ट में बदलें |
| `/version`    | GET  | vLLM संस्करण प्राप्त करें |
| `/docs`       | GET  | Swagger UI दस्तावेज़ीकरण  |
| `/metrics`    | GET  | Prometheus metrics        |

#### टेक्स्ट को टोकनाइज़ करें

अनुरोध भेजने से पहले टोकन गिनने के लिए उपयोगी:

```bash
curl https://your-http-pub.clorecloud.net/tokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "Hello world"
  }'
```

प्रतिक्रिया:

```json
{"count": 2, "max_model_len": 32768, "tokens": [9707, 1879]}
```

#### डी-टोकनाइज़

टोकन IDs को वापस टेक्स्ट में बदलें:

```bash
curl https://your-http-pub.clorecloud.net/detokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "tokens": [9707, 1879]
  }'
```

प्रतिक्रिया:

```json
{"prompt": "Hello world"}
```

#### संस्करण प्राप्त करें

```bash
curl https://your-http-pub.clorecloud.net/version
```

प्रतिक्रिया:

```json
{"version": "0.7.3"}
```

#### Swagger दस्तावेज़ीकरण

इंटरैक्टिव API दस्तावेज़ीकरण के लिए ब्राउज़र में खोलें:

```
https://your-http-pub.clorecloud.net/docs
```

#### Prometheus metrics

मॉनिटरिंग के लिए:

```bash
curl https://your-http-pub.clorecloud.net/metrics
```

{% hint style="info" %}
**Reasoning मॉडल:** DeepSeek-R1 और समान मॉडल में शामिल हैं `<think>` प्रतिक्रियाओं में टैग जो अंतिम उत्तर से पहले मॉडल की reasoning प्रक्रिया दिखाते हैं।
{% endhint %}

## बेंचमार्क

### थ्रूपुट (टोकन/सेकंड प्रति उपयोगकर्ता)

| मॉडल               | RTX 3090 | RTX 4090 | A100 40GB | A100 80GB |
| ------------------ | -------- | -------- | --------- | --------- |
| Mistral 7B         | 100      | 170      | 210       | 230       |
| Llama 3.1 8B       | 95       | 150      | 200       | 220       |
| Llama 3.1 8B (AWQ) | 130      | 190      | 260       | 280       |
| Mixtral 8x7B       | -        | 45       | 70        | 85        |
| Llama 3.1 70B      | -        | -        | 25 (2x)   | 45 (2x)   |
| DeepSeek-R1 7B     | 90       | 145      | 190       | 210       |
| DeepSeek-R1 32B    | -        | -        | 40        | 70 (2x)   |

*बेंचमार्क जनवरी 2026 में अपडेट किए गए।*

### Context Length बनाम VRAM

| मॉडल     | 4K ctx | 8K ctx | 16K ctx | 32K ctx |
| -------- | ------ | ------ | ------- | ------- |
| 8B FP16  | 18GB   | 22GB   | 30GB    | 46GB    |
| 8B AWQ   | 8GB    | 10GB   | 14GB    | 22GB    |
| 70B FP16 | 145GB  | 160GB  | 190GB   | 250GB   |
| 70B AWQ  | 42GB   | 50GB   | 66GB    | 98GB    |

## Hugging Face प्रमाणीकरण

गेटेड मॉडलों (Llama, आदि) के लिए:

```bash
# कमांड में टोकन सेट करें
vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --env HUGGING_FACE_HUB_TOKEN=hf_xxxxx
```

या इसे environment variable के रूप में सेट करें:

```bash
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx
```

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

| मॉडल | न्यूनतम VRAM | न्यूनतम RAM | अनुशंसित            |
| ---- | ------------ | ----------- | ------------------- |
| 7-8B | 16GB         | **16GB**    | 24GB VRAM, 32GB RAM |
| 13B  | 26GB         | 32GB        | 40GB VRAM           |
| 34B  | 70GB         | 32GB        | 80GB VRAM           |
| 70B  | 140GB        | 64GB        | 2x80GB              |

## लागत अनुमान

CLORE.AI मार्केटप्लेस की सामान्य दरें:

| GPU      | VRAM | कीमत/दिन   | इसके लिए सबसे अच्छा |
| -------- | ---- | ---------- | ------------------- |
| RTX 3090 | 24GB | $0.30–1.00 | 7-8B मॉडल           |
| RTX 4090 | 24GB | $0.50–2.00 | 7-13B, तेज़         |
| A100     | 40GB | $1.50–3.00 | 13-34B मॉडल         |
| A100     | 80GB | $2.00–4.00 | 34-70B मॉडल         |

*कीमतें USD/दिन में हैं। दरें प्रदाता के अनुसार बदलती हैं — वर्तमान दरों के लिए देखें* [*CLORE.AI मार्केटप्लेस*](https://clore.ai/marketplace) *।*

## समस्या-समाधान

### लंबे समय तक HTTP 502

1. **RAM जाँचें:** सर्वर में 16GB+ RAM होना चाहिए
2. **VRAM जाँचें:** मॉडल समा जाना चाहिए
3. **मॉडल डाउनलोड हो रहा है:** पहली बार चलाने पर HuggingFace से डाउनलोड होता है (5-15 मिनट)
4. **HF Token:** गेटेड मॉडल के लिए प्रमाणीकरण आवश्यक है

### मेमोरी समाप्त

```bash
# मेमोरी उपयोग कम करें
--gpu-memory-utilization 0.8
--max-model-len 4096
--max-num-seqs 64

# या क्वांटाइज़ेशन का उपयोग करें
--quantization awq
```

### मॉडल डाउनलोड विफल होता है

```bash
# HF टोकन जाँचें
echo $HUGGING_FACE_HUB_TOKEN

# मॉडल पहले से डाउनलोड करें
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.2
```

## vLLM बनाम अन्य

| विशेषता          | vLLM        | llama.cpp | Ollama   |
| ---------------- | ----------- | --------- | -------- |
| थ्रूपुट          | सर्वोत्तम   | अच्छा     | अच्छा    |
| VRAM उपयोग       | उच्च        | निम्न     | मध्यम    |
| उपयोग में आसानी  | मध्यम       | मध्यम     | आसान     |
| शुरू होने का समय | 5-15 मिनट   | 1-2 मिनट  | 30 सेकंड |
| मल्टी-GPU        | मूल         | सीमित     | सीमित    |
| टूल कॉलिंग       | हाँ (v0.7+) | सीमित     | सीमित    |
| मल्टी-LoRA       | हाँ (v0.7+) | नहीं      | नहीं     |

**vLLM का उपयोग करें जब:**

* उच्च थ्रूपुट प्राथमिकता हो
* कई उपयोगकर्ताओं को सेवा देना
* पर्याप्त VRAM और RAM हो
* प्रोडक्शन परिनियोजन
* टूल कॉलिंग / संरचित आउटपुट की आवश्यकता हो

**Ollama का उपयोग करें जब:**

* त्वरित सेटअप की आवश्यकता हो
* एकल उपयोगकर्ता
* कम संसाधन उपलब्ध हों

## अगले चरण

* [Ollama](/guides/guides_v2-hi/language-models/ollama.md) - तेज़ स्टार्टअप वाला सरल विकल्प
* [DeepSeek-R1](/guides/guides_v2-hi/language-models/deepseek-r1.md) - तर्क मॉडल गाइड
* [DeepSeek-V3](/guides/guides_v2-hi/language-models/deepseek-v3.md) - सर्वश्रेष्ठ सामान्य मॉडल
* [Qwen2.5](/guides/guides_v2-hi/language-models/qwen25.md) - बहुभाषी मॉडल
* [Llama.cpp](/guides/guides_v2-hi/language-models/llamacpp-server.md) - कम VRAM विकल्प


---

# 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/language-models/vllm.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.