> 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/videogenerierung/wan-video.md).

# Wan2.1 Video

Generiere Videos mit Alibabas Wan2.1-Modell auf Clore.ai-GPUs

Erstellen Sie hochwertige Videos mit Alibabas Wan2.1-Text-zu-Video- und Bild-zu-Video-Modellen 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 Wan2.1?

* **Hohe Qualität** - Videogenerierung auf dem neuesten Stand der Technik
* **Mehrere Modi** - Text-zu-Video, Bild-zu-Video
* **Verschiedene Größen** - 1,3B bis 14B Parameter
* **Lange Videos** - Bis zu 81 Frames
* **Offene Gewichte** - Apache-2.0-Lizenz

## Modellvarianten

| Modell          | Parameter | VRAM  | Auflösung | Frames |
| --------------- | --------- | ----- | --------- | ------ |
| Wan2.1-T2V-1.3B | 1.3B      | 8 GB  | 480p      | 81     |
| Wan2.1-T2V-14B  | 14B       | 24 GB | 720p      | 81     |
| Wan2.1-I2V-14B  | 14B       | 24 GB | 720p      | 81     |

## Schnellbereitstellung auf CLORE.AI

**Docker-Image:**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Ports:**

```
22/tcp
7860/http
```

**Befehl:**

```bash
pip install diffusers transformers accelerate gradio && \
python -c "
import gradio as gr
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained('alibaba-pai/Wan2.1-T2V-1.3B', torch_dtype=torch.float16)
pipe.to('cuda')
pipe.enable_model_cpu_offload()

def generate(prompt, steps, frames, seed):
    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None
    output = pipe(prompt, num_frames=frames, num_inference_steps=steps, generator=generator)
    export_to_video(output.frames[0], 'output.mp4', fps=16)
    return 'output.mp4'

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Eingabeaufforderung'),
        gr.Slider(20, 100, value=50, label='Schritte'),
        gr.Slider(16, 81, value=49, step=8, label='Frames'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Video(),
    title='Wan2.1 - Text zu Video'
).launch(server_name='0.0.0.0', server_port=7860)
"
```

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

## Hardware-Anforderungen

| Modell   | Minimale GPU  | Empfohlen      | Optimal   |
| -------- | ------------- | -------------- | --------- |
| 1.3B T2V | RTX 3070 8GB  | RTX 3090 24 GB | RTX 4090  |
| 14B T2V  | RTX 4090 24GB | A100 40GB      | A100 80GB |
| 14B I2V  | RTX 4090 24GB | A100 40GB      | A100 80GB |

## Installation

```bash
pip install diffusers transformers accelerate torch
```

## Text-zu-Video

### Grundlegende Nutzung (1.3B)

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-1.3B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = "Eine Katze spielt mit einem Ball in einem sonnigen Garten"

output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "cat_video.mp4", fps=16)
```

### Hohe Qualität (14B)

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

prompt = "Kinematische Aufnahme eines Drachen, der bei Sonnenuntergang über Berge fliegt, 4K, detailreich"

output = pipe(
    prompt=prompt,
    negative_prompt="unscharf, niedrige Qualität, verzerrt",
    num_frames=81,
    height=720,
    width=1280,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "dragon.mp4", fps=24)
```

## Bild-zu-Video

### Animiere ein Bild

```python
import torch
from diffusers import WanI2VPipeline
from diffusers.utils import load_image, export_to_video

pipe = WanI2VPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-I2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Eingabebild laden
image = load_image("input.jpg")

prompt = "Die Person im Bild beginnt, nach vorne zu gehen"

output = pipe(
    prompt=prompt,
    image=image,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "animated.mp4", fps=16)
```

## Bild-zu-Video mit Wan2.1-I2V-14B

{% hint style="info" %}
Wan2.1-I2V-14B animiert ein statisches Bild mithilfe eines Text-Prompts zur Steuerung der Bewegung. Erfordert **24 GB VRAM** (RTX 4090 oder A100 40GB empfohlen).
{% endhint %}

### Modelldetails

| Eigenschaft         | Wert                                |
| ------------------- | ----------------------------------- |
| Modell-ID           | `Wan-AI/Wan2.1-I2V-14B-480P`        |
| Parameter           | 14 Milliarden                       |
| Erforderlicher VRAM | **24 GB**                           |
| Maximale Auflösung  | 480p (854×480) oder 720p (1280×720) |
| Max. Frames         | 81                                  |
| Lizenz              | Apache 2.0                          |

### Hardware-Anforderungen

| GPU       | VRAM  | Status           |
| --------- | ----- | ---------------- |
| RTX 4090  | 24 GB | ✅ Empfohlen      |
| RTX 3090  | 24 GB | ✅ Unterstützt    |
| A100 40GB | 40 GB | ✅ Optimal        |
| A100 80GB | 80 GB | ✅ Beste Qualität |
| RTX 3080  | 10 GB | ❌ Unzureichend   |

### Schnelles CLI-Skript

Speichern unter `generate_i2v.py` und ausführen:

```bash
python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P --image input.jpg --prompt "Die Kamera zoomt langsam heraus"
```

### generate\_i2v.py — Vollständiges Skript

```python
#!/usr/bin/env python3
"""
Wan2.1-Bild-zu-Video-CLI-Skript.
Verwendung: python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P \
           --image input.jpg --prompt "Die Kamera zoomt langsam heraus"
"""

import argparse
import os
import sys
import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image


def parse_args():
    parser = argparse.ArgumentParser(description="Wan2.1-Bild-zu-Video-Generator")
    parser.add_argument(
        "--model",
        type=str,
        default="Wan-AI/Wan2.1-I2V-14B-480P",
        help="Modell-ID von Hugging Face (Standard: Wan-AI/Wan2.1-I2V-14B-480P)",
    )
    parser.add_argument(
        "--image",
        type=str,
        required=True,
        help="Pfad zum Eingabebild (JPEG oder PNG)",
    )
    parser.add_argument(
        "--prompt",
        type=str,
        required=True,
        help='Text-Prompt, der die gewünschte Bewegung beschreibt (z. B. "Die Kamera zoomt langsam heraus")',
    )
    parser.add_argument(
        "--negative-prompt",
        type=str,
        default="unscharf, niedrige Qualität, verzerrt, ruckartige Bewegung, Artefakte",
        help="Negativer Prompt, um unerwünschte Artefakte zu vermeiden",
    )
    parser.add_argument(
        "--frames",
        type=int,
        default=49,
        help="Anzahl der zu erzeugenden Video-Frames (Standard: 49, Max.: 81)",
    )
    parser.add_argument(
        "--steps",
        type=int,
        default=50,
        help="Anzahl der Diffusionsschritte (Standard: 50)",
    )
    parser.add_argument(
        "--guidance",
        type=float,
        default=7.0,
        help="Classifier-free Guidance-Skala (Standard: 7.0)",
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=-1,
        help="Zufalls-Seed für Reproduzierbarkeit (-1 = zufällig)",
    )
    parser.add_argument(
        "--fps",
        type=int,
        default=16,
        help="FPS des Ausgabevideos (Standard: 16)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="output_i2v.mp4",
        help="Dateipfad für das Ausgabevideo (Standard: output_i2v.mp4)",
    )
    parser.add_argument(
        "--height",
        type=int,
        default=480,
        help="Höhe des Ausgabevideos in Pixeln (Standard: 480)",
    )
    parser.add_argument(
        "--width",
        type=int,
        default=854,
        help="Breite des Ausgabevideos in Pixeln (Standard: 854)",
    )
    parser.add_argument(
        "--cpu-offload",
        action="store_true",
        default=True,
        help="CPU-Offloading des Modells aktivieren, um VRAM zu sparen (Standard: True)",
    )
    parser.add_argument(
        "--vae-tiling",
        action="store_true",
        default=False,
        help="VAE-Tiling für hochauflösende Ausgaben aktivieren",
    )
    return parser.parse_args()


def load_and_resize_image(image_path: str, width: int, height: int) -> Image.Image:
    """Bild aus Pfad laden und auf Zielabmessungen skalieren."""
    if not os.path.exists(image_path):
        print(f"[ERROR] Bild nicht gefunden: {image_path}", file=sys.stderr)
        sys.exit(1)

    img = Image.open(image_path).convert("RGB")
    original_size = img.size
    img = img.resize((width, height), Image.LANCZOS)
    print(f"[INFO] Bild geladen: {image_path} ({original_size[0]}x{original_size[1]}) → auf {width}x{height} skaliert")
    return img


def load_pipeline(model_id: str, cpu_offload: bool, vae_tiling: bool):
    """Die Wan-I2V-Pipeline mit Speicheroptimierungen laden."""
    print(f"[INFO] Modell wird geladen: {model_id}")
    print(f"[INFO] CUDA verfügbar: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
        print(f"[INFO] GPU: {torch.cuda.get_device_name(0)} ({vram_gb:.1f} GB VRAM)")
        if vram_gb < 23:
            print("[WARN] Weniger als 24 GB VRAM erkannt — aktivieren Sie --cpu-offload oder verwenden Sie das 1.3B-Modell")

    pipe = WanImageToVideoPipeline.from_pretrained(
        model_id,
        torch_dtype=torch.float16,
    )

    if cpu_offload:
        print("[INFO] CPU-Offload des Modells wird aktiviert")
        pipe.enable_model_cpu_offload()
    else:
        pipe.to("cuda")

    if vae_tiling:
        print("[INFO] VAE-Tiling für hochauflösende Generierung wird aktiviert")
        pipe.enable_vae_tiling()

    return pipe


def generate_video(pipe, args) -> None:
    """Die I2V-Pipeline ausführen und das Ausgabevideo speichern."""
    image = load_and_resize_image(args.image, args.width, args.height)

    generator = None
    if args.seed >= 0:
        generator = torch.Generator("cuda").manual_seed(args.seed)
        print(f"[INFO] Verwendeter Seed: {args.seed}")
    else:
        print("[INFO] Zufälligen Seed verwenden")

    print(f"[INFO] Generiere {args.frames} Frames mit {args.width}x{args.height}")
    print(f"[INFO] Schritte: {args.steps} | Guidance: {args.guidance} | FPS: {args.fps}")
    print(f"[INFO] Prompt: {args.prompt}")

    output = pipe(
        prompt=args.prompt,
        negative_prompt=args.negative_prompt,
        image=image,
        num_frames=args.frames,
        height=args.height,
        width=args.width,
        num_inference_steps=args.steps,
        guidance_scale=args.guidance,
        generator=generator,
    )

    export_to_video(output.frames[0], args.output, fps=args.fps)
    print(f"[INFO] Video gespeichert unter: {os.path.abspath(args.output)}")
    duration = args.frames / args.fps
    print(f"[INFO] Dauer: {duration:.1f}s bei {args.fps}fps ({args.frames} Frames)")


def main():
    args = parse_args()

    if not torch.cuda.is_available():
        print("[ERROR] Keine CUDA-GPU gefunden. Wan2.1-I2V-14B benötigt eine CUDA-fähige GPU.", file=sys.stderr)
        sys.exit(1)

    pipe = load_pipeline(args.model, args.cpu_offload, args.vae_tiling)
    generate_video(pipe, args)
    print("[DONE] Bild-zu-Video-Generierung abgeschlossen!")


if __name__ == "__main__":
    main()
```

### Erweiterte I2V-Pipeline (Python-API)

```python
import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image

# ── Pipeline laden ──────────────────────────────────────────────────────────────
pipe = WanImageToVideoPipeline.from_pretrained(
    "Wan-AI/Wan2.1-I2V-14B-480P",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()   # hält den VRAM unter 24 GB
pipe.enable_vae_tiling()          # optional: hilft bei 720p

# ── Eingabebild laden und vorbereiten ─────────────────────────────────────────
image = load_image("input.jpg").resize((854, 480))

# ── Generieren ───────────────────────────────────────────────────────────────────
prompt = "Die Kamera zoomt langsam heraus und zeigt die gesamte Landschaft"
negative_prompt = "unscharf, niedrige Qualität, verzerrt, flackernd, Artefakte"

generator = torch.Generator("cuda").manual_seed(42)

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=image,
    num_frames=49,          # ~3 Sekunden bei 16fps
    height=480,
    width=854,
    num_inference_steps=50,
    guidance_scale=7.5,
    generator=generator,
)

export_to_video(output.frames[0], "i2v_output.mp4", fps=16)
print("Gespeichert: i2v_output.mp4")
```

### I2V-Prompt-Tipps

| Ziel               | Prompt-Beispiel                                                   |
| ------------------ | ----------------------------------------------------------------- |
| Kamerabewegung     | `"Die Kamera zoomt langsam vom Motiv weg"`                        |
| Parallax-Effekt    | `"subtile Parallax-Bewegung, Tiefenschärfe-Verschiebung"`         |
| Charakteranimation | `"die Figur dreht den Kopf und lächelt"`                          |
| Naturanimation     | `"Blätter rascheln in einer sanften Brise, Licht verändert sich"` |
| Abstrakte Bewegung | `"Farben wirbeln und vermischen sich, flüssige Bewegung"`         |

### Speichertipps für I2V (24-GB-GPUs)

```python
# Auf 24-GB-GPUs erforderlich
pipe.enable_model_cpu_offload()

# Optional: reduziert den Spitzen-VRAM um ~10%
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# Zwischen Durchläufen bereinigen
import gc
gc.collect()
torch.cuda.empty_cache()
```

## Prompt-Beispiele

### Natur & Landschaften

```python
prompts = [
    "Zeitraffer von Wolken, die über Berggipfel ziehen, dramatische Beleuchtung",
    "Ozeanwellen, die gegen Felsen schlagen, Zeitlupe, filmisch",
    "Nordlichter tanzen am Nachthimmel, leuchtende Farben",
    "Wald im Herbst mit fallenden Blättern, friedliche Atmosphäre"
]
```

### Tiere & Charaktere

```python
prompts = [
    "Ein Golden Retriever, der durch ein Blumenfeld rennt",
    "Ein Schmetterling, der aus seinem Kokon schlüpft, Makroaufnahme",
    "Samurai-Krieger zieht das Schwert, dramatische Beleuchtung",
    "Roboter, der durch futuristische Stadtstraßen geht"
]
```

### Abstrakt & Künstlerisch

```python
prompts = [
    "Bunte Farbe, die in Wasser wirbelt, abstrakte Kunst",
    "Geometrische Formen, die sich verwandeln und morphieren, Neonfarben",
    "Tintentropfen, die sich in Milch ausbreiten, Makrofotografie"
]
```

## Erweiterte Einstellungen

### Qualität vs. Geschwindigkeit

```python
# Schnelle Vorschau
output = pipe(
    prompt=prompt,
    num_frames=17,
    num_inference_steps=25,
    guidance_scale=5.0
)

# Ausgewogen
output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

# Maximale Qualität
output = pipe(
    prompt=prompt,
    num_frames=81,
    num_inference_steps=100,
    guidance_scale=7.5
)
```

### Auflösungsoptionen

```python
# 480p (1.3B-Modell)
output = pipe(prompt, height=480, width=854, num_frames=49)

# 720p (14B-Modell)
output = pipe(prompt, height=720, width=1280, num_frames=49)

# 1080p (14B-Modell, hoher VRAM)
output = pipe(prompt, height=1080, width=1920, num_frames=33)
```

## Batch-Generierung

```python
import os
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompts = [
    "Eine Rakete startet ins All",
    "Fische, die in einem Korallenriff schwimmen",
    "Regen, der nachts auf eine Stadtstraße fällt"
]

output_dir = "./videos"
os.makedirs(output_dir, exist_ok=True)

for i, prompt in enumerate(prompts):
    print(f"Generiere {i+1}/{len(prompts)}: {prompt[:40]}...")

    output = pipe(
        prompt=prompt,
        num_frames=49,
        num_inference_steps=50
    )

    export_to_video(output.frames[0], f"{output_dir}/video_{i:03d}.mp4", fps=16)
    torch.cuda.empty_cache()
```

## Gradio-Oberfläche

```python
import gradio as gr
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video
import tempfile

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

def generate_video(prompt, negative_prompt, frames, steps, guidance, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    output = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=frames,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    )

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(output.frames[0], f.name, fps=16)
        return f.name

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Textbox(label="Eingabeaufforderung", lines=2),
        gr.Textbox(label="Negativer Prompt", value="unscharf, niedrige Qualität"),
        gr.Slider(17, 81, value=49, step=8, label="Frames"),
        gr.Slider(20, 100, value=50, step=5, label="Schritte"),
        gr.Slider(3, 12, value=7, step=0.5, label="Guidance"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Video(label="Generiertes Video"),
    title="Wan2.1 - Text zu Video-Generierung",
    description="Videos aus Texteingaben generieren. Läuft auf CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Speicheroptimierung

```python
# Alle Optimierungen aktivieren
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# Für sehr wenig VRAM
pipe.enable_sequential_cpu_offload()

# Cache zwischen Generierungen leeren
torch.cuda.empty_cache()
```

## Leistung

| Modell | Auflösung | Frames | GPU       | Zeit       |
| ------ | --------- | ------ | --------- | ---------- |
| 1.3B   | 480p      | 49     | RTX 4090  | \~2 Min.   |
| 1.3B   | 480p      | 49     | A100 40GB | \~1,5 Min. |
| 14B    | 720p      | 49     | A100 40GB | \~5 min    |
| 14B    | 720p      | 81     | A100 80GB | \~8 Min.   |

## Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

| GPU            | Stundensatz | \~49-Frame-Videos/Stunde |
| -------------- | ----------- | ------------------------ |
| RTX 3090 24 GB | \~$0.06     | \~20 (1.3B)              |
| RTX 4090 24GB  | \~$0.10     | \~30 (1.3B)              |
| A100 40GB      | \~$0.17     | \~40 (1.3B) / \~12 (14B) |
| A100 80GB      | \~$0.25     | \~8 (14B hochauflösend)  |

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

## Fehlerbehebung

### Speicher erschöpft

```python
# Kleineres Modell verwenden
pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B")

# Alle Optimierungen aktivieren
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Frames reduzieren
output = pipe(prompt, num_frames=17)

# Auflösung reduzieren
output = pipe(prompt, height=480, width=854)
```

### Schlechte Qualität

* Schritte erhöhen (75-100)
* Formuliere detailliertere Prompts
* Verwende Negative Prompts
* Probiere das 14B-Modell für bessere Qualität

### Video zu kurz

* Erhöhen Sie `num_frames` (max. 81)
* Verwende RIFE-Interpolation für die Frame-Interpolation
* Verknüpfe mehrere Generierungen

### Artefakte/Flickern

* Erhöhe die Guidance-Skala
* Verwende einen festen Seed für Konsistenz
* Nachbearbeitung mit Videostabilisierung

## Wan2.1 vs. andere

| Funktion          | Wan2.1       | Hunyuan      | SVD     | CogVideoX |
| ----------------- | ------------ | ------------ | ------- | --------- |
| Qualität          | Hervorragend | Hervorragend | Gut     | Großartig |
| Geschwindigkeit   | Schnell      | Mittel       | Schnell | Langsam   |
| Max. Frames       | 81           | 129          | 25      | 49        |
| Auflösung         | 720p         | 720p         | 576p    | 720p      |
| I2V-Unterstützung | Ja           | Ja           | Ja      | Ja        |
| Lizenz            | Apache 2.0   | Öffnen       | Öffnen  | Öffnen    |

**Verwende Wan2.1, wenn:**

* Open-Source-Videogenerierung benötigt wird
* eine schnelle Generierungsgeschwindigkeit gewünscht ist
* Apache-2.0-Lizenz erforderlich
* ein ausgewogenes Verhältnis von Qualität und Geschwindigkeit benötigt wird

## Nächste Schritte

* [Hunyuan Video](/guides/guides_v2-de/videogenerierung/hunyuan-video.md) - Alternative T2V
* [OpenSora](/guides/guides_v2-de/videogenerierung/opensora.md) - Open-Sora-Alternative
* [Stable Video Diffusion](/guides/guides_v2-de/videogenerierung/stable-video-diffusion.md) - Bildanimation
* [RIFE-Interpolation](/guides/guides_v2-de/videoverarbeitung/rife-interpolation.md) - Frame-Interpolation


---

# 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/videogenerierung/wan-video.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.