> 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ühre Alibabas Qwen2.5-Mehrsprach-LLMs auf Clore.ai-GPUs aus

Führe 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 gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

## Warum Qwen2.5?

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

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

## Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine `http_pub` URL in **Meine Bestellungen**:

1. Gehe zu **Meine Bestellungen** Seite
2. Klicke auf deine Bestellung
3. Finde die `http_pub` URL (z. B. `abc123.clorecloud.net`)

Verwende `https://YOUR_HTTP_PUB_URL` anstelle von `localhost` in den folgenden Beispielen.

### Prü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 du HTTP 502 erhältst, warte 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 das Schritt für Schritt durchdenken...\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      | 4 GB        | 32K     | Sehr leicht                 |
| Qwen2.5-3B           | 3B        | 8 GB        | 32K     | Budget                      |
| Qwen2.5-7B           | 7B        | 16 GB       | 128K    | Ausgewogen                  |
| Qwen2.5-14B          | 14B       | 32 GB       | 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    | Für Chat/Instruct optimiert |

### Spezialisierte Varianten

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

## Hardware-Anforderungen

{% hint style="warning" %}
**Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet.** Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als [Bare Metal](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst.
{% endhint %}

| Modell    | Minimale GPU   | Empfohlen     | VRAM (Q4) |
| --------- | -------------- | ------------- | --------- |
| 0,5B-3B   | RTX 3060 12 GB | RTX 3080      | 2-6GB     |
| 7B        | RTX 3090 24 GB | RTX 4090      | 6 GB      |
| 14B       | A100 40GB      | A100 80GB     | 12 GB     |
| 32B       | A100 80GB      | 2x A100 40 GB | 22 GB     |
| 72B       | 2x A100 80 GB  | 4x A100 80 GB | 48GB      |
| Coder-32B | A100 80GB      | 2x A100 40 GB | 22 GB     |

## Installation

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

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

# Chat starten
ollama run qwen2.5:7b
```

### Mit 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="not-needed"
)

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
        {"role": "user", "content": "Erkläre 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": "Was ist Python?"}
        ]
    }'
```

## Qwen2.5-72B-Instruct

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

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

```bash
# Einrichtung mit 4× 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-quantisiert — läuft auf 2× 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
# 72B-Modell herunterladen (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 glänzt bei komplexen analytischen Aufgaben
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Du bist ein Expertenanalyst. Gib detaillierte, nuancierte Antworten."
        },
        {
            "role": "user",
            "content": """Vergleiche die architektonischen Unterschiede zwischen Transformer- und 
            Zustandsraummodellen (SSMs) für die Sequenzmodellierung. Berücksichtige die Effizienzkompromisse."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

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

Das beste verfügbare Open-Source-Codemodell. Qwen2.5-Coder-32B-Instruct erreicht bei vielen Coding-Benchmarks 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

# Zwei RTX 4090 (24GB jeweils = 48GB gesamt, mit 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
# Coder-32B herunterladen (erfordert ca. 22GB VRAM für Q4)
ollama pull qwen2.5-coder:32b

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

# Mit einem Coding-Prompt testen
ollama run qwen2.5-coder:32b "Schreibe einen Python-Async-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": "Du bist ein Experte für Softwareentwicklung. Schreibe sauberen, produktionsreifen Code mit ordentlicher Fehlerbehandlung und Dokumentation."
        },
        {
            "role": "user",
            "content": """Schreibe 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. Ordentliche Fehlerbehandlung, Eingabevalidierung mit Pydantic und asynchrone 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üfe diesen Python-Code auf Leistungsprobleme und schlage 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
# Mit vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-7B-Instruct \
    --host 0.0.0.0

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

```python
prompt = """Schreibe eine Python-Funktion, die:
1. Eine Liste von Zahlen entgegennimmt
2. Den Medianwert zurückgibt
3. Leere Listen elegant behandelt
Typannotationen und Docstrings einschließen."""

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

Speziell für mathematisches Schlussfolgern:

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

```python
prompt = """Schritt für Schritt lösen:
Finde 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
# Ein langes Dokument lesen
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"Fasse 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-Einrichtung

### Tensor-Parallelismus

```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       | 35 ms      |
| 14B    | 120ms    | 80ms       | 60ms       |
| 32B    | -        | 200ms      | 140ms      |
| 72B    | -        | 400ms (2x) | 280ms (2x) |

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

| Kontext | FP16  | Q8    | Q4    |
| ------- | ----- | ----- | ----- |
| 8K      | 16 GB | 10 GB | 6 GB  |
| 32K     | 24 GB | 16 GB | 10 GB |
| 64K     | 40 GB | 26GB  | 16 GB |
| 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]
```

## Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

| GPU            | Stundensatz | Am besten geeignet für |
| -------------- | ----------- | ---------------------- |
| RTX 3090 24 GB | \~$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 80 GB  | \~$0.50     | 72B-Modelle            |
| 4x A100 80 GB  | \~$1.00     | 72B maximaler Kontext  |

*Preise variieren je nach Anbieter. Prüfen* [*CLORE.AI-Marktplatz*](https://clore.ai/marketplace) *für aktuelle Preise.*

**Geld sparen:**

* Verwende **Spot** Markt für flexible Workloads
* Bezahlen Sie mit **CLORE** Tokens
* Für Tests mit kleineren Modellen (7B) beginnen

## Fehlerbehebung

### Speicher erschöpft

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

# Speicheroptimierung aktivieren
--gpu-memory-utilization 0.85

# Quantisiertes Modell verwenden
ollama pull qwen2.5:7b-instruct-q4_K_M
```

### Langsame Generierung

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

# vLLM für höheren Durchsatz verwenden
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-prefix-caching
```

### Anzeige chinesischer Zeichen

```python
# UTF-8-Kodierung sicherstellen
import sys
sys.stdout.reconfigure(encoding='utf-8')
```

### Modell nicht gefunden

```bash
# Modellnamen prüfen
huggingface-cli search Qwen/Qwen2.5

# Gängige 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 im Vergleich zu anderen

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

**Qwen2.5 verwenden, wenn:**

* Unterstützung für die chinesische Sprache benötigt wird
* Mathe-/Code-Aufgaben Priorität haben
* Langer Kontext erforderlich ist
* Apache-2.0-Lizenz gewünscht
* Bestes Open-Source-Codemodell benötigt (Coder-32B)

## Nächste Schritte

* [vLLM](/guides/guides_v2-de/sprachmodelle/vllm.md) - Produktionseinsatz
* [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) - Anpassungstraining


---

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