> 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-ru/yazykovye-modeli/qwen25.md).

# Qwen2.5

Запустите многоязычные LLM Alibaba Qwen2.5 на GPU Clore.ai

Запускайте семейство моделей Qwen2.5 от Alibaba — мощные многоязычные LLM с отличными возможностями кода и математики на GPU CLORE.AI.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Почему Qwen2.5?

* **Модели разных размеров** - от 0,5B до 72B параметров
* **Многоязычность** - 29 языков, включая китайский
* **Длинный контекст** - до 128K токенов
* **Специализированные варианты** - версии Coder, Math
* **Открытый исходный код** - лицензия Apache 2.0

## Быстрое развертывание на CLORE.AI

**Docker-образ:**

```
vllm/vllm-openai:latest
```

**Порты:**

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

**Команда:**

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000
```

## Доступ к вашему сервису

После развертывания найдите свой `http_pub` URL в **Мои заказы**:

1. Перейдите на **Мои заказы** страницу
2. Нажмите на свой заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

### Проверьте, что он работает

```bash
# Проверьте, готов ли сервис
curl https://your-http-pub.clorecloud.net/health

# Список доступных моделей
curl https://your-http-pub.clorecloud.net/v1/models
```

{% hint style="warning" %}
Если вы получаете HTTP 502, подождите 5–15 минут — модель всё ещё загружается с HuggingFace.
{% endhint %}

## Режим рассуждений Qwen3

{% hint style="info" %}
**Новое в Qwen3:** Некоторые модели Qwen3 поддерживают режим рассуждений, который показывает ход мыслей модели в `<think>` тегах перед окончательным ответом.
{% endhint %}

При использовании моделей Qwen3 через vLLM ответы могут включать рассуждения:

```json
{
  "content": "<think>\nДавайте подумаем об этом шаг за шагом...\n</think>\n\nОтвет такой..."
}
```

Чтобы использовать Qwen3 с рассуждениями:

```bash
vllm serve Qwen/Qwen3-0.6B --host 0.0.0.0 --port 8000
```

## Варианты модели

### Базовые модели

| Модель               | Параметры | VRAM (FP16) | Контекст | Примечания                      |
| -------------------- | --------- | ----------- | -------- | ------------------------------- |
| Qwen2.5-0.5B         | 0,5B      | 2 ГБ        | 32K      | Для edge/тестирования           |
| Qwen2.5-1.5B         | 1,5B      | 4 ГБ        | 32K      | Очень лёгкая                    |
| Qwen2.5-3B           | 3B        | 8 ГБ        | 32K      | Бюджетная                       |
| Qwen2.5-7B           | 7B        | 16GB        | 128K     | Сбалансированная                |
| Qwen2.5-14B          | 14B       | 32GB        | 128K     | Высокое качество                |
| Qwen2.5-32B          | 32B       | 70 ГБ       | 128K     | Очень высокое качество          |
| Qwen2.5-72B          | 72B       | 150 ГБ      | 128K     | **Лучшее качество**             |
| Qwen2.5-72B-Instruct | 72B       | 150 ГБ      | 128K     | Настроенная для чата/инструкций |

### Специализированные варианты

| Модель                     | Назначение | Лучше всего для                      | VRAM (FP16) |
| -------------------------- | ---------- | ------------------------------------ | ----------- |
| Qwen2.5-Coder-7B-Instruct  | Код        | Программирование, отладка            | 16GB        |
| Qwen2.5-Coder-14B-Instruct | Код        | Сложные задачи по коду               | 32GB        |
| Qwen2.5-Coder-32B-Instruct | Код        | **Лучшая модель для кода**           | 70 ГБ       |
| Qwen2.5-Math-7B-Instruct   | Математика | Вычисления, доказательства           | 16GB        |
| Qwen2.5-Math-72B-Instruct  | Математика | Математика исследовательского уровня | 150 ГБ      |
| Qwen2.5-Instruct           | Чат        | Общий помощник                       | варьируется |

## Требования к оборудованию

{% hint style="warning" %}
**Многопроцессорные конфигурации с GPU класса 80GB не представлены на маркетплейсе Clore.ai.** Самые крупные доступные сейчас машины — это 4× RTX PRO 6000 Blackwell (по 96GB, всего 380GB) и 8–11× RTX 5090 (по 32GB). Ёмкость A100 / H200 / B200 продаётся как [голое железо](https://clore.ai/bare-metal) по запросу. Проверьте [Цены и доступность GPU](/guides/guides_v2-ru/nachalo-raboty/pricing.md) перед выбором размера развёртывания.
{% endhint %}

| Модель    | Минимальная GPU | Рекомендуется | Видеопамять (Q4) |
| --------- | --------------- | ------------- | ---------------- |
| 0,5B-3B   | RTX 3060 12GB   | RTX 3080      | 2-6 ГБ           |
| 7B        | RTX 3090 24GB   | RTX 4090      | 6 ГБ             |
| 14B       | A100 40 ГБ      | A100 80 ГБ    | 12GB             |
| 32B       | A100 80 ГБ      | 2x A100 40 ГБ | 22 ГБ            |
| 72B       | 2x A100 80 ГБ   | 4x A100 80GB  | 48 ГБ            |
| Coder-32B | A100 80 ГБ      | 2x A100 40 ГБ | 22 ГБ            |

## Установка

### Использование vLLM (рекомендуется)

```bash
pip install vllm==0.7.3

python -m vllm.entrypoints.openai.api_server \\
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000
```

### Использование Ollama

```bash
# Стандартные модели
ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull qwen2.5:72b       # Новое: крупнейшая Qwen2.5

# Специализированные
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:32b  # Новое: лучшая модель для кода

# Запуск чата
ollama run qwen2.5:7b
```

### Использование Transformers

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "Qwen/Qwen2.5-7B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

messages = [{"role": "user", "content": "Hello!"}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer([text], return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

## Использование API

### API, совместимый с OpenAI

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "Вы — полезный помощник."},
        {"role": "user", "content": "Объясни машинное обучение простыми словами."}
    ],
    temperature=0.7,
    max_tokens=500
)

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

### Потоковая передача

```python
stream = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Напиши стихотворение об ИИ"}],
    stream=True
)

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

### cURL

```bash
curl http://localhost:8000/v1/chat/completions \\
    -H "Content-Type: application/json" \\
    -d '{
        "model": "Qwen/Qwen2.5-7B-Instruct",
        "messages": [
            {"role": "user", "content": "Что такое Python?"}
        ]
    }'
```

## Qwen2.5-72B-Instruct

Флагманская модель Qwen2.5 — крупнейшая и самая мощная в семействе. Она конкурирует с GPT-4 по многим бенчмаркам и полностью открыта под лицензией Apache 2.0.

### Запуск через vLLM (несколько GPU)

```bash
# Конфигурация 4x A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \\
    --tensor-parallel-size 4 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9

# Квантованная AWQ — работает на 2x A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \\
    --tensor-parallel-size 2 \
    --quantization awq \\
    --max-model-len 32768
```

### Запуск через Ollama

```bash
# Загрузите модель 72B (для Q4 требуется 48+ ГБ VRAM)
ollama pull qwen2.5:72b

# Запустите интерактивную сессию
ollama run qwen2.5:72b

# Доступ к API
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:72b",
  "messages": [{"role": "user", "content": "Проанализируй этот сложный сценарий..."}],
  "stream": false
}'
```

### Пример на Python

```python
from openai import OpenAI

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

# Модель 72B отлично справляется со сложными аналитическими задачами
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Вы эксперт-аналитик. Давайте подробные, нюансированные ответы."
        },
        {
            "role": "user",
            "content": """Сравните архитектурные различия между трансформером и 
            моделями пространства состояний (SSM) для моделирования последовательностей. Включите компромиссы в эффективности."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

## Qwen2.5-Coder-32B-Instruct

Лучшая доступная открытая модель для кода. Qwen2.5-Coder-32B-Instruct по многим бенчмаркам программирования соответствует GPT-4o или превосходит его, поддерживая более 40 языков программирования.

### Запуск через vLLM

```bash
# Один A100 80GB
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \\
    --max-model-len 16384 \
    --gpu-memory-utilization 0.9

# Две RTX 4090 (24 ГБ каждая = 48 ГБ всего, с квантованием Q4)
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \\
    --tensor-parallel-size 2 \
    --quantization awq
```

### Запуск через Ollama

```bash
# Загрузите Coder-32B (для Q4 требуется примерно 22 ГБ VRAM)
ollama pull qwen2.5-coder:32b

# Запуск
ollama run qwen2.5-coder:32b

# Проверьте с помощью кодового запроса
ollama run qwen2.5-coder:32b "Напишите асинхронный веб-скрейпер на Python с использованием aiohttp"
```

### Примеры генерации кода

```python
from openai import OpenAI

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

# Генерация кода для полного стека
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Вы эксперт-программист. Пишите чистый, готовый к production код с корректной обработкой ошибок и документацией."
        },
        {
            "role": "user",
            "content": """Напишите сервис на Python FastAPI, который:
1. Принимает POST /summarize с JSON-телом {"text": "...", "max_length": 150}
2. Использует локальный экземпляр Ollama для краткого изложения текста
3. Возвращает {"summary": "...", "original_length": N, "summary_length": N}
4. Включает корректную обработку ошибок, проверку входных данных с помощью Pydantic и поддержку async"""
        }
    ],
    temperature=0.1,  # Низкая температура для кода
    max_tokens=3000
)

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

````python
# Рецензирование и отладка кода
code_to_review = """
def find_duplicates(lst):
    seen = []
    duplicates = []
    for item in lst:
        if item in seen:
            duplicates.append(item)
        seen.append(item)
    return duplicates
"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "user",
            "content": f"Проверьте этот код на Python на предмет проблем с производительностью и предложите улучшения:\n\n```python\n{code_to_review}\n```"
        }
    ],
    temperature=0.3
)

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

## Qwen2.5-Coder

Оптимизирована для генерации кода:

```bash
# Использование vLLM
python -m vllm.entrypoints.openai.api_server \\
    --model Qwen/Qwen2.5-Coder-7B-Instruct \
    --host 0.0.0.0

# Использование Ollama
ollama run qwen2.5-coder:7b
```

```python
prompt = """Напишите функцию на Python, которая:
1. Принимает список чисел
2. Возвращает медианное значение
3. Корректно обрабатывает пустые списки
Добавьте аннотации типов и строки документации."""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2
)

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

## Qwen2.5-Math

Специализирована для математических рассуждений:

```bash
# Использование vLLM
python -m vllm.entrypoints.openai.api_server \\
    --model Qwen/Qwen2.5-Math-7B-Instruct \
    --host 0.0.0.0
```

```python
prompt = """Решите шаг за шагом:
Найдите все значения x, при которых: x^3 - 6x^2 + 11x - 6 = 0"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Math-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1
)

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

## Многоязычная поддержка

Qwen2.5 поддерживает 29 языков:

```python
# Китайский
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "用中文解释什么是人工智能"}]
)

# Японский
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "人工知能について日本語で説明してください"}]
)

# Корейский
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "인공지능에 대해 한국어로 설명해주세요"}]
)
```

## Длинный контекст (128K)

```python
# Чтение длинного документа
with open("long_document.txt", "r") as f:
    document = f.read()

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "user", "content": f"Кратко изложите этот документ:\n\n{document}"}
    ],
    max_tokens=2000
)
```

## Квантование

### GGUF с Ollama

```bash
# 4-битная квантизация
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:72b-instruct-q4_K_M   # 72B в 4 бита (~48 ГБ)

# 8-битная квантизованная
ollama pull qwen2.5:7b-instruct-q8_0

# Варианты Coder
ollama pull qwen2.5-coder:32b-instruct-q4_K_M
```

### AWQ с vLLM

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model Qwen/Qwen2.5-72B-Instruct-AWQ \
    --quantization awq \\
    --tensor-parallel-size 2
```

### GGUF с llama.cpp

```bash
# Загрузить GGUF
wget https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q4_k_m.gguf

# Запустить сервер
./llama-server -m qwen2.5-7b-instruct-q4_k_m.gguf \
    --host 0.0.0.0 \
    --port 8080 \\
    -ngl 35
```

## Настройка нескольких GPU

### Тензорный параллелизм

```bash
# 72B на 4 GPU
python -m vllm.entrypoints.openai.api_server \\
    --model Qwen/Qwen2.5-72B-Instruct \
    --tensor-parallel-size 4 \
    --max-model-len 32768

# 32B на 2 GPU
python -m vllm.entrypoints.openai.api_server \\
    --model Qwen/Qwen2.5-32B-Instruct \
    --tensor-parallel-size 2

# Coder-32B на 2 GPU
python -m vllm.entrypoints.openai.api_server \\
    --model Qwen/Qwen2.5-Coder-32B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 16384
```

## Производительность

### Пропускная способность (токенов/с)

| Модель            | RTX 3090 | RTX 4090 | A100 40 ГБ | A100 80 ГБ |
| ----------------- | -------- | -------- | ---------- | ---------- |
| Qwen2.5-0.5B      | 250      | 320      | 380        | 400        |
| Qwen2.5-3B        | 150      | 200      | 250        | 280        |
| Qwen2.5-7B        | 75       | 100      | 130        | 150        |
| Qwen2.5-7B Q4     | 110      | 140      | 180        | 200        |
| Qwen2.5-14B       | -        | 55       | 70         | 85         |
| Qwen2.5-32B       | -        | -        | 35         | 50         |
| Qwen2.5-72B       | -        | -        | 20 (2x)    | 40 (2x)    |
| Qwen2.5-72B Q4    | -        | -        | -          | 55 (2x)    |
| Qwen2.5-Coder-32B | -        | -        | 32         | 48         |

### Время до первого токена (TTFT)

| Модель | RTX 4090 | A100 40 ГБ  | A100 80 ГБ  |
| ------ | -------- | ----------- | ----------- |
| 7B     | 60 мс    | 40 мс       | 35 мс       |
| 14B    | 120 мс   | 80 мс       | 60 мс       |
| 32B    | -        | 200 мс      | 140 мс      |
| 72B    | -        | 400 мс (2x) | 280 мс (2x) |

### Длина контекста vs VRAM (7B)

| Контекст | FP16  | Q8    | Q4    |
| -------- | ----- | ----- | ----- |
| 8K       | 16GB  | 10 ГБ | 6 ГБ  |
| 32K      | 24 ГБ | 16GB  | 10 ГБ |
| 64K      | 40 ГБ | 26 ГБ | 16GB  |
| 128K     | 72 ГБ | 48 ГБ | 28 ГБ |

## Бенчмарки

| Модель            | MMLU  | HumanEval | GSM8K | MATH  | LiveCodeBench |
| ----------------- | ----- | --------- | ----- | ----- | ------------- |
| Qwen2.5-7B        | 74.2% | 75.6%     | 85.4% | 55.2% | 42.1%         |
| Qwen2.5-14B       | 79.7% | 81.1%     | 89.5% | 65.8% | 51.3%         |
| Qwen2.5-32B       | 83.3% | 84.2%     | 91.2% | 72.1% | 60.7%         |
| Qwen2.5-72B       | 86.1% | 86.2%     | 93.2% | 79.5% | 67.4%         |
| Qwen2.5-Coder-7B  | 72.8% | 88.4%     | 86.1% | 58.4% | 64.2%         |
| Qwen2.5-Coder-32B | 83.1% | **92.7%** | 92.3% | 76.8% | **78.5%**     |

## Docker Compose

```yaml
version: '3.8'

services:
  qwen:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    command: >
      --model Qwen/Qwen2.5-7B-Instruct
      --host 0.0.0.0
      --port 8000
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
```

## Оценка стоимости

Типичные расценки маркетплейса CLORE.AI:

| GPU           | Почасовая ставка | Лучше всего для           |
| ------------- | ---------------- | ------------------------- |
| RTX 3090 24GB | \~$0.06          | Модели 7B                 |
| RTX 4090 24GB | \~$0.10          | Модели 7B-14B             |
| A100 40 ГБ    | \~$0.17          | Модели 14B-32B            |
| A100 80 ГБ    | \~$0.25          | Модели 32B, Coder-32B     |
| 2x A100 80 ГБ | \~$0.50          | Модели 72B                |
| 4x A100 80GB  | \~$1.00          | Максимальный контекст 72B |

*Цены зависят от провайдера. Проверьте* [*маркетплейс CLORE.AI*](https://clore.ai/marketplace) *актуальные тарифы.*

**Сэкономьте деньги:**

* Используйте **Spot** рынок для гибких нагрузок
* Платите **CLORE** токенами
* Начните с меньших моделей (7B) для тестирования

## Устранение неполадок

### Недостаточно памяти

```bash
# Уменьшите контекст
--max-model-len 8192

# Включите оптимизацию памяти
--gpu-memory-utilization 0.85

# Используйте квантизованную модель
ollama pull qwen2.5:7b-instruct-q4_K_M
```

### Медленная генерация

```bash
# Включите flash attention
pip install flash-attn

# Используйте vLLM для большей пропускной способности
python -m vllm.entrypoints.openai.api_server \\
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-prefix-caching
```

### Отображение китайских символов

```python
# Убедитесь в кодировке UTF-8
import sys
sys.stdout.reconfigure(encoding='utf-8')
```

### Модель не найдена

```bash
# Проверьте имя модели
huggingface-cli search Qwen/Qwen2.5

# Частые названия:
# Qwen/Qwen2.5-7B-Instruct
# Qwen/Qwen2.5-72B-Instruct       ← Новое
# Qwen/Qwen2.5-Coder-7B-Instruct
# Qwen/Qwen2.5-Coder-32B-Instruct ← Новое
# Qwen/Qwen2.5-Math-7B-Instruct
```

## Qwen2.5 против других

| Функция        | Qwen2.5-7B | Qwen2.5-72B | Llama 3.1 70B | GPT-4o      |
| -------------- | ---------- | ----------- | ------------- | ----------- |
| Контекст       | 128K       | 128K        | 128K          | 128K        |
| Многоязычность | Отлично    | Отлично     | Хорошо        | Отлично     |
| Код            | Отлично    | Отлично     | Хорошо        | Отлично     |
| Математика     | Отлично    | Отлично     | Хорошо        | Отлично     |
| Китайский      | Отлично    | Отлично     | Плохо         | Хорошо      |
| Лицензия       | Apache 2.0 | Apache 2.0  | Llama 3.1     | Закрытый    |
| Стоимость      | Бесплатно  | Бесплатно   | Бесплатно     | Платный API |

**Используйте Qwen2.5, когда:**

* Требуется поддержка китайского языка
* Задачи по математике/коду в приоритете
* Требуется длинный контекст
* Нужна лицензия Apache 2.0
* Нужна лучшая открытая модель для кода (Coder-32B)

## Дальнейшие шаги

* [vLLM](/guides/guides_v2-ru/yazykovye-modeli/vllm.md) - Развёртывание в production
* [компонент](/guides/guides_v2-ru/yazykovye-modeli/ollama.md) - Простая локальная настройка
* [DeepSeek-V3](/guides/guides_v2-ru/yazykovye-modeli/deepseek-v3.md) - Более крупная модель для рассуждений
* [DeepSeek-R1](/guides/guides_v2-ru/yazykovye-modeli/deepseek-r1.md) - Открытая модель для рассуждений
* [Дообучение LLM](/guides/guides_v2-ru/obuchenie/finetune-llm.md) - Пользовательское обучение


---

# 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-ru/yazykovye-modeli/qwen25.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.