> 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/platformy-i-agenty-ii/gpt4all.md).

# Локальная LLM GPT4All

Разверните GPT4All на Clore.ai — запускайте локальные LLM, ориентированные на приватность, с OpenAI-совместимым API-сервером на Docker, с поддержкой GGUF-моделей и опциональным ускорением CUDA для максимальной производительности.

## Обзор

[GPT4All](https://github.com/nomic-ai/gpt4all) от Nomic AI — один из самых популярных локальных проектов LLM с открытым исходным кодом, более чем **72 000 звёзд на GitHub**. Это позволяет запускать большие языковые модели полностью офлайн на собственном оборудовании — не требуется подключение к интернету, данные не отправляются третьим лицам.

GPT4All наиболее известен своим отточенным настольным приложением, но также включает **библиотеку Python** (`gpt4all` пакет) и встроенный **API-сервер, совместимый с OpenAI** работающий на порту **4891**. На Clore.ai вы можете развернуть GPT4All в Docker-контейнере на арендованном GPU, обслуживать его по HTTP и подключить к нему любой клиент, совместимый с OpenAI.

> **Примечание по Docker:** GPT4All не публикует официальный Docker-образ для серверного компонента. В этом руководстве используется настраиваемая Docker-конфигурация с `gpt4all` пакетом Python. Для более готовой к продакшену Docker-альтернативы, которая запускает **те же файлы моделей GGUF**, см. раздел [альтернативы LocalAI](#alternative-localai-docker-image) — LocalAI ориентирован на Docker и поддерживает тот же формат модели.

**Ключевые возможности:**

* 🔒 100% офлайн — всё выполнение инференса происходит локально
* 🤖 REST API, совместимый с OpenAI (порт 4891)
* 📚 LocalDocs — RAG по вашим собственным документам
* 🧩 Поддерживает все популярные форматы моделей GGUF
* 🐍 Полный Python API с `pip install gpt4all`
* 💬 Красивый десктопный интерфейс (не относится к серверу, но полезен для локального тестирования)

***

## Требования

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

| Тариф               | GPU           | VRAM  | ОЗУ   | Хранилище  | Цена Clore.ai            |
| ------------------- | ------------- | ----- | ----- | ---------- | ------------------------ |
| **только CPU**      | Нет           | —     | 16 ГБ | SSD 50 ГБ  | \~$0.02/час (сервер CPU) |
| **Базовый GPU**     | RTX 3060 12GB | 12 ГБ | 16 ГБ | SSD 50 ГБ  | $0.03–0.07/час           |
| **Рекомендуется**   | RTX 3090      | 24 ГБ | 32 ГБ | SSD 100 ГБ | $0.07–0.21/ч             |
| **Высокий уровень** | RTX 4090      | 24 ГБ | 64 ГБ | SSD 200 ГБ | $0.14–0.42/ч             |

> **Примечание:** Поддержка GPU в GPT4All использует CUDA через llama.cpp под капотом. В отличие от vLLM, она **не** не требует конкретной вычислительной способности CUDA — обычно подходят RTX 10xx и новее.

### Требования к VRAM для модели (GGUF Q4\_K\_M)

| Модель                | Размер на диске | VRAM    | Мин. GPU    |
| --------------------- | --------------- | ------- | ----------- |
| Phi-3 Mini 3.8B       | \~2,4 ГБ        | \~3 ГБ  | RTX 3060    |
| Mistral 7B Instruct   | \~4,1 ГБ        | \~5 ГБ  | RTX 3060    |
| Llama 3.1 8B Instruct | \~4,7 ГБ        | \~6 ГБ  | RTX 3060    |
| Llama 3 70B Instruct  | \~40 ГБ         | \~45 ГБ | A100 80 ГБ  |
| Mixtral 8x7B          | \~26 ГБ         | \~30 ГБ | 2× RTX 3090 |

***

## Быстрый старт

### Шаг 1 — Арендуйте GPU-сервер на Clore.ai

1. Войдите в [маркетплейсе clore.ai](https://clore.ai)
2. Фильтр: **Docker включён**, **GPU**: RTX 3090 (для моделей 7B–13B)
3. Разверните с образом: `nvidia/cuda:12.8.1-runtime-ubuntu22.04`
4. Откройте порты: **4891** (API GPT4All), **22** (SSH)
5. Выделите не менее **50 ГБ** дискового пространства

### Шаг 2 — Подключитесь по SSH

```bash
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Проверить GPU
nvidia-smi
# Должен отобразить ваш GPU с версией драйвера
```

### Шаг 3 — Соберите Docker-образ GPT4All

Поскольку официального Docker-образа GPT4All нет, мы соберём его сами:

```bash
mkdir -p /workspace/gpt4all-server && cd /workspace/gpt4all-server

cat > Dockerfile << 'EOF'
FROM nvidia/cuda:12.8.1-runtime-ubuntu22.04

ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Установите Python и системные зависимости
RUN apt-get update && apt-get install -y \\
    python3.11 \
    python3.11-dev \
    python3-pip \
    curl \\
    wget \\
    git \\
    libgomp1 \
    && rm -rf /var/lib/apt/lists/*

# Сделайте python3.11 версией по умолчанию
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 \
    && update-alternatives --install /usr/bin/python python python3.11 1

# Установите GPT4All с поддержкой CUDA
RUN pip install --upgrade pip && \\
    pip install gpt4all>=2.8.0 fastapi uvicorn aiofiles pydantic

# Создайте каталоги
RUN mkdir -p /models /workspace /app

WORKDIR /app

# Скопируйте серверный скрипт (он будет смонтирован или встроен в образ)
COPY server.py .

EXPOSE 4891

CMD ["python", "server.py"]
EOF
```

### Шаг 4 — Создайте скрипт API-сервера

```bash
cat > /workspace/gpt4all-server/server.py << 'PYEOF'
#!/usr/bin/env python3
"""
API-сервер GPT4All, совместимый с OpenAI
Работает на порту 4891 (по умолчанию для GPT4All)
"""

import os
import time
import json
import asyncio
from typing import Optional, List, Dict, Any
from pathlib import Path

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import uvicorn
from gpt4all import GPT4All

# Конфигурация
MODEL_NAME = os.environ.get("MODEL_NAME", "Mistral 7B Instruct v0.1 Q4_0")
MODEL_PATH = os.environ.get("MODEL_PATH", "/models")
API_HOST = os.environ.get("API_HOST", "0.0.0.0")
API_PORT = int(os.environ.get("API_PORT", "4891"))
DEVICE = os.environ.get("DEVICE", "gpu")  # 'gpu', 'cpu', 'metal'
N_CTX = int(os.environ.get("N_CTX", "4096"))

app = FastAPI(title="API-сервер GPT4All", version="1.0.0")

# Глобальный экземпляр модели
model = None

def load_model():
    global model
    print(f"Загрузка модели: {MODEL_NAME}")
    print(f"Путь к модели: {MODEL_PATH}")
    print(f"Устройство: {DEVICE}")
    model = GPT4All(
        model_name=MODEL_NAME,
        model_path=MODEL_PATH,
        device=DEVICE,
        n_ctx=N_CTX,
        allow_download=True,  # Загружает из хаба GPT4All, если отсутствует
        verbose=True
    )
    Модель успешно загружена!

# --- Модели Pydantic ---

class Message(BaseModel):
    role: str
    content: str

class ChatCompletionRequest(BaseModel):
    model: str
    messages: List[Message]
    temperature: float = 0.7
    max_tokens: int = 512
    top_p: float = 0.95
    top_k: int = 40
    stream: bool = False

class CompletionRequest(BaseModel):
    model: str
    prompt: str
    temperature: float = 0.7
    max_tokens: int = 512
    stream: bool = False

# --- Маршруты API ---

@app.get("/health")
async def health():
    {"status": "ok", "model": MODEL_NAME, "device": DEVICE}

@app.get("/v1/models")
async def list_models():
    return {
        "object": "list",
        "data": [{
            "id": MODEL_NAME,
            "object": "model",
            "created": int(time.time()),
            "owned_by": "gpt4all",
        }]
    }

@app.post("/v1/chat/completions")
async def chat_completions(request: ChatCompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Модель не загружена")

    # Форматируйте сообщения в единый промпт
    prompt_parts = []
    for msg in request.messages:
        if msg.role == "system":
            prompt_parts.append(f"### Система:\n{msg.content}")
        elif msg.role == "user":
            prompt_parts.append(f"### Пользователь:\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### Ассистент:\n{msg.content}")
    prompt_parts.append("### Ассистент:")
    full_prompt = "\n\n".join(prompt_parts)

    with model.chat_session():
        response_text = model.generate(
            full_prompt,
            max_tokens=request.max_tokens,
            temp=request.temperature,
            top_p=request.top_p,
            top_k=request.top_k,
        )

    return {
        "id": f"chatcmpl-{int(time.time())}",
        "object": "chat.completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "index": 0,
            "message": {"role": "assistant", "content": response_text},
            "finish_reason": "stop"
        }],
        "usage": {
            "prompt_tokens": len(full_prompt.split()),
            "completion_tokens": len(response_text.split()),
            "total_tokens": len(full_prompt.split()) + len(response_text.split())
        }
    }

@app.post("/v1/completions")
async def completions(request: CompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Модель не загружена")

    response_text = model.generate(
        request.prompt,
        max_tokens=request.max_tokens,
        temp=request.temperature,
    )

    return {
        "id": f"cmpl-{int(time.time())}",
        "object": "text_completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "text": response_text,
            "index": 0,
            "finish_reason": "stop"
        }]
    }

if __name__ == "__main__":
    load_model()
    uvicorn.run(app, host=API_HOST, port=API_PORT, log_level="info")
PYEOF
```

### Шаг 5 — Соберите и запустите

```bash
cd /workspace/gpt4all-server

# Соберите Docker-образ
docker build -t gpt4all-server:latest .

# Сначала загрузите модель (необязательно — сервер также может скачать её автоматически)
mkdir -p /workspace/models
wget -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \
  https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf

# Запустите с поддержкой GPU
docker run -d \
  --name gpt4all-server \
  --gpus all \
  --restart unless-stopped \
  -p 4891:4891 \
  -v /workspace/models:/models \
  -v /workspace/gpt4all-server/server.py:/app/server.py \
  -e MODEL_NAME="mistral-7b-instruct-v0.1.Q4_0.gguf" \
  -e MODEL_PATH="/models" \
  -e DEVICE="gpu" \
  -e N_CTX="4096" \
  gpt4all-server:latest

# Следите за логами
docker logs -f gpt4all-server
```

### Шаг 6 — Проверьте API

```bash
# Проверка состояния
curl http://localhost:4891/health

# Список моделей
curl http://localhost:4891/v1/models

# Завершение чата
curl http://localhost:4891/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-7b-instruct-v0.1.Q4_0.gguf",
    "messages": [
      {"role": "user", "content": "Какова столица Франции?"}
    ],
    "temperature": 0.7,
    "max_tokens": 256
  }'
```

***

## Альтернатива: Docker-образ LocalAI

Для более надёжного Docker-развертывания, готового к продакшену, которое запускает **те же модели GGUF** как GPT4All, рекомендуется LocalAI. У него есть официальный Docker-образ, поддержка CUDA и он активно поддерживается:

```bash
# Скачайте LocalAI с поддержкой CUDA
docker pull localai/localai:latest-aio-gpu-nvidia-cuda-12

# Создайте каталог моделей и загрузите модель GGUF
mkdir -p /workspace/localai-models
wget -O /workspace/localai-models/mistral-7b.gguf \\
  https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q4_K_M.gguf

# Создайте конфигурацию модели
cat > /workspace/localai-models/mistral-7b.yaml << 'EOF'
name: mistral-7b
parameters:
  model: mistral-7b.gguf
  temperature: 0.7
  top_p: 0.95
  top_k: 40
  max_tokens: 2048
context_size: 4096
f16: true
gpu_layers: 35
threads: 8
EOF

# Запустите LocalAI
docker run -d \
  --name localai \\
  --gpus all \
  --restart unless-stopped \
  -p 8080:8080 \
  -v /workspace/localai-models:/build/models \\
  -e DEBUG=true \\
  localai/localai:latest-aio-gpu-nvidia-cuda-12

# Проверьте LocalAI (тот же API, совместимый с OpenAI)
curl http://localhost:8080/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

***

## Конфигурация

### Переменные окружения для сервера GPT4All

| Переменная   | По умолчанию             | Описание                                |
| ------------ | ------------------------ | --------------------------------------- |
| `MODEL_NAME` | `mistral-7b-instruct...` | Имя файла модели или имя в хабе GPT4All |
| `MODEL_PATH` | `/models`                | Каталог, содержащий файлы модели        |
| `DEVICE`     | `gpu`                    | `gpu`, `cpu`, или `metal` (macOS)       |
| `N_CTX`      | `4096`                   | Размер контекстного окна (токены)       |
| `API_HOST`   | `0.0.0.0`                | Адрес привязки                          |
| `API_PORT`   | `4891`                   | Порт для API-сервера                    |

### Настройка Docker Compose

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

services:
  gpt4all-server:
    build: .
    container_name: gpt4all-server
    restart: unless-stopped
    ports:
      - "4891:4891"
    volumes:
      - /workspace/models:/models
      - ./server.py:/app/server.py
    environment:
      - MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf
      - MODEL_PATH=/models
      - DEVICE=gpu
      - N_CTX=4096
      - API_PORT=4891
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:4891/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 120s
```

```bash
docker compose up -d
docker compose logs -f
```

***

## Ускорение на GPU

### Проверка использования GPU

Библиотека Python GPT4All использует `llama.cpp` под капотом с поддержкой CUDA:

```bash
# Проверьте использование VRAM GPU после загрузки модели
watch -n 2 nvidia-smi

# Проверьте внутри контейнера, что CUDA доступна
docker exec gpt4all-server python3 -c "
from gpt4all import GPT4All
devices = GPT4All.list_gpus()
print('Доступные GPU:', devices)
"
```

### Выбор слоёв GPU

Параметр `gpu_layers` (или `n_gpu_layers`) определяет, какая часть модели выполняется на GPU, а какая — на CPU:

```python
# В server.py — принудительно отправить все слои на GPU
model = GPT4All(
    model_name=MODEL_NAME,
    model_path=MODEL_PATH,
    device="gpu",
    n_ctx=N_CTX,
    # Дополнительные параметры llama.cpp передаются дальше:
    # n_gpu_layers=99  # Все слои на GPU
)
```

```bash
# Пересоберите и перезапустите с максимальным числом слоёв GPU
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d \
  --name gpt4all-server \
  --gpus all \
  -p 4891:4891 \
  -v /workspace/models:/models \
  -e DEVICE=gpu \\
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \
  gpt4all-server:latest
```

### Режим резервного CPU

Если GPU недоступен (например, сервер Clore.ai только с CPU для тестирования):

```bash
docker run -d \
  --name gpt4all-server-cpu \
  -p 4891:4891 \
  -v /workspace/models:/models \
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest
```

> ⚠️ Инференс на CPU **в 10–50 раз медленнее** чем на GPU. Для серверов только с CPU используйте небольшие модели (Phi-3 Mini, TinyLlama) и ожидайте 2–5 токенов/с.

***

## Советы и лучшие практики

### 📥 Предварительная загрузка моделей

Вместо того чтобы полагаться на автоматическую загрузку при запуске, заранее скачайте модели для более быстрых перезапусков:

```bash
# Скачать популярные модели GPT4All
mkdir -p /workspace/models

# Mistral 7B (самая популярная, хорошее качество)
wget -q -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf"

# Phi-3 Mini (самая быстрая, самая маленькая)
wget -q -O /workspace/models/Phi-3-mini-4k-instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Phi-3-mini-4k-instruct.Q4_0.gguf"

# Llama 3 (лучшее качество в диапазоне 8B)
wget -q -O /workspace/models/Meta-Llama-3-8B-Instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Meta-Llama-3-8B-Instruct.Q4_0.gguf"

ls -lh /workspace/models/
```

### 🔌 Использование с Python-приложениями

```python
# Прямое использование Python (без Docker API)
from gpt4all import GPT4All

model = GPT4All(
    model_name="mistral-7b-instruct-v0.1.Q4_0.gguf",
    model_path="/workspace/models",
    device="gpu"
)

# Простая генерация
with model.chat_session():
    response = model.generate("Объясните вычисления на GPU простыми словами", max_tokens=200)
    print(response)

# Использование API-сервера с клиентом OpenAI
from openai import OpenAI

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

completion = client.chat.completions.create(
    model="mistral-7b-instruct-v0.1.Q4_0.gguf",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(completion.choices[0].message.content)
```

### 💰 Оптимизация затрат на Clore.ai

```bash
# RTX 3090 за $0.07–0.21/ч — используйте для моделей 7B (лучшее соотношение цены и качества)
# Ожидаемая производительность: ~40 токенов/с для Mistral 7B Q4
# Стоимость за 1 млн сгенерированных токенов: ~$0.005 (крайне дёшево по сравнению с OpenAI)

# RTX 4090 за $0.14–0.42/ч — используйте для моделей 13B или когда важна скорость
# Ожидаемая производительность: ~60 токенов/с для Mistral 7B Q4

# Для пакетной обработки: предварительно загрузите модель, обработайте все запросы, завершите работу
docker run --rm \
  --gpus all \
  -v /workspace/models:/models \
  -v /workspace/prompts:/prompts \
  gpt4all-server:latest \
  python3 -c "
from gpt4all import GPT4All
import json

model = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/models', device='gpu')
prompts = open('/prompts/batch.txt').readlines()
results = []
for p in prompts:
    with model.chat_session():
        results.append(model.generate(p.strip(), max_tokens=256))
json.dump(results, open('/prompts/results.json', 'w'))
print(f'Обработано {len(results)} запросов')
"
```

***

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

### Модель не загружается — файл не найден

```bash
# Проверьте, что файл модели существует и имеет правильное имя
ls -lh /workspace/models/
docker exec gpt4all-server ls /models/

# GPT4All чувствителен к регистру в именах моделей
# Используйте точное имя файла из вывода ls как MODEL_NAME
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \
  gpt4all-server:latest
```

### Ошибка CUDA: нет образа ядра для этой архитектуры

```bash
# Ваш GPU может быть несовместим с версией CUDA
# Проверьте вычислительные возможности GPU
nvidia-smi --query-gpu=compute_cap --format=csv,noheader

# Если < 6.0, используйте режим CPU
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest
```

### API возвращает 503 — модель не загружена

```bash
# Проверьте журналы запуска
docker logs gpt4all-server | head -50

# Загрузка модели может занять 30–120 секунд
# Подождите и повторите:
sleep 60 && curl http://localhost:4891/health

# Проверьте, не повреждён ли файл модели
python3 -c "
from gpt4all import GPT4All
m = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/workspace/models')
print('Модель в порядке:', m)
"
```

### Порт 4891 недоступен извне

```bash
# Проверьте привязку порта
docker ps | grep 4891
# Должно показывать: 0.0.0.0:4891->4891/tcp

# Проверьте, есть ли у Clore.ai правила файрвола
# В настройках сервера Clore.ai убедитесь, что порт 4891 указан как открытый

# Проверьте локально:
curl http://127.0.0.1:4891/health

# Примечание: Clore.ai сопоставляет порты случайным образом — используйте порт, указанный в панели вашего сервера
```

***

## Дополнительное чтение

* [GPT4All на GitHub](https://github.com/nomic-ai/gpt4all) — Основной репозиторий
* [Документация GPT4All Python](https://docs.gpt4all.io/) — Справочник по Python API
* [Обозреватель моделей GPT4All](https://gpt4all.io/models/gguf/) — Просмотреть доступные модели
* [Документация LocalAI](https://localai.io/) — Альтернатива, удобная для Docker
* [Ollama на Clore.ai](/guides/guides_v2-ru/yazykovye-modeli/ollama.md) — Более простое развёртывание LLM в Docker
* [vLLM на Clore.ai](/guides/guides_v2-ru/yazykovye-modeli/vllm.md) — Сервер инференса для продакшена
* [Руководство по сравнению GPU](/guides/guides_v2-ru/nachalo-raboty/gpu-comparison.md) — Выберите подходящий GPU на Clore.ai
* [TheBloke на HuggingFace](https://huggingface.co/TheBloke) — Тысячи квантований GGUF
* [Формат GGUF: объяснение](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) — Документация по формату моделей

> 💡 **Рекомендация:** Если вам нужно самое простое развёртывание локальных LLM в Docker, рассмотрите [компонент](/guides/guides_v2-ru/yazykovye-modeli/ollama.md) вместо него — у него есть официальный Docker-образ, встроенная поддержка GPU, и он специально создан для серверного развёртывания. Сильная сторона GPT4All — его красивый настольный интерфейс и функции LocalDocs (RAG), которые недоступны в серверном режиме.


---

# 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/platformy-i-agenty-ii/gpt4all.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.