> 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/modelos-de-lenguaje/qwen25.md).

# Qwen2.5

Ejecuta los LLMs multilingües Qwen2.5 de Alibaba en GPUs de Clore.ai

Ejecuta la familia de modelos Qwen2.5 de Alibaba: potentes LLM multilingües con excelentes capacidades de código y matemáticas en las GPU de CLORE.AI.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## ¿Por qué Qwen2.5?

* **Tamaños versátiles** - De 0.5B a 72B parámetros
* **Multilingüe** - 29 idiomas, incluido el chino
* **Contexto largo** - Hasta 128K tokens
* **Variantes especializadas** - Ediciones Coder y Math
* **Código abierto** - Licencia Apache 2.0

## Despliegue rápido en CLORE.AI

**Imagen de Docker:**

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

**Puertos:**

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

**Comando:**

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

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis pedidos**:

1. Ve a **Mis pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (p. ej., `abc123.clorecloud.net`)

Usa `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos a continuación.

### Verifica que funciona

```bash
# Comprueba si el servicio está listo
curl https://your-http-pub.clorecloud.net/health

# Lista los modelos disponibles
curl https://your-http-pub.clorecloud.net/v1/models
```

{% hint style="warning" %}
Si obtienes HTTP 502, espera de 5 a 15 minutos: el modelo todavía se está descargando desde HuggingFace.
{% endhint %}

## Modo de razonamiento de Qwen3

{% hint style="info" %}
**Nuevo en Qwen3:** Algunos modelos Qwen3 admiten un modo de razonamiento que muestra el proceso de pensamiento del modelo en `<think>` etiquetas antes de la respuesta final.
{% endhint %}

Al usar modelos Qwen3 mediante vLLM, las respuestas pueden incluir razonamiento:

```json
{
  "content": "<think>\nDéjame pensar en esto paso a paso...\n</think>\n\nLa respuesta es..."
}
```

Para usar Qwen3 con razonamiento:

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

## Variantes del modelo

### Modelos base

| Modelo               | Parámetros | VRAM (FP16) | Contexto | Notas                            |
| -------------------- | ---------- | ----------- | -------- | -------------------------------- |
| Qwen2.5-0.5B         | 0.5B       | 2 GB        | 32K      | Borde/pruebas                    |
| Qwen2.5-1.5B         | 1.5B       | 4GB         | 32K      | Muy ligero                       |
| Qwen2.5-3B           | 3B         | 8GB         | 32K      | Económico                        |
| Qwen2.5-7B           | 7B         | 16GB        | 128K     | Equilibrado                      |
| Qwen2.5-14B          | 14B        | 32GB        | 128K     | Alta calidad                     |
| Qwen2.5-32B          | 32B        | 70GB        | 128K     | Calidad muy alta                 |
| Qwen2.5-72B          | 72B        | 150GB       | 128K     | **Mejor calidad**                |
| Qwen2.5-72B-Instruct | 72B        | 150GB       | 128K     | Ajustado para chat/instrucciones |

### Variantes especializadas

| Modelo                     | Enfoque     | Ideal para                            | VRAM (FP16) |
| -------------------------- | ----------- | ------------------------------------- | ----------- |
| Qwen2.5-Coder-7B-Instruct  | Código      | Programación, depuración              | 16GB        |
| Qwen2.5-Coder-14B-Instruct | Código      | Tareas de código complejas            | 32GB        |
| Qwen2.5-Coder-32B-Instruct | Código      | **El mejor modelo de código**         | 70GB        |
| Qwen2.5-Math-7B-Instruct   | Matemáticas | Cálculos, demostraciones              | 16GB        |
| Qwen2.5-Math-72B-Instruct  | Matemáticas | Matemáticas de nivel de investigación | 150GB       |
| Qwen2.5-Instruct           | Chat        | Asistente general                     | varía       |

## Requisitos de hardware

{% hint style="warning" %}
**Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai.** Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como [bare metal](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

| Modelo    | GPU mínima    | Recomendado  | VRAM (Q4) |
| --------- | ------------- | ------------ | --------- |
| 0.5B-3B   | RTX 3060 12GB | RTX 3080     | 2-6GB     |
| 7B        | RTX 3090 24GB | RTX 4090     | 6GB       |
| 14B       | A100 40GB     | A100 80GB    | 12GB      |
| 32B       | A100 80GB     | 2x A100 40GB | 22GB      |
| 72B       | 2x A100 80GB  | 4x A100 80GB | 48GB      |
| Coder-32B | A100 80GB     | 2x A100 40GB | 22GB      |

## Instalación

### Usando vLLM (recomendado)

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

### Usando Ollama

```bash
# Modelos estándar
ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull qwen2.5:72b       # Nuevo: el Qwen2.5 más grande

# Especializados
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:32b  # Nuevo: el mejor modelo de código

# Iniciar chat
ollama run qwen2.5:7b
```

### Usando 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": "¡Hola!"}]
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))
```

## Uso de la API

### API compatible con OpenAI

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "Eres un asistente útil."},
        {"role": "user", "content": "Explica el aprendizaje automático en términos simples."}
    ],
    temperature=0.7,
    max_tokens=500
)

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

### Transmisión

```python
stream = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Escribe un poema sobre la IA"}],
    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": "¿Qué es Python?"}
        ]
    }'
```

## Qwen2.5-72B-Instruct

El modelo insignia de Qwen2.5: el más grande y capaz de la familia. Compite con GPT-4 en muchos benchmarks y es completamente de código abierto bajo Apache 2.0.

### Ejecutando mediante vLLM (multigPU)

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

# Cuantizado con AWQ: funciona en 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
```

### Ejecutando mediante Ollama

```bash
# Descargar el modelo 72B (requiere más de 48GB de VRAM para Q4)
ollama pull qwen2.5:72b

# Iniciar sesión interactiva
ollama run qwen2.5:72b

# Acceso a la API
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:72b",
  "messages": [{"role": "user", "content": "Analiza este escenario complejo..."}],
  "stream": false
}'
```

### Ejemplo en Python

```python
from openai import OpenAI

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

# El modelo 72B sobresale en tareas analíticas complejas
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Eres un analista experto. Proporciona respuestas detalladas y matizadas."
        },
        {
            "role": "user",
            "content": """Compara las diferencias arquitectónicas entre transformer y 
            modelos de espacio de estados (SSM) para el modelado de secuencias. Incluye compensaciones de eficiencia."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

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

El mejor modelo de código de código abierto disponible. Qwen2.5-Coder-32B-Instruct iguala o supera a GPT-4o en muchos benchmarks de programación y es compatible con más de 40 lenguajes de programación.

### Ejecutando mediante vLLM

```bash
# Un solo 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

# Doble RTX 4090 (24GB cada una = 48GB en total, usando cuantización Q4)
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct-AWQ \
    --host 0.0.0.0 \\
    --port 8000 \\
    --tensor-parallel-size 2 \\
    --quantization awq
```

### Ejecutando mediante Ollama

```bash
# Descargar Coder-32B (requiere ~22GB de VRAM para Q4)
ollama pull qwen2.5-coder:32b

# Ejecutar
ollama run qwen2.5-coder:32b

# Probar con una instrucción de programación
ollama run qwen2.5-coder:32b "Escribe un rastreador web asíncrono en Python usando aiohttp"
```

### Ejemplos de generación de código

```python
from openai import OpenAI

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

# Generación de código full-stack
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Eres un ingeniero de software experto. Escribe código limpio, listo para producción, con el manejo de errores y la documentación adecuados."
        },
        {
            "role": "user",
            "content": """Escribe un servicio FastAPI en Python que:
1. Acepte POST /summarize con cuerpo JSON {"text": "...", "max_length": 150}
2. Use una instancia local de Ollama para resumir el texto
3. Devuelva {"summary": "...", "original_length": N, "summary_length": N}
4. Incluya un manejo de errores adecuado, validación de entrada con Pydantic y soporte asíncrono"""
        }
    ],
    temperature=0.1,  # Baja temperatura para código
    max_tokens=3000
)

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

````python
# Revisión de código y depuración
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"Revisa este código Python en busca de problemas de rendimiento y sugiere mejoras:\n\n```python\n{code_to_review}\n```"
        }
    ],
    temperature=0.3
)

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

## Qwen2.5-Coder

Optimizado para la generación de código:

```bash
# Usando vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-7B-Instruct \
    --host 0.0.0.0

# Usando Ollama
ollama run qwen2.5-coder:7b
```

```python
prompt = """Escribe una función de Python que:
1. Tome una lista de números
2. Devuelva el valor mediano
3. Maneje listas vacías con elegancia
Incluye anotaciones de tipo y docstrings."""

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

Especializado en razonamiento matemático:

```bash
# Usando vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Math-7B-Instruct \
    --host 0.0.0.0
```

```python
prompt = """Resuelve paso a paso:
Encuentra todos los valores de x donde: 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)
```

## Compatibilidad multilingüe

Qwen2.5 admite 29 idiomas:

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

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

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

## Contexto largo (128K)

```python
# Leer un documento largo
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"Resume este documento:\n\n{document}"}
    ],
    max_tokens=2000
)
```

## Cuantización

### GGUF con Ollama

```bash
# Cuantizado a 4 bits
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:72b-instruct-q4_K_M   # 72B en 4 bits (~48GB)

# Cuantizado a 8 bits
ollama pull qwen2.5:7b-instruct-q8_0

# Variantes Coder
ollama pull qwen2.5-coder:32b-instruct-q4_K_M
```

### AWQ con vLLM

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

### GGUF con llama.cpp

```bash
# Descargar GGUF
wget https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q4_k_m.gguf

# Ejecutar servidor
./llama-server -m qwen2.5-7b-instruct-q4_k_m.gguf \
    --host 0.0.0.0 \\
    --port 8080 \\
    -ngl 35
```

## Configuración multi-GPU

### Paralelismo tensorial

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

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

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

## Rendimiento

### Rendimiento (tokens/seg)

| Modelo            | RTX 3090 | RTX 4090 | A100 40GB | A100 80GB |
| ----------------- | -------- | -------- | --------- | --------- |
| 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        |

### Tiempo hasta el primer token (TTFT)

| Modelo | RTX 4090 | A100 40GB   | A100 80GB   |
| ------ | -------- | ----------- | ----------- |
| 7B     | 60 ms    | 40 ms       | 35 ms       |
| 14B    | 120 ms   | 80ms        | 60 ms       |
| 32B    | -        | 200 ms      | 140 ms      |
| 72B    | -        | 400 ms (2x) | 280 ms (2x) |

### Longitud de contexto vs VRAM (7B)

| Contexto | FP16  | Q8   | Q4   |
| -------- | ----- | ---- | ---- |
| 8K       | 16GB  | 10GB | 6GB  |
| 32K      | 24GB  | 16GB | 10GB |
| 64K      | 40 GB | 26GB | 16GB |
| 128K     | 72GB  | 48GB | 28GB |

## Pruebas comparativas

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

## Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

| GPU           | Tarifa por hora | Ideal para             |
| ------------- | --------------- | ---------------------- |
| RTX 3090 24GB | \~$0.06         | modelos 7B             |
| RTX 4090 24GB | \~$0.10         | modelos 7B-14B         |
| A100 40GB     | \~$0.17         | modelos 14B-32B        |
| A100 80GB     | \~$0.25         | modelos 32B, Coder-32B |
| 2x A100 80GB  | \~$0.50         | modelos 72B            |
| 4x A100 80GB  | \~$1.00         | contexto máximo de 72B |

*Los precios varían según el proveedor. Consulta* [*Marketplace de CLORE.AI*](https://clore.ai/marketplace) *las tarifas actuales.*

**Ahorra dinero:**

* Usa **Spot** el mercado para cargas de trabajo flexibles
* Paga con **CLORE** tokens
* Empieza con modelos más pequeños (7B) para probar

## Solución de problemas

### Sin memoria

```bash
# Reducir el contexto
--max-model-len 8192

# Habilitar optimización de memoria
--gpu-memory-utilization 0.85

# Usar modelo cuantizado
ollama pull qwen2.5:7b-instruct-q4_K_M
```

### Generación lenta

```bash
# Habilitar flash attention
pip install flash-attn

# Usar vLLM para un mejor rendimiento
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-prefix-caching
```

### Visualización de caracteres chinos

```python
# Asegurar codificación UTF-8
import sys
sys.stdout.reconfigure(encoding='utf-8')
```

### Modelo no encontrado

```bash
# Comprobar el nombre del modelo
huggingface-cli search Qwen/Qwen2.5

# Nombres comunes:
# Qwen/Qwen2.5-7B-Instruct
# Qwen/Qwen2.5-72B-Instruct       ← Nuevo
# Qwen/Qwen2.5-Coder-7B-Instruct
# Qwen/Qwen2.5-Coder-32B-Instruct ← Nuevo
# Qwen/Qwen2.5-Math-7B-Instruct
```

## Qwen2.5 frente a otros

| Función     | Qwen2.5-7B | Qwen2.5-72B | Llama 3.1 70B | GPT-4o      |
| ----------- | ---------- | ----------- | ------------- | ----------- |
| Contexto    | 128K       | 128K        | 128K          | 128K        |
| Multilingüe | Excelente  | Excelente   | Bueno         | Excelente   |
| Código      | Excelente  | Excelente   | Bueno         | Excelente   |
| Matemáticas | Excelente  | Excelente   | Bueno         | Excelente   |
| Chino       | Excelente  | Excelente   | Mala          | Bueno       |
| Licencia    | Apache 2.0 | Apache 2.0  | Llama 3.1     | Propietario |
| Costo       | Gratis     | Gratis      | Gratis        | API de pago |

**Usa Qwen2.5 cuando:**

* Se necesita compatibilidad con el idioma chino
* Las tareas de matemáticas/código son prioritarias
* Se requiere contexto largo
* Quieres la licencia Apache 2.0
* Necesitas el mejor modelo de código de código abierto (Coder-32B)

## Siguientes pasos

* [vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) - Despliegue en producción
* [Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) - Configuración local sencilla
* [DeepSeek-V3](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3.md) - Modelo de razonamiento más grande
* [DeepSeek-R1](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1.md) - Modelo de razonamiento de código abierto
* [Ajustar LLM](/guides/guides_v2-es/entrenamiento/finetune-llm.md) - Entrenamiento personalizado


---

# 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/modelos-de-lenguaje/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.