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

# Qwen2.5

Führen Sie Alibabas Qwen2.5-Modellfamilie aus - leistungsstarke mehrsprachige LLMs mit hervorragenden Code- und Mathematikfähigkeiten auf CLORE.AI-GPUs.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Warum Qwen2.5?

* **Vielseitige Größen** - 0,5B bis 72B Parameter
* **Mehrsprachig** - 29 Sprachen einschließlich Chinesisch
* **Langer Kontext** - Bis zu 128K Token
* **Spezialisierte Varianten** - Coder-, Math-Editionen
* **Open Source** - Apache-2.0-Lizenz

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

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

**Ports:**

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

**Befehl:**

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

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zur **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B., `abc123.clorecloud.net`)

Verwenden Sie `https://IHRE_HTTP_PUB_URL` anstelle von `localhost` in den Beispielen unten.

### Überprüfen, ob es funktioniert

```bash
# Prüfen, ob der Dienst bereit ist
curl https://your-http-pub.clorecloud.net/health

# Verfügbare Modelle auflisten
curl https://your-http-pub.clorecloud.net/v1/models
```

{% hint style="warning" %}
Wenn Sie HTTP 502 erhalten, warten Sie 5–15 Minuten – das Modell wird noch von HuggingFace heruntergeladen.
{% endhint %}

## Qwen3 Reasoning-Modus

{% hint style="info" %}
**Neu in Qwen3:** Einige Qwen3-Modelle unterstützen einen Reasoning-Modus, der den Denkprozess des Modells in `<think>` Tags vor der endgültigen Antwort anzeigt.
{% endhint %}

Bei der Verwendung von Qwen3-Modellen über vLLM können Antworten Reasoning enthalten:

```json
{
  "content": "<think>\nLass mich Schritt für Schritt darüber nachdenken...\n</think>\n\nDie Antwort ist..."
}
```

Um Qwen3 mit Reasoning zu verwenden:

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

## Modellvarianten

### Basis-Modelle

| Modell               | Parameter | VRAM (FP16) | Kontext | Hinweise                      |
| -------------------- | --------- | ----------- | ------- | ----------------------------- |
| Qwen2.5-0.5B         | 0.5B      | 2GB         | 32K     | Edge/Tests                    |
| Qwen2.5-1.5B         | 1.5B      | 4GB         | 32K     | Sehr leicht                   |
| Qwen2.5-3B           | 3B        | 8GB         | 32K     | Budget                        |
| Qwen2.5-7B           | 7B        | 16GB        | 128K    | Ausgeglichen                  |
| Qwen2.5-14B          | 14B       | 32GB        | 128K    | Hohe Qualität                 |
| Qwen2.5-32B          | 32B       | 70GB        | 128K    | Sehr hohe Qualität            |
| Qwen2.5-72B          | 72B       | 150GB       | 128K    | **Beste Qualität**            |
| Qwen2.5-72B-Instruct | 72B       | 150GB       | 128K    | Chat-/Instruct-Feinabgestimmt |

### Spezialisierte Varianten

| Modell                     | Fokus      | Am besten geeignet für          | VRAM (FP16) |
| -------------------------- | ---------- | ------------------------------- | ----------- |
| Qwen2.5-Coder-7B-Instruct  | Code       | Programmierung, Debugging       | 16GB        |
| Qwen2.5-Coder-14B-Instruct | Code       | Komplexe Code-Aufgaben          | 32GB        |
| Qwen2.5-Coder-32B-Instruct | Code       | **Bestes Codemodell**           | 70GB        |
| Qwen2.5-Math-7B-Instruct   | Mathematik | Berechnungen, Beweise           | 16GB        |
| Qwen2.5-Math-72B-Instruct  | Mathematik | Mathematik auf Forschungsniveau | 150GB       |
| Qwen2.5-Instruct           | Chat       | Allgemeiner Assistent           | variiert    |

## Hardware-Anforderungen

| Modell    | Minimale GPU  | Empfohlen    | 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      |

## Installation

### Verwendung von vLLM (empfohlen)

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

### Verwendung von Ollama

```bash
# Standardmodelle
ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull qwen2.5:72b       # Neu: größtes Qwen2.5

# Spezialisiert
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:32b  # Neu: bestes Codemodell

# Chat ausführen
ollama run qwen2.5:7b
```

### Verwendung von 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": "Hallo!"}]
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-Nutzung

### OpenAI‑kompatible API

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="nicht benötigt"
)

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Erklären Sie maschinelles Lernen in einfachen Worten."}
    ],
    temperature=0.7,
    max_tokens=500
)

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

### Streaming

```python
stream = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Schreibe ein Gedicht über KI"}],
    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": "What is Python?"}
        ]
    }'
```

## Qwen2.5-72B-Instruct

Das Flaggschiff-Modell Qwen2.5 — das größte und leistungsfähigste der Familie. Es konkurriert in vielen Benchmarks mit GPT-4 und ist vollständig Open Source unter Apache 2.0.

### Ausführung über vLLM (Multi-GPU)

```bash
# 4x A100 80GB Setup
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 quantisiert — läuft auf 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
```

### Ausführung über Ollama

```bash
# Ziehen Sie das 72B-Modell (erfordert 48GB+ VRAM für Q4)
ollama pull qwen2.5:72b

# Interaktive Sitzung starten
ollama run qwen2.5:72b

# API-Zugriff
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:72b",
  "messages": [{"role": "user", "content": "Analysiere dieses komplexe Szenario..."}],
  "stream": false
}'
```

### Python-Beispiel

```python
from openai import OpenAI

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

# Das 72B-Modell eignet sich hervorragend für komplexe analytische Aufgaben
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Sie sind ein Experte für Analyse. Geben Sie detaillierte, nuancierte Antworten."
        },
        {
            "role": "user",
            "content": """Vergleichen Sie die architektonischen Unterschiede zwischen Transformer und 
            State-Space-Modellen (SSMs) für die Sequenzmodellierung. Schließen Sie Effizienzkompromisse ein."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

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

Das beste Open-Source-Codemodell, das verfügbar ist. Qwen2.5-Coder-32B-Instruct erreicht in vielen Coding-Benchmarks das Niveau von GPT-4o oder übertrifft es und unterstützt über 40 Programmiersprachen.

### Ausführung über vLLM

```bash
# Einzelne 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

# Duale RTX 4090 (24GB jeweils = 48GB insgesamt, Verwendung von Q4-Quantisierung)
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --quantization awq
```

### Ausführung über Ollama

```bash
# Ziehen Sie Coder-32B (erfordert ~22GB VRAM für Q4)
ollama pull qwen2.5-coder:32b

# Ausführen
ollama run qwen2.5-coder:32b

# Testen mit einer Coding-Aufforderung
ollama run qwen2.5-coder:32b "Schreibe einen asynchronen Python-Web-Scraper mit aiohttp"
```

### Beispiele zur Codegenerierung

```python
from openai import OpenAI

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

# Full-Stack-Codegenerierung
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Sie sind ein erfahrener Softwareingenieur. Schreiben Sie sauberen, produktionsreifen Code mit geeigneter Fehlerbehandlung und Dokumentation."
        },
        {
            "role": "user",
            "content": """Schreiben Sie einen Python-FastAPI-Dienst, der:
1. POST /summarize mit JSON-Body {"text": "...", "max_length": 150} akzeptiert
2. Eine lokale Ollama-Instanz verwendet, um den Text zusammenzufassen
3. {"summary": "...", "original_length": N, "summary_length": N} zurückgibt
4. Geeignete Fehlerbehandlung, Eingabevalidierung mit Pydantic und Async-Unterstützung enthält"""
        }
    ],
    temperature=0.1,  # Niedrige Temperatur für Code
    max_tokens=3000
)

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

````python
# Code-Review und Debugging
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"Überprüfen Sie diesen Python-Code auf Performance-Probleme und schlagen Sie Verbesserungen vor:\n\n```python\n{code_to_review}\n```"
        }
    ],
    temperature=0.3
)

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

## Qwen2.5-Coder

Optimiert für Codegenerierung:

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

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

```python
prompt = """Schreiben Sie eine Python-Funktion, die:
1. Eine Liste von Zahlen entgegennimmt
2. Den Medianwert zurückgibt
3. Leere Listen elegant behandelt
Fügen Sie Typannotationen und Docstrings hinzu."""

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

Spezialisiert für mathematisches Denken:

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

```python
prompt = """Lösen Sie Schritt für Schritt:
Finden Sie alle Werte von x, für die gilt: 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)
```

## Mehrsprachige Unterstützung

Qwen2.5 unterstützt 29 Sprachen:

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

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

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

## Langer Kontext (128K)

```python
# Lesen Sie ein langes Dokument
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"Fassen Sie dieses Dokument zusammen:\n\n{document}"}
    ],
    max_tokens=2000
)
```

## Quantisierung

### GGUF mit Ollama

```bash
# 4-Bit-quantisiert
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:72b-instruct-q4_K_M   # 72B in 4-Bit (~48GB)

# 8-Bit quantisiert
ollama pull qwen2.5:7b-instruct-q8_0

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

### AWQ mit vLLM

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

### GGUF mit llama.cpp

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

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

## Multi-GPU-Setup

### Tensor-Parallele Verarbeitung

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

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

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

## Leistung

### Durchsatz (Tokens/Sek)

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

### Zeit bis zum ersten Token (TTFT)

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

### Kontextlänge vs. VRAM (7B)

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

## Benchmarks

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

## Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

| GPU           | Stundensatz | Am besten geeignet für |
| ------------- | ----------- | ---------------------- |
| RTX 3090 24GB | \~$0.06     | 7B-Modelle             |
| RTX 4090 24GB | \~$0.10     | 7B-14B Modelle         |
| A100 40GB     | \~$0.17     | 14B-32B Modelle        |
| A100 80GB     | \~$0.25     | 32B-Modelle, Coder-32B |
| 2x A100 80GB  | \~$0.50     | 72B-Modelle            |
| 4x A100 80GB  | \~$1.00     | 72B maximaler Kontext  |

*Preise variieren je nach Anbieter. Prüfe* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Workloads
* Bezahlen mit **CLORE** Token
* Beginnen Sie mit kleineren Modellen (7B) zum Testen

## Fehlerbehebung

### Kein Speicher mehr

```bash
# Kontext reduzieren
--max-model-len 8192

# Aktivieren Sie Speicheroptimierung
--gpu-memory-utilization 0.85

# Verwenden Sie quantisiertes Modell
ollama pull qwen2.5:7b-instruct-q4_K_M
```

### Langsame Generierung

```bash
# Flash-Attention aktivieren
pip install flash-attn

# Verwenden Sie vLLM für besseren Durchsatz
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-prefix-caching
```

### Anzeige chinesischer Zeichen

```python
# Stellen Sie UTF-8-Codierung sicher
import sys
sys.stdout.reconfigure(encoding='utf-8')
```

### Modell nicht gefunden

```bash
# Überprüfen Sie den Modellnamen
huggingface-cli search Qwen/Qwen2.5

# Geläufige Namen:
# Qwen/Qwen2.5-7B-Instruct
# Qwen/Qwen2.5-72B-Instruct       ← Neu
# Qwen/Qwen2.5-Coder-7B-Instruct
# Qwen/Qwen2.5-Coder-32B-Instruct ← Neu
# Qwen/Qwen2.5-Math-7B-Instruct
```

## Qwen2.5 vs. Andere

| Funktion     | Qwen2.5-7B    | Qwen2.5-72B   | Llama 3.1 70B | GPT-4o        |
| ------------ | ------------- | ------------- | ------------- | ------------- |
| Kontext      | 128K          | 128K          | 128K          | 128K          |
| Mehrsprachig | Ausgezeichnet | Ausgezeichnet | Gut           | Ausgezeichnet |
| Code         | Ausgezeichnet | Ausgezeichnet | Gut           | Ausgezeichnet |
| Mathematik   | Ausgezeichnet | Ausgezeichnet | Gut           | Ausgezeichnet |
| Chinesisch   | Ausgezeichnet | Ausgezeichnet | Schlecht      | Gut           |
| Lizenz       | Apache 2.0    | Apache 2.0    | Llama 3.1     | Proprietär    |
| Kosten       | Kostenlos     | Kostenlos     | Kostenlos     | Bezahlte API  |

**Verwenden Sie Qwen2.5, wenn:**

* Unterstützung der chinesischen Sprache erforderlich ist
* Mathematik-/Code-Aufgaben Priorität haben
* Ein langer Kontext erforderlich ist
* Sie die Apache-2.0-Lizenz wünschen
* Sie das beste Open-Source-Codemodell benötigen (Coder-32B)

## Nächste Schritte

* [vLLM](/guides/guides_v2-de/sprachmodelle/vllm.md) - Produktionsbereitstellung
* [Ollama](/guides/guides_v2-de/sprachmodelle/ollama.md) - Einfache lokale Einrichtung
* [DeepSeek-V3](/guides/guides_v2-de/sprachmodelle/deepseek-v3.md) - Größeres Reasoning-Modell
* [DeepSeek-R1](/guides/guides_v2-de/sprachmodelle/deepseek-r1.md) - Open-Source-Reasoning-Modell
* [LLM feinabstimmen](/guides/guides_v2-de/training/finetune-llm.md) - Benutzerdefiniertes Training


---

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

```
GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/qwen25.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.