# Dify selbst gehostet unter Windows 11: QCode Schritt für Schritt verbinden


**Kurz gesagt**: Öffnen Sie in Dify `Integrations` → `Model Provider`, installieren Sie das Plugin `OpenAI-API-compatible`, klicken Sie dann auf `Add Model` und tragen Sie die Basis-URL `https://api.qcode.cc/openai/v1`, den Modellnamen `gpt-6.2-sol`, Ihren `cr_`-Key und `Chat` als Completion-Modus ein.

| Punkt | Eintrag |
|---|---|
| Zu installierende Integration | `OpenAI-API-compatible` |
| API-Basis-URL | `https://api.qcode.cc/openai/v1` |
| Modellname | `gpt-6.2-sol` |
| Modelltyp / Completion-Modus | `LLM` / `Chat` |
| API-Key | `cr_xxxxxxxx` |

Geprüft am 2026-11-22 · Dify 1.20.0 · Windows 11


Arbeiten Sie die 13 Screenshots unten auf einem Windows-11-PC durch, und am Ende antwortet QCode in Dify: eine Chatbot-App in `Studio`, die Ihre erste Nachricht beantwortet. Dify selbst braucht kein Konto bei einem Modellanbieter — das einzige Zugangsdatum hier ist ein QCode-API-Key.


- **Gilt für**: Windows 10 / 11 (64-Bit) mit Docker Desktop und WSL 2; die Screenshots zeigen Windows 11
- **Softwareversion**: Dify Community Edition 1.20.0 + Plugin `OpenAI-API-compatible` 0.0.87
- **Screenshots aktualisiert**: 2026-11
- **Zeitbedarf**: etwa 25 Minuten, plus der erste Download der Docker-Images
- **Sie brauchen**: einen QCode-API-Key, der mit `cr_` beginnt


Prüfen Sie vor dem ersten Screenshot, ob Sie Folgendes haben:


- Einen Windows-10- oder -11-PC (64-Bit), der Websites öffnen kann, mit mindestens 2 CPU-Kernen und 4 GiB Arbeitsspeicher, die für Docker reserviert sind
- Einen Browser — Edge oder Chrome —, denn Dify hat keine Desktop-App; das ganze Tutorial läuft in einem Browser-Tab
- Eine Dify-Instanz, bei der Sie sich anmelden können: Ihre eigene Docker-Compose-Bereitstellung unter `http://localhost:8080` oder Dify Cloud unter **cloud.dify.ai**
- Einen aus Ihrem Dashboard kopierten QCode-API-Key (`cr_xxxxxxxx`); das ist der einzige Punkt, den Sie nicht überspringen können. Noch kein Konto? [Registrieren](https://qcode.cc/de/auth/sign-up?utm_source=docs.qcode.cc&utm_medium=tut_before&utm_campaign=knowledge_base&src=docs-ide-dify-before) Sie sich zuerst, wählen Sie auf der [Preisseite](https://qcode.cc/de/pricing?utm_source=docs.qcode.cc&utm_medium=tut_before&utm_campaign=knowledge_base&src=docs-ide-dify-before) einen Tarif und erstellen Sie den Key anschließend im [Dashboard](https://qcode.cc/de/dashboard).


## Download und Installation

Dify ist ein Webdienst, es gibt also keinen Windows-Installer für die Dify-Oberfläche. Sie öffnen entweder Dify Cloud im Browser oder betreiben dieselbe Oberfläche lokal mit Docker Compose. Beide Wege enden auf derselben Seite `Model Provider`, die die folgenden Schritte verwenden. Wählen Sie den Tab, der zu Ihrer Situation passt:

**Andere Regionen**

Öffnen Sie **dify.ai** und nutzen Sie den Cloud-Weg: Melden Sie sich unter **cloud.dify.ai** an, und das ganze Tutorial läuft im Browser.

Für eine lokale Bereitstellung öffnen Sie die offizielle Docker-Compose-Anleitung unter **docs.dify.ai**, installieren Docker Desktop von **docker.com** (Windows, `x64`), akzeptieren die Vereinbarung und behalten das Backend `Use WSL 2`. Der Installer benötigt Administratorrechte und fragt üblicherweise nach einem Neustart. Das Repository der Anleitung enthält außerdem GitHub Releases, wo die Windows-Datei `difyctl-v1.20.0-windows-x64.exe` ein Kommandozeilenwerkzeug für Administratoren ist — es ist nicht die Dify-Oberfläche, erwarten Sie also nicht, dass sich daraus ein Fenster öffnet. Nach `docker compose up -d` ist die Oberfläche unter `http://localhost:8080` erreichbar.


**Festlandchina**

Öffnen Sie **dify.ai** und nutzen Sie den Cloud-Weg: Die Oberfläche liegt dann unter **cloud.dify.ai**, und auf dem PC wird nichts installiert.

Wenn Sie die Oberfläche lieber auf Ihrem eigenen Rechner haben möchten, öffnen Sie die offizielle Docker-Compose-Anleitung unter **docs.dify.ai** und folgen Sie ihr mit Docker Desktop. Installieren Sie Docker Desktop zuerst von **docker.com**. Lädt eine Seite langsam oder stockt ein Download, warten Sie eine Minute und starten Sie ihn erneut — Seite und Installer werden vom selben Host ausgeliefert, ein späterer Versuch behebt meist beides.




### Zuerst die Seite mit den Voraussetzungen lesen

Bevor Sie etwas herunterladen, öffnen Sie die offizielle Docker-Compose-Anleitung. ① Der Seitentitel bestätigt, dass Sie auf der Selbst-Hosting-Seite für Docker Compose sind, und ② der Block mit den Voraussetzungen listet, was der Rechner bieten muss: mindestens 2 CPU-Kerne, 4 GiB RAM und Docker Compose selbst.

![Die offizielle Selbst-Hosting-Anleitung von Dify für Docker Compose mit dem Seitentitel oben und dem Block mit den Hardware- und Software-Voraussetzungen darunter](https://docs.qcode.cc/static/images/tut/dify/202611/en/01-dify-docs-docker.webp)


Richtig gemacht sehen Sie: ① die Überschrift der Installationsseite für Docker Compose und ② die Liste der Voraussetzungen mit CPU-, Arbeitsspeicher- und Docker-Compose-Zeile, die auf einem Bildschirm lesbar sind.


**Hängt es? Die Seite zeigt eine andere Installationsmethode**

Dify dokumentiert Docker Compose und Kubernetes nebeneinander, und Suchergebnisse landen manchmal auf der Kubernetes-Seite. Scrollen Sie nach oben und prüfen Sie, ob die Adresse `docker-compose` enthält; das ist der Weg, den dieses Tutorial nutzt.




### Docker Desktop installieren

Dify läuft unter Windows in Containern, Docker Desktop kommt also zuerst. Klicken Sie auf **docker.com** auf ① `Download Docker Desktop`, führen Sie die heruntergeladene `Docker Desktop Installer.exe` aus, akzeptieren Sie die Vereinbarung und lassen Sie das Backend `Use WSL 2` ausgewählt. Der Installer verlangt Administratorrechte und bietet meist einen Neustart an; nehmen Sie ihn an.

![Die offizielle Download-Seite von Docker Desktop mit der Schaltfläche Download Docker Desktop](https://docs.qcode.cc/static/images/tut/dify/202611/en/02-docker-desktop-download.webp)


Richtig gemacht sehen Sie: Der Download startet über die Schaltfläche ①, und nach der Installation erscheint das Wal-Symbol im Infobereich mit dem Status `Engine running`.


**Hängt es? Windows meldet „Windows hat Ihren PC geschützt“**

Klicken Sie auf `More info`, dann auf `Run anyway`. SmartScreen zeigt dieses Feld für Installer, die es noch nicht oft gesehen hat; die Datei ist die, die die Schaltfläche ① gerade heruntergeladen hat.




### Bei Ihrer Dify-Instanz anmelden

Öffnen Sie `http://localhost:8080` im Browser. Der allererste Besuch führt auf die Seite `/install`, auf der Sie das Administratorkonto mit E-Mail-Adresse und Passwort anlegen; jeder weitere Besuch öffnet die Anmeldeseite. Tragen Sie E-Mail und Passwort in ① ein und klicken Sie dann auf ② `Sign in`.

![Die Anmeldeseite einer selbst gehosteten Dify-Instanz mit E-Mail- und Passwortfeld sowie der Schaltfläche Sign in](https://docs.qcode.cc/static/images/tut/dify/202611/en/03-dify-signin.webp)


Richtig gemacht sehen Sie: ① beide Felder gefüllt, das Passwort durch Punkte verdeckt, ② `Sign in` wird blau, und nach dem Klick die Dify-Startseite mit dem Workspace-Namen oben links.


**Hängt es? Der Browser meldet, die Website sei nicht erreichbar**

Die Container laufen noch nicht. Öffnen Sie Docker Desktop, warten Sie auf `Engine running`, führen Sie dann im Ordner der Dify-Quellen `docker compose up -d` aus und aktualisieren Sie die Seite. Der erste Start lädt mehrere Images und dauert eine Weile.




### Integrations öffnen

Nach der Anmeldung öffnet sich die Dify-Startseite. Die gesamte Navigation liegt in einer Spalte links: `Home`, `Studio`, `Agents`, `Knowledge`, `Contacts`, `Skills`, `Integrations`, `Marketplace`. Klicken Sie auf ① `Integrations`; Dify bringt Sie direkt zu `Model Provider`.

![Dify-Startseite mit der Navigation in der linken Seitenleiste und dem hervorgehobenen Eintrag Integrations](https://docs.qcode.cc/static/images/tut/dify/202611/en/04-dify-home-integrations.webp)


Richtig gemacht sehen Sie: ① `Integrations` in der linken Spalte hervorgehoben und die Seite dahinter mit dem Titel `Model Provider` und einem Feld `Search models...` oben.




### Nach dem Provider OpenAI-API-compatible suchen

`Model Provider` listet jede Integration, mit der Dify sprechen kann. Klicken Sie auf ① das Feld `Search models...` und tippen Sie `OpenAI-API-compatible` ein. ② Die passende Karte erscheint in der Liste, mit einer blauen Schaltfläche `Install`.

![Die Seite Model Provider mit OpenAI-API-compatible im Suchfeld und der passenden Provider-Karte darunter in der Liste](https://docs.qcode.cc/static/images/tut/dify/202611/en/05-search-openai-compat.webp)


Richtig gemacht sehen Sie: ① Ihren Text im Suchfeld und ② eine Karte namens `OpenAI-API-compatible` mit einer Schaltfläche `Install` — nicht `OpenAI`, das ein anderes Plugin ist.


**Hängt es? Die Suche liefert nichts**

Tippen Sie nur `OpenAI` und scrollen Sie die Liste. Das Installieren von Plugins erfordert den Workspace-Eigentümer oder einen Administrator, ein Mitgliedskonto sieht die Karten also möglicherweise ohne die Schaltfläche `Install`. Aktualisieren Sie die Seite nach der Installation, bevor Sie erneut suchen.




### Die Plugin-Installation bestätigen

Ein Klick auf `Install` auf der Karte öffnet einen Dialog mit dem Titel `Install Integration`, statt sofort zu installieren. Lesen Sie den Namen im Dialog und klicken Sie auf ① `Install` in der Fußzeile des Dialogs. Dify lädt das Plugin dann aus seinem Marketplace herunter, was ein paar Sekunden dauert.

![Der Bestätigungsdialog Install Integration mit der blauen Schaltfläche Install in der Fußzeile](https://docs.qcode.cc/static/images/tut/dify/202611/en/06-install-plugin-confirm.webp)


Richtig gemacht sehen Sie: ① der Dialog schließt sich von selbst, und die Karte `OpenAI-API-compatible` wandert in die Gruppe `Configuration required`.


**Hängt es? Der Dialog lädt und schlägt dann fehl**

Das Plugin wird von **marketplace.dify.ai** geladen. Prüfen Sie, ob die Adresse in einem anderen Tab aufgeht; in einem Firmennetz oder hinter einem Proxy kann der Download blockiert sein, ein erneuter Versuch in einem anderen Netz funktioniert meist.




### Den Dialog Add model öffnen

Das installierte Plugin steht jetzt unter `Configuration required` mit dem Hinweis `Set up api-key or add model to use`. Klicken Sie auf ① `Add Model` rechts auf dieser Karte — hier kommen die QCode-Adresse und der Key hinein.

![Die Karte OpenAI-API-compatible unter Configuration required mit der Schaltfläche Add Model rechts](https://docs.qcode.cc/static/images/tut/dify/202611/en/07-provider-add-model-entry.webp)


Richtig gemacht sehen Sie: ① `Add Model`, und ein Klick darauf öffnet einen Dialog namens `Add model` mit `Model Name`, `Model Type` und `API Key`.




### Das Modell benennen und seinen Typ wählen

Tippen Sie `gpt-6.2-sol` in ① `Model Name` — das ist die QCode-Modell-ID, kopieren Sie sie also genau so wie geschrieben. Öffnen Sie ② `Model Type` und wählen Sie `LLM`. Klicken Sie dann in das Feld `API Key` und fügen Sie Ihren Key ein, der mit `cr_` beginnt; der Dialog verbirgt ihn hinter Punkten.

![Die obere Hälfte des Dialogs Add model mit gpt-6.2-sol in Model Name, LLM in Model Type und dem mit Punkten gefüllten Feld API Key](https://docs.qcode.cc/static/images/tut/dify/202611/en/08-add-model-config-top.webp)

**Brauchen Sie einen API-Key?**

Wenn Sie noch kein QCode-Konto haben, [Registrieren](https://qcode.cc/de/auth/sign-up?utm_source=docs.qcode.cc&utm_medium=tut_key_step&utm_campaign=knowledge_base&src=docs-ide-dify-key) Sie sich zuerst. Wenn Sie keinen Monatstarif möchten, kaufen Sie ein Paket auf der Seite [Nutzungspakete](https://qcode.cc/de/pay-as-you-go?utm_source=docs.qcode.cc&utm_medium=tut_key_step&utm_campaign=knowledge_base&src=docs-ide-dify-key), und erstellen Sie den Key anschließend im [Dashboard](https://qcode.cc/de/dashboard). Kopieren Sie die Zeichenfolge ab `cr_` und fügen Sie sie anstelle von `cr_xxxxxxxx` ein. Sie können mit Kredit- oder Debitkarte (Visa / Mastercard), Apple Pay / Google Pay oder Kryptowährung bezahlen — siehe [Zahlungsarten](/docs/reference/payment-methods).



Richtig gemacht sehen Sie: ① `gpt-6.2-sol` genau so geschrieben, ② `LLM` im Typfeld und eine Reihe Punkte in `API Key` — ohne Anführungszeichen um irgendetwas davon.




### Die QCode-Basis-URL und den Completion-Modus eintragen

Scrollen Sie im Dialog nach unten. Tragen Sie `https://api.qcode.cc/openai/v1` in ① `API Base URL` ein — der ganze Pfad gehört in das Feld, `/openai/v1` inklusive, ohne abschließenden Schrägstrich und ohne `/chat/completions`. Lassen Sie ② `Completion mode` auf `Chat` und klicken Sie dann auf ③ `Add`, um den Key zu speichern und zu prüfen.

![Die untere Hälfte des Dialogs Add model mit der QCode-Basis-URL in API Base URL, Chat in Completion mode und der Schaltfläche Add](https://docs.qcode.cc/static/images/tut/dify/202611/en/09-add-model-config-url.webp)


Richtig gemacht sehen Sie: ① die Adresse endet auf `/openai/v1`, ② `Chat` ist ausgewählt, und ③ `Add` schließt den Dialog ohne rote Fehlerzeile.


**Hängt es? Das Speichern endet mit 401 oder 404**

Ein 401 bedeutet, der Key wurde abgeschnitten oder enthält ein Leerzeichen oder Anführungszeichen — kopieren Sie ihn erneut aus dem Dashboard und tippen Sie das Feld neu. Ein 404 bedeutet, die Adresse hat einen zusätzlichen oder fehlenden Pfad; sie muss genau `https://api.qcode.cc/openai/v1` lauten.




### Prüfen, ob das Modell aktiviert ist

Nach `Add` verlässt das Plugin `Configuration required`. Klicken Sie unter der Karte auf `Show Models`, um die Modellliste aufzuklappen: ① die Zeile `gpt-6.2-sol LLM CHAT` erscheint mit eingeschaltetem Schalter. Klicken Sie dann auf ② `Default Models` in der Werkzeugleiste oben rechts auf der Seite.

![Die aufgeklappte Liste Show Models mit der aktivierten Zeile gpt-6.2-sol LLM CHAT und der Schaltfläche Default Models oben rechts](https://docs.qcode.cc/static/images/tut/dify/202611/en/10-model-saved-enabled.webp)


Richtig gemacht sehen Sie: ① eine Modellzeile mit `gpt-6.2-sol`, `LLM` und `CHAT` und dem eingeschalteten Schalter rechts, während ② `Default Models` eine blaue Schaltfläche in der oberen rechten Ecke ist.




### Das Modell als Standard-Systemmodell festlegen

`Default Model Settings` öffnet sich als Dialog. Die erste Zeile ist ① `System Reasoning Model`: Öffnen Sie sie, wählen Sie `gpt-6.2-sol` aus der Liste und klicken Sie dann auf ② `Save`.

![Der Dialog Default Model Settings mit gpt-6.2-sol für System Reasoning Model und der Schaltfläche Save](https://docs.qcode.cc/static/images/tut/dify/202611/en/11-default-model-settings.webp)


Richtig gemacht sehen Sie: ① `gpt-6.2-sol` in der Zeile System Reasoning Model, und nach dem Klick auf ② `Save` verschwindet der gelbe Balken `Configure a default system model to run applications` oben auf der Seite.


**Hängt es? Die Zeile meldet, die Modellliste sei leer**

Eine leere Liste bedeutet, dass das Plugin noch kein aktiviertes Modell hat — gehen Sie einen Schritt zurück und klappen Sie `Show Models` auf, um zu prüfen, ob der Schalter an ist. Ein Modell, das in dieser Liste deaktiviert wurde, wird hier nicht angeboten.




### Eine Chatbot-App erstellen

Öffnen Sie `Studio` in der linken Spalte und klicken Sie auf `Create from Blank`. Zunächst werden nur `Workflow` und `Chatflow` angeboten; klicken Sie auf `MORE BASIC APP TYPES`, um die übrigen aufzuklappen, und wählen Sie ① `Chatbot`. Tippen Sie `QCode Assistant` in ② `App name` und klicken Sie dann auf ③ `Create`.

![Die Karte Create from Blank in Studio mit aufgeklapptem MORE BASIC APP TYPES, ausgewähltem Typ Chatbot, dem App-Namen QCode Assistant und der Schaltfläche Create](https://docs.qcode.cc/static/images/tut/dify/202611/en/12-create-chatbot-app.webp)


Richtig gemacht sehen Sie: ① `Chatbot` nach der Auswahl blau umrahmt, ② `QCode Assistant` im Namensfeld und ③ `Create` öffnet die neue Anwendung.


**Hängt es? Es gibt keine Option Chatbot**

`Chatbot` ist standardmäßig eingeklappt: Klicken Sie unter den beiden großen Karten auf `MORE BASIC APP TYPES`, und `Chatbot`, `Agent` und `Text Generator` erscheinen. Prüfen Sie außerdem, ob die Seite `Studio` und nicht `Agents` ist.




### Die erste Nachricht senden und die Antwort prüfen

Das Erstellen der App öffnet die Seite `Orchestrate`. ① Die Modellauswahl oben zeigt bereits `gpt-6.2-sol CHAT`. Tippen Sie `Hello! Please introduce yourself in one sentence.` in ③ das Feld `Talk to Bot` unten in `Debug & Preview` und drücken Sie `Send`; ② die Antwort streamt in das Panel darüber.

![Die Seite Orchestrate mit gpt-6.2-sol CHAT im Kopfbereich, dem Eingabefeld Talk to Bot und einer streamenden Antwort in Debug and Preview](https://docs.qcode.cc/static/images/tut/dify/202611/en/13-chatbot-preview-reply.webp)


Richtig gemacht sehen Sie: ① `gpt-6.2-sol CHAT` im Kopfbereich, ③ Ihren Satz im Eingabefeld und ② eine kurze englische Antwort, die Wort für Wort erscheint — kein 401, 404 oder „model not found“.


**Hängt es? Die Antwort beginnt nie**

Öffnen Sie `Default Model Settings` erneut und bestätigen Sie, dass `System Reasoning Model` weiterhin `gpt-6.2-sol` enthält; eine App, die erstellt wurde, bevor der Standard gespeichert war, startet ohne Modell. Ist die Antwort rot, sind Key oder Adresse falsch — siehe **Häufige Fehler** unten.




## Prüfen, ob es funktioniert

Ihre Einrichtung ist vollständig, wenn alle vier Punkte zutreffen:

- `Model Provider` führt `OpenAI-API-compatible` unter den installierten Integrationen auf, mit aktiviertem `gpt-6.2-sol` in `Show Models`.
- `Default Model Settings` zeigt `gpt-6.2-sol` für `System Reasoning Model` statt einer leeren Zeile.
- `QCode Assistant` antwortet in `Debug & Preview`, und die Antwort kommt als Stream an, nicht als Fehler 401, 404 oder „model not found“.
- Schließen Sie den Browser-Tab, öffnen Sie Dify erneut, und Modell, Standardeinstellung und App sind alle noch da.


### Fertig

Sie haben QCode in Dify eingebunden, und eine Chatbot-App antwortet darüber. Weiter geht es mit:

- [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths) — die drei QCode-Hosts und jeder Pfad, den sie bedienen
- [Abrechnung](/docs/reference/billing) — wie ein Key und ein Kontingent über Apps und Werkzeuge hinweg geteilt werden
- [Fehlerbehebung](/docs/reference/troubleshooting)
- Vergleichen Sie die Tarife auf der [Preisseite](https://qcode.cc/de/pricing?utm_source=docs.qcode.cc&utm_medium=tut_done&utm_campaign=knowledge_base&src=docs-ide-dify-done)
- Kehren Sie zu Ihrem [Dashboard](https://qcode.cc/de/dashboard) zurück, um Nutzung und Guthaben zu prüfen


## Häufige Fehler

| Fehlermeldung | Ursache | Was tun |
|---|---|---|
| `Set up api-key or add model to use` | Das Plugin ist installiert, aber es wurde noch kein Modell hinzugefügt, Dify hat also nichts auszuwählen | Öffnen Sie `Model Provider`, klicken Sie auf `Add Model` auf der Karte `OpenAI-API-compatible` und füllen Sie alle vier Felder aus |
| `Configure a default system model to run applications` | Ein Modell existiert, aber es wurde kein Standard gewählt, neue Apps starten also ohne Modell | Klicken Sie oben rechts auf `Default Models`, setzen Sie `System Reasoning Model` auf `gpt-6.2-sol` und klicken Sie auf `Save` |
| `401` | Der Key hat QCode erreicht und wurde abgelehnt: Er wurde mit einem Leerzeichen, einem Anführungszeichen oder nur teilweise kopiert, oder er gehört zu einem beendeten Tarif | Kopieren Sie den `cr_`-Key erneut aus dem Dashboard, fügen Sie ihn ohne Zusätze in `API Key` ein und prüfen Sie den Tarifstatus im Dashboard |
| `404` | Die Adresse hat einen zusätzlichen oder fehlenden Pfad, QCode erhält also eine Anfrage, die es nicht bedient | Lassen Sie `API Base URL` genau auf `https://api.qcode.cc/openai/v1` — kein abschließender Schrägstrich, kein `/chat/completions` |

## Häufige Fragen

### Brauche ich ein Dify-Konto oder ein Anthropic- oder OpenAI-Konto?

Kein Konto bei einem Modellanbieter ist nötig. Dify Cloud verlangt ein Dify-Konto; eine selbst gehostete Instanz verlangt das Administratorkonto, das Sie auf der Seite `/install` anlegen. In beiden Fällen ist der Key, der das Modell erreicht, Ihr QCode-`cr_`-Key, und nichts in diesem Tutorial verlangt eine Anmeldung bei Anthropic oder OpenAI.

### Warum fehlt `OpenAI-API-compatible` in der Liste?

Drei übliche Gründe: Im Suchfeld steht noch eine längere Eingabe (tippen Sie nur `OpenAI` und scrollen Sie), das Plugin ist bereits installiert und deshalb aus dem Marketplace-Teil der Seite verschwunden, oder das Konto ist kein Workspace-Eigentümer und kein Administrator, was zum Installieren von Plugins nötig ist. Aktualisieren Sie die Seite einmal, bevor Sie erneut suchen.

### Warum muss der Modellname `gpt-6.2-sol` sein?

`Model Name` ist kein Etikett — Dify sendet diese Zeichenfolge als Modell-ID an QCode. Eine QCode-Modell-ID muss genau so geschrieben werden, wie die QCode-Dokumentation sie aufführt, `gpt-6.2-sol` funktioniert also, `GPT 6.2 Sol` nicht. Jede andere ID, die derselbe Endpunkt bedient, gehört in dasselbe Feld, etwa `gpt-6.2-astra`.

### Kann ich Claude-Modelle über QCode in Dify nutzen?

Ja, über die Anthropic-Integration von Dify selbst, mit der Anthropic-kompatiblen Adresse `https://api.qcode.cc/api` statt der OpenAI-kompatiblen. Der QCode-Standard ist dort `claude-opus-5-5`. Die 13 Screenshots auf dieser Seite folgen dem OpenAI-kompatiblen Plugin, weil das der hier durchgängig behandelte Weg ist; betrachten Sie die Anthropic-Adresse als Option für später.

### Was passiert, wenn mein Key abläuft?

Das hängt davon ab, was Sie gekauft haben. Ein Key aus einem persönlichen Tarif lässt sich nicht verlängern — öffnen Sie den Tarif neu, erstellen Sie einen neuen Key und fügen Sie ihn wieder in das Feld `API Key` ein. Ein Key aus einem Nutzungspaket wird wieder aktiv, sobald Sie ein weiteres Paket kaufen: Derselbe Key funktioniert weiter, und in Dify muss nichts geändert werden.

### Behält Dify die Modelleinstellungen nach einem Neustart?

Ja. Modelle, ihre Keys und das Standardmodell liegen in der Dify-Datenbank, nicht in der Browser-Sitzung; Abmelden oder ein Neustart der Container entfernt sie also nicht. Nur das Löschen der Datenvolumes löscht sie, und damit auch das Administratorkonto und jede App.

### Soll ich `Chat` oder `Completion` als Completion-Modus verwenden?

Verwenden Sie `Chat`. QCode bedient auf diesem Endpunkt Chat-Completions-Modelle, und `Completion` erwartet eine Prompt-Completion-Schnittstelle, die diese Modelle nicht anbieten. Eine falsche Wahl hier zeigt sich als Fehler bei `Add` und nicht in der App.

## Zu verwendende Modelle

Derselbe QCode-Key macht Modelle mehrerer Hersteller verfügbar, und die Modell-ID gehört in `Model Name`. Wählen Sie eine und lassen Sie die übrigen Felder unverändert.

| Modell | Protokoll und Adresse | Wofür |
|---|---|---|
| `gpt-6.2-sol` | OpenAI-kompatibel — `https://api.qcode.cc/openai/v1` | Standard für dieses Tutorial: Alltags-Chat, Schreiben, Code-Fragen |
| `gpt-6.2-astra` | OpenAI-kompatibel — `https://api.qcode.cc/openai/v1` | Die höhere Stufe der GPT-Familie, für die schwierigsten Aufgaben |
| `claude-opus-5-5` | Anthropic-kompatibel — `https://api.qcode.cc/api` | Flaggschiff-Claude, für langes Reasoning und große Refactorings |
| `claude-haiku-5-5` | Anthropic-kompatibel — `https://api.qcode.cc/api` | Leichtes Claude, für schnelle, günstige Antworten |

Eine `claude-*`-ID an den OpenAI-kompatiblen Endpunkt wird abgelehnt, und eine `gpt-*`-ID an den Anthropic-Endpunkt ebenso — die Modellfamilie muss zur Adresse passen. Die aktuelle Liste der IDs finden Sie in Ihrem Dashboard.

## Wie die Adresse verwendet wird

`API Base URL` ist eine Basis, kein vollständiger Anfragepfad. Dify behält den Teil `/openai/v1` und hängt `chat/completions` selbst an, deshalb muss das Feld bei `/v1` enden.

| Feld | Wert | Hinweis |
|---|---|---|
| `API Base URL` | `https://api.qcode.cc/openai/v1` | `/openai/v1` beibehalten; kein abschließender Schrägstrich |
| Was Dify anfragt | `https://api.qcode.cc/openai/v1/chat/completions` | Aus dem Feld oben gebildet — nicht selbst eintippen |
| `Model Name` | `gpt-6.2-sol` | Jede Modell-ID, die auf diesem Endpunkt bedient wird |
| `Model Type` | `LLM` | Der Typ, der Chat-Anfragen beantwortet |
| `Completion mode` | `Chat` | Nicht `Completion` |
| `API Key` | `cr_xxxxxxxx` | Wird mit dem Modell gespeichert, also nur einmal eingegeben |

## Alternative Endpunkte

Wenn der Standard-Host langsam ist oder aus Ihrem Netz nicht erreichbar ist, ersetzen Sie nur die Domain und lassen Sie den Rest der Adresse unverändert:

| Endpunkt | OpenAI-kompatible Basis | Anthropic-kompatible Basis |
|---|---|---|
| Standard | `https://api.qcode.cc/openai/v1` | `https://api.qcode.cc/api` |
| Asien | `https://asia.qcode.cc/openai/v1` | `https://asia.qcode.cc/api` |
| Nordamerika und Europa | `https://us.qcode.cc/openai/v1` | `https://us.qcode.cc/api` |

Beide alternativen Hosts akzeptieren denselben Key und dieselben Pfade. Wenn Sie den Host wechseln, bearbeiten Sie `API Base URL` auf der Modellkarte und klicken Sie erneut auf `Add`, um sie zu prüfen. Alle Details stehen unter [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths).

## Hinweise zum Selbst-Hosting

- **Windows braucht Docker Desktop plus WSL 2.** Das Dify-Repository ist eine Sammlung von Diensten, keine Anwendung, die Sie doppelklicken können; Docker Desktop führt sie aus, und die Anleitung verlangt mindestens 2 CPU-Kerne und 4 GiB RAM.
- **Die Quellen gehören aufs Linux-Dateisystem.** Leistung und Dateiberechtigungen verhalten sich besser, wenn der Dify-Ordner in WSL 2 statt auf `C:\` liegt.
- **Der erste Start ist langsam.** Beim ersten Mal werden mehrere Container-Images geladen, und die Seite bleibt leer, bis der API-Container bereit meldet. Spätere Starts dauern Sekunden.
- **`http://localhost:8080` ist die Oberfläche, nicht die API.** Für den Browser muss nichts von Dify selbst heruntergeladen werden; der Port wird von den Containern bedient.
- **Die Sprache der Dify-Oberfläche ist vom Browser getrennt.** Sie wird im Kontomenü unter `Preferences` → `General` → `Display Language` umgestellt; dieses Tutorial verwendet die englische Oberfläche, alle Beschriftungen hier entsprechen also dem, was die Screenshots zeigen.

## Verwandte Dokumentation

- [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths) — jede Ingress-Domain und ihre Pfade
- [Abrechnung](/docs/reference/billing) — gemeinsame Kontingentregeln
- [Fehlerbehebung](/docs/reference/troubleshooting) — wenn eine Anfrage 401, 404 oder einen Modellfehler liefert
- [Claude-Code-Tutorial](/docs/getting-started/claude-code-tutorial) — derselbe Key im Terminal
- [Zahlungsarten](/docs/reference/payment-methods) — wie ein Paket oder ein Tarif bezahlt werden kann