> 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-es/plataformas-y-agentes-de-ia/gpt4all.md).

# GPT4All LLM local

Despliega GPT4All en Clore.ai: ejecuta LLMs locales centrados en la privacidad con un servidor API compatible con OpenAI usando Docker, compatible con modelos GGUF y aceleración CUDA opcional para máximo rendimiento.

## Descripción general

[GPT4All](https://github.com/nomic-ai/gpt4all) de Nomic AI es uno de los proyectos locales de LLM de código abierto más populares, con más de **72.000 estrellas en GitHub**. Te permite ejecutar modelos de lenguaje grandes completamente sin conexión en tu propio hardware: no se requiere conexión a internet, no se envían datos a terceros.

GPT4All es mejor conocido por su pulida aplicación de escritorio, pero también incluye una **biblioteca de Python** (`gpt4all` paquete) y un **servidor API compatible con OpenAI** que se ejecuta en el puerto **4891**. En Clore.ai, puedes desplegar GPT4All en un contenedor Docker en una GPU alquilada, servirlo por HTTP y conectar cualquier cliente compatible con OpenAI.

> **Nota sobre Docker:** GPT4All no publica una imagen oficial de Docker para el componente del servidor. Esta guía usa una configuración Docker personalizada con el `gpt4all` paquete de Python. Para una alternativa de Docker más lista para producción que ejecute los **mismos archivos de modelo GGUF**, consulta la [sección alternativa de LocalAI](#alternative-localai-docker-image) — LocalAI es primero Docker y admite el mismo formato de modelo.

**Características principales:**

* 🔒 100% sin conexión — toda la inferencia se ejecuta localmente
* 🤖 API REST compatible con OpenAI (puerto 4891)
* 📚 LocalDocs — RAG sobre tus propios documentos
* 🧩 Admite todos los formatos de modelo GGUF populares
* 🐍 API completa de Python con `pip install gpt4all`
* 💬 Hermosa interfaz de escritorio (no relevante para el servidor, pero buena para pruebas locales)

***

## Requisitos

### Requisitos de hardware

| Nivel              | GPU           | VRAM  | RAM   | Almacenamiento | Precio de Clore.ai       |
| ------------------ | ------------- | ----- | ----- | -------------- | ------------------------ |
| **Solo CPU**       | Ninguno       | —     | 16 GB | SSD de 50 GB   | \~$0.02/h (servidor CPU) |
| **GPU de entrada** | RTX 3060 12GB | 12 GB | 16 GB | SSD de 50 GB   | $0.03–0.07/h             |
| **Recomendado**    | RTX 3090      | 24 GB | 32 GB | SSD de 100 GB  | $0.07–0.21/h             |
| **Gama alta**      | RTX 4090      | 24 GB | 64 GB | SSD de 200 GB  | $0.14–0.42/h             |

> **Nota:** El soporte GPU de GPT4All usa CUDA a través de llama.cpp internamente. A diferencia de vLLM, no **no** requiere una capacidad de cómputo CUDA específica: RTX 10xx y posteriores generalmente funcionan.

### Requisitos de VRAM del modelo (GGUF Q4\_K\_M)

| Modelo                | Tamaño en disco | VRAM    | GPU mínima  |
| --------------------- | --------------- | ------- | ----------- |
| Phi-3 Mini 3.8B       | \~2.4 GB        | \~3 GB  | RTX 3060    |
| Mistral 7B Instruct   | \~4.1 GB        | \~5 GB  | RTX 3060    |
| Llama 3.1 8B Instruct | \~4.7 GB        | \~6 GB  | RTX 3060    |
| Llama 3 70B Instruct  | \~40 GB         | \~45 GB | A100 80GB   |
| Mixtral 8x7B          | \~26 GB         | \~30 GB | 2× RTX 3090 |

***

## Inicio rápido

### Paso 1 — Alquila un servidor GPU en Clore.ai

1. Inicia sesión en [clore.ai](https://clore.ai)
2. Filtro: **Docker habilitado**, **GPU**: RTX 3090 (para modelos de 7B–13B)
3. Despliega con la imagen: `nvidia/cuda:12.8.1-runtime-ubuntu22.04`
4. Abrir puertos: **4891** (API de GPT4All), **22** (SSH)
5. Asigna al menos **50 GB** de espacio en disco

### Paso 2 — Conectarse vía SSH

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

# Verificar GPU
nvidia-smi
# Debería listar tu GPU con la versión del controlador
```

### Paso 3 — Construye la imagen Docker de GPT4All

Como no hay una imagen Docker oficial de GPT4All, construiremos una:

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

# Instala Python y dependencias del sistema
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/*

# Haz que python3.11 sea el predeterminado
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 \\
    && update-alternatives --install /usr/bin/python python python3.11 1

# Instala GPT4All con soporte CUDA
RUN pip install --upgrade pip && \
    pip install gpt4all>=2.8.0 fastapi uvicorn aiofiles pydantic

# Crea directorios
RUN mkdir -p /models /workspace /app

WORKDIR /app

# Copia el script del servidor (se montará o se integrará en la imagen)
COPY server.py .

EXPOSE 4891

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

### Paso 4 — Crea el script del servidor API

```bash
cat > /workspace/gpt4all-server/server.py << 'PYEOF'
#!/usr/bin/env python3
"""
Servidor API compatible con OpenAI de GPT4All
Se ejecuta en el puerto 4891 (predeterminado de 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

# Configuración
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="Servidor API GPT4All", version="1.0.0")

# Instancia global del modelo
model = None

def load_model():
    global model
    print(f"Cargando modelo: {MODEL_NAME}")
    print(f"Ruta del modelo: {MODEL_PATH}")
    print(f"Dispositivo: {DEVICE}")
    model = GPT4All(
        model_name=MODEL_NAME,
        model_path=MODEL_PATH,
        device=DEVICE,
        n_ctx=N_CTX,
        allow_download=True,  # Descarga desde GPT4All hub si no está presente
        verbose=True
    )
    ¡Modelo cargado correctamente!

# --- Modelos 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

# --- Rutas de la API ---

@app.get("/health")
async def health():
    return {"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="Modelo no cargado")

    # Formatea los mensajes en un solo prompt
    prompt_parts = []
    for msg in request.messages:
        if msg.role == "system":
            prompt_parts.append(f"### Sistema:\n{msg.content}")
        elif msg.role == "user":
            prompt_parts.append(f"### Humano:\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### Asistente:\n{msg.content}")
    prompt_parts.append("### Asistente:")
    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="Modelo no cargado")

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

### Paso 5 — Construir y ejecutar

```bash
cd /workspace/gpt4all-server

# Construye la imagen Docker
docker build -t gpt4all-server:latest .

# Descarga primero un modelo (opcional — el servidor también puede descargarlo automáticamente)
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

# Ejecuta con soporte 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

# Sigue los registros
docker logs -f gpt4all-server
```

### Paso 6 — Prueba la API

```bash
# Comprobación de salud
curl http://localhost:4891/health

# Lista modelos
curl http://localhost:4891/v1/models

# Finalización de chat
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": "¿Cuál es la capital de Francia?"}
    ],
    "temperature": 0.7,
    "max_tokens": 256
  }'
```

***

## Alternativa: imagen Docker de LocalAI

Para un despliegue Docker más robusto y listo para producción que ejecute los **mismos modelos GGUF** que GPT4All, LocalAI es la opción recomendada. Tiene una imagen Docker oficial, soporte CUDA y se mantiene activamente:

```bash
# Descarga LocalAI con soporte CUDA
docker pull localai/localai:latest-aio-gpu-nvidia-cuda-12

# Crea el directorio de modelos y descarga un modelo 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

# Crea la configuración del modelo
cat > /workspace/localai-models/mistral-7b.yaml << 'EOF'
nombre: mistral-7b
parámetros:
  modelo: mistral-7b.gguf
  temperatura: 0.7
  top_p: 0.95
  top_k: 40
  max_tokens: 2048
context_size: 4096
f16: true
gpu_layers: 35
threads: 8
EOF

# Ejecuta 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

# Prueba LocalAI (la misma API compatible con OpenAI)
curl http://localhost:8080/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

***

## Configuración

### Variables de entorno para el servidor GPT4All

| Variable     | Predeterminado           | Descripción                                           |
| ------------ | ------------------------ | ----------------------------------------------------- |
| `MODEL_NAME` | `mistral-7b-instruct...` | Nombre del archivo del modelo o nombre de GPT4All hub |
| `MODEL_PATH` | `/models`                | Directorio que contiene archivos de modelo            |
| `DEVICE`     | `gpu`                    | `gpu`, `cpu`, o `metal` (macOS)                       |
| `N_CTX`      | `4096`                   | Tamaño de la ventana de contexto (tokens)             |
| `API_HOST`   | `0.0.0.0`                | Dirección de enlace                                   |
| `API_PORT`   | `4891`                   | Puerto para el servidor API                           |

### Configuración con 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
```

***

## Aceleración GPU

### Verificación del uso de GPU

La biblioteca de Python GPT4All usa `llama.cpp` internamente con soporte CUDA:

```bash
# Comprueba el uso de VRAM de la GPU después de cargar el modelo
watch -n 2 nvidia-smi

# Comprueba dentro del contenedor que CUDA esté disponible
docker exec gpt4all-server python3 -c "
from gpt4all import GPT4All
devices = GPT4All.list_gpus()
print('GPUs disponibles:', devices)
"
```

### Selección de capas GPU

El `gpu_layers` (o `n_gpu_layers`) controla cuánto del modelo se ejecuta en la GPU frente a la CPU:

```python
# En server.py — fuerza todas las capas a la GPU
model = GPT4All(
    model_name=MODEL_NAME,
    model_path=MODEL_PATH,
    device="gpu",
    n_ctx=N_CTX,
    # Parámetros adicionales de llama.cpp pasados a través de:
    # n_gpu_layers=99  # Todas las capas en la GPU
)
```

```bash
# Reconstruye y reinicia con el máximo de capas 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
```

### Modo de respaldo de CPU

Si no hay ninguna GPU disponible (p. ej., servidor Clore.ai solo con CPU para pruebas):

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

> ⚠️ La inferencia en CPU es **10–50× más lenta** que en GPU. Para servidores solo con CPU, usa modelos pequeños (Phi-3 Mini, TinyLlama) y espera 2–5 tokens/seg.

***

## Consejos y mejores prácticas

### 📥 Predescarga de modelos

En lugar de depender de la descarga automática al iniciar, predescarga los modelos para reinicios más rápidos:

```bash
# Descarga modelos populares de GPT4All
mkdir -p /workspace/models

# Mistral 7B (el más popular, buena calidad)
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 (el más rápido, el más pequeño)
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 (la mejor calidad en el rango de 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/
```

### 🔌 Uso con aplicaciones Python

```python
# Uso directo de Python (sin la API de Docker)
from gpt4all import GPT4All

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

# Generación simple
with model.chat_session():
    response = model.generate("Explica la computación en GPU en términos simples", max_tokens=200)
    print(response)

# Usando el servidor API con un cliente OpenAI
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:4891/v1",
    api_key="no necesario"
)

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

### 💰 Optimización de costos en Clore.ai

```bash
# RTX 3090 @ $0.07–0.21/h — úsala para modelos de 7B (la mejor relación calidad-precio)
# Rendimiento esperado: ~40 tokens/seg para Mistral 7B Q4
# Costo por 1M tokens generados: ~$0.005 (extremadamente barato frente a OpenAI)

# RTX 4090 @ $0.14–0.42/h — úsala para modelos de 13B o cuando la velocidad importe
# Rendimiento esperado: ~60 tokens/seg para Mistral 7B Q4

# Para procesamiento por lotes: carga el modelo previamente, procesa todos los prompts y apaga
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'Procesados {len(results)} prompts')
"
```

***

## Solución de problemas

### El modelo no se carga — archivo no encontrado

```bash
# Verifica que el archivo del modelo exista y tenga el nombre correcto
ls -lh /workspace/models/
docker exec gpt4all-server ls /models/

# GPT4All distingue mayúsculas y minúsculas en los nombres de modelo
# Usa el nombre exacto del archivo de la salida de ls como 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
```

### Error de CUDA: no hay imagen de kernel para esta arquitectura

```bash
# Es posible que tu GPU no sea compatible con la versión de CUDA
# Comprueba la capacidad de cómputo de la GPU
nvidia-smi --query-gpu=compute_cap --format=csv,noheader

# Si es < 6.0, usa el modo 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
```

### La API devuelve 503 — el modelo no está cargado

```bash
# Revisa los registros de inicio
docker logs gpt4all-server | head -50

# La carga del modelo puede tardar entre 30 y 120 segundos
# Espera y vuelve a intentar:
sleep 60 && curl http://localhost:4891/health

# Comprueba si el archivo del modelo está corrupto
python3 -c "
from gpt4all import GPT4All
m = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/workspace/models')
print('Modelo OK:', m)
"
```

### El puerto 4891 no es accesible desde fuera

```bash
# Verifica el enlace del puerto
docker ps | grep 4891
# Debería mostrar: 0.0.0.0:4891->4891/tcp

# Comprueba si Clore.ai tiene reglas de firewall
# En la configuración del servidor de Clore.ai, asegúrate de que el puerto 4891 esté listado como abierto

# Prueba internamente:
curl http://127.0.0.1:4891/health

# Nota: Clore.ai asigna los puertos aleatoriamente — usa el puerto que se muestre en el panel de control de tu servidor
```

***

## Lecturas adicionales

* [GitHub de GPT4All](https://github.com/nomic-ai/gpt4all) — Repositorio principal
* [Documentación de GPT4All en Python](https://docs.gpt4all.io/) — Referencia de la API de Python
* [Explorador de modelos de GPT4All](https://gpt4all.io/models/gguf/) — Examina los modelos disponibles
* [Documentación de LocalAI](https://localai.io/) — Alternativa amigable con Docker
* [Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — Implementación de LLM en Docker más fácil
* [vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — Servidor de inferencia para producción
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — Elige la GPU adecuada de Clore.ai
* [TheBloke en HuggingFace](https://huggingface.co/TheBloke) — Miles de cuantizaciones GGUF
* [Formato GGUF explicado](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) — Documentación del formato del modelo

> 💡 **Recomendación:** Si quieres la implementación Docker más sencilla para LLM locales, considera [Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) en su lugar — tiene una imagen oficial de Docker, compatibilidad integrada con GPU y está diseñado específicamente para la implementación del lado del servidor. La fortaleza de GPT4All es su hermosa interfaz de escritorio y las funciones de LocalDocs (RAG), que no están disponibles en el modo servidor.


---

# 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-es/plataformas-y-agentes-de-ia/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.