> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/neu/studio/start.md). # Starte mit Unsloth Studio Unsloth Studio ist eine lokale, browserbasierte GUI für das Feinabstimmen von LLMs, ohne dass Sie Code schreiben müssen. Sie kapselt die Trainingspipeline in einer übersichtlichen Oberfläche, die das Laden von Modellen, die Formatierung von Datensätzen, die Konfiguration von Hyperparametern und die Live-Überwachung des Trainings übernimmt. Unsloth Datenrezept Exportieren Chat #### Unsloth Studio einrichten **Mit Unsloth Desktop installieren.** Der einfachste Weg, Unsloth Studio zu installieren, ist die native Desktop-App. Lade sie für dein Betriebssystem herunter: * [Download für macOS](https://unsloth.ai/download/mac) * [Download für Windows](https://unsloth.ai/download/windows) * [Download für Linux](https://unsloth.ai/download/linux) Starten Sie zunächst Unsloth Studio entweder mit einer lokalen Installation oder mit einer Cloud-Option. Folgen Sie der [Installationsanweisungen](/docs/de/neu/studio/install.md) für Ihr Setup, oder verwenden Sie unser [kostenloses Colab](/docs/de/neu/studio.md#google-colab-notebook) Notebook. Für ein lokales Setup führen Sie aus: ```bash unsloth studio -H 0.0.0.0 -p 8888 ``` {% columns %} {% column width="50%" %} Öffnen Sie Ihren bevorzugten Browser und gehen Sie zu `http://127.0.0.1:8888`. Sie müssen ein neues Passwort erstellen. **Starten Sie Unsloth sicher mit HTTPS und Cloudflare.** Unsloth bietet jetzt eine sichere Möglichkeit, Unsloth über HTTPS über einen kostenlosen Cloudflare-Tunnel zu starten. Verwenden Sie Folgendes (funktioniert unter Windows, Mac & Linux): ```bash unsloth studio --secure ``` {% endcolumn %} {% column width="50%" %}

{% endcolumn %} {% endcolumns %} ## Chat - Schnellstart [Unsloth Studio Chat](/docs/de/neu/studio/chat.md) ermöglicht es Ihnen, Modelle zu 100 % offline auf Ihrem Computer auszuführen. Führen Sie Modellformate wie GGUF und Safetensors von Hugging Face oder aus Ihren lokalen Dateien aus. * **Herunterladen + Ausführen** beliebige Modelle wie GGUFs, feinabgestimmte Adapter, Safetensors usw. * [**Vergleichen** anderes Modell](#model-arena) Ausgaben nebeneinander * **Hochladen** Dokumente, Bilder und Audio in Ihre Prompts * [**Abstimmen** Inferenz](#generation-settings) Einstellungen wie: Temperatur, Top-p, Top-k und System-Prompt

Sie können hier unser ausführliches Tutorial / unseren Leitfaden zum Ausführen von Modellen mit Unsloth Studio lesen: {% content-ref url="/pages/73168493b14a89fa27e95b776ade6bd93679a3e5" %} [Studio Chat](/docs/de/neu/studio/chat.md) {% endcontent-ref %} ### Leitfaden zum Laden von Modellen Bevor Sie die API verwenden, müssen Sie **das Modell laden** das Sie verwenden möchten in **Unsloth.** Öffnen Sie das **Modell auswählen** Dropdown-Menü in der oberen linken Ecke der Chat-Seite.

{% hint style="info" %} Auf einer anderen Seite? Verwenden Sie die linke Seitenleiste und klicken Sie auf `Neuer Chat` um zur Chat-Seite zurückzukehren. {% endhint %} {% columns %} {% column width="50%" %} #### Modell auswählen Verwenden Sie die Suchleiste, um das Modell zu finden, das Sie in Unsloth laden möchten. Durchsuchen Sie empfohlene Modelle, suchen Sie direkt nach Hugging-Face-Modellen oder legen Sie ein benutzerdefiniertes Modellverzeichnis fest. Lokal trainierte und exportierte Modelle können über den Tab \`Fine-tuned\` geladen werden. {% endcolumn %} {% column width="50%" %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### GGUF-Auswahl Model-Repositories enthalten mehrere Quantisierungen. Wählen Sie die Quantisierung, die am besten zu Ihrem verfügbaren RAM / VRAM passt.\ \ In dieser Anleitung verwenden wir `unsloth/gemma-4-26B-A4B-it-GGUF` und wählen Sie die empfohlene `UD-Q4_K_XL` Variante {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} #### Das Modell herunterladen {% columns %} {% column %} Suchen Sie nach dem Modell, das Sie verwenden möchten, und dann **klicken Sie darauf** um mit dem Herunterladen und Laden zu beginnen. Nachdem Sie eine Modellvariante ausgewählt haben, beginnt Unsloth mit dem Herunterladen und Laden des Modells in den Speicher. Sobald das Laden abgeschlossen ist, sehen Sie die folgende Bestätigung: {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} Das Modell ist geladen und einsatzbereit. Sie können jetzt direkt in Unsloth mit dem Modell chatten oder es mit Tools verbinden wie [Claude Code](/docs/de/grundlagen/claude-code.md) und [Codex](/docs/de/grundlagen/codex.md).

## Unsloth - Schnellstart Die Unsloth Studio-Startseite hat 4 Hauptbereiche: [Modell](#id-1.-select-model-and-method), [Datensatz](#id-2.-dataset), [Parameter](#id-3.-hyperparameters)und [Training/Konfiguration](#id-4.-training-and-config) * **Einfache Einrichtung für Modelle und Daten** von Hugging Face oder lokalen Dateien * **Flexible Trainingsoptionen** wie QLoRA, LoRA oder vollständiges Fine-Tuning, wobei Standardwerte bereits ausgefüllt sind * **Hilfreiche Konfigurationstools** für Splits, Spaltenzuordnung, Hyperparameter und YAML-Konfigurationen * **Hohe Sichtbarkeit beim Training** mit Live-Fortschritt, GPU-Statistiken, Diagrammen und Startstatus

### 1. Modell und Methode auswählen #### **Modelltyp** Wählen Sie die Modalität, die zu Ihrem Anwendungsfall passt: | Typ | Anwendungsfall | | -------------------- | -------------------------------------------- | | **Text** | Chat, Anweisungsbefolgung, Vervollständigung | | **Bildverarbeitung** | Bild + Text (VLMs) | | **Audio** | Sprach-/Audioverständnis | | **Embeddings** | Satz-Embeddings, Retrieval | #### **Trainingsmethode** Es stehen drei Methoden zur Verfügung, umschaltbar mit einem Pill-Selektor: | Methode | Beschreibung | VRAM | | ----------------------------- | ---------------------------------------------- | ---------- | | **QLoRA** | 4-Bit-quantisiertes Basismodell + LoRA-Adapter | Niedrigste | | **LoRA** | Basismodell in voller Präzision + LoRA-Adapter | Mittel | | **Vollständiges Fine-Tuning** | Alle Gewichte werden trainiert | Höchste | Geben Sie einen beliebigen Hugging-Face-Modellnamen ein oder suchen Sie den Hub direkt über das Kombinationsfeld. Lokal gespeicherte Modelle in `~/.unsloth/studio/models` und Ihr Hugging-Face-Cache erscheinen ebenfalls in der Liste. {% hint style="warning" %} Modelle im GGUF-Format sind vom Training ausgeschlossen - sie sind nur für die Inferenz. {% endhint %} Wenn Sie ein Modell auswählen, ruft Unsloth automatisch dessen Konfiguration vom Backend ab und füllt sinnvolle Standardwerte für alle Hyperparameter vorab aus. **HuggingFace-Token** Fügen Sie hier Ihren Hugging Face-Zugriffstoken ein, wenn das Modell geschützt ist (z. B. Llama, Gemma). Der Token wird in Echtzeit validiert, und bei Ungültigkeit wird ein Fehler direkt angezeigt. ### 2. Datensatz {% columns %} {% column %} Wechseln Sie zwischen zwei Tabs, um auszuwählen, woher Ihre Daten stammen: * **HuggingFace Hub** - Live-Suche im Hub. Das Datum der letzten Aktualisierung wird für jedes Ergebnis angezeigt. * **Lokal** - per Drag-and-drop ablegen oder klicken, um eine Datei hochzuladen; unstrukturierte oder strukturierte Dateien wie: `PDF`, `DOCX`, `JSONL`, `JSON`, `CSV`, oder `Parquet` Format. Zuvor hochgeladene Datensätze erscheinen in einer Liste, die sich automatisch aktualisiert. Sie können unseren ausführlichen [Leitfaden für Datensätze hier ansehen](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md). Weisen Sie Unsloth an, wie Ihre Daten interpretiert und formatiert werden sollen: {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} | Format | Wann verwenden | | ---------- | -------------------------------------------------- | | `auto` | Lassen Sie Unsloth das Format automatisch erkennen | | `alpaca` | `Anweisung` / `Eingabe` / `Ausgabe` Spalten | | `chatml` | OpenAI-Stil `Nachrichten` Array | | `sharegpt` | Unterhaltungen im ShareGPT-Stil | **Splits und Slicing** * **Teilmenge** - automatisch aus der Dataset-Card übernommen. * **Trainingssplit / Evaluationssplit** - wählen Sie aus, welche Splits verwendet werden sollen. Das Festlegen eines Evaluierungs-Splits aktiviert das **Evaluierungsverlust** Diagramm während des Trainings. * **Datensatz-Slice** - begrenzt das Training optional auf einen Zeilenbereich (Startindex / Endindex) für schnelle Experimente. **Spaltenzuordnung** Wenn Unsloth Ihre Datensatzspalten nicht automatisch den richtigen Rollen zuordnen kann, öffnet sich ein **Dialog zur Datensatzvorschau** öffnet sich. Er zeigt Beispielzeilen und ermöglicht es Ihnen, jede Spalte zu `Anweisung`, `Eingabe`, `Ausgabe`, `Bild`, usw. Vorgeschlagene Zuordnungen werden, wenn möglich, vorab ausgefüllt. ### 3. Hyperparameter Parameter sind in aufklappbare Abschnitte gruppiert. Sie können unseren ausführlichen [Leitfaden zu LoRA-Hyperparametern](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md) hier ansehen: {% content-ref url="/pages/ce825bbf83c91ef73a7fc71d696bd3d1ecc78590" %} [Hyperparameters Guide](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md) {% endcontent-ref %} | Parameter | Standard | Hinweise | | --------------------- | -------- | ------------------------------------------ | | **Maximale Schritte** | `0` | `0` bedeutet stattdessen Epochen verwenden | | **Kontextlänge** | `2048` | Optionen: 512 → 32768 | | **Lernrate** | `2e-4` | | **LoRA-Einstellungen** *(Wird ausgeblendet, wenn Full Fine-tuning ausgewählt ist)* | Parameter | Standard | Hinweise | | ----------------- | ---------- | --------------------------------------------------------------------------- | | **Rank** | `16` | Schieberegler 4–128 | | **Alpha** | `32` | Schieberegler 4–256 | | **Dropout** | `0.05` | | | **LoRA-Variante** | `LoRA` | `LoRA` / `RS-LoRA` / `LoftQ` | | **Zielmodule** | Alle aktiv | `q_proj`, `k_proj`, `v_proj`, `o_proj`, `gate_proj`, `up_proj`, `down_proj` | Für **Bildverarbeitung** Bei Modellen mit einem Bilddatensatz erscheinen vier zusätzliche Kontrollkästchen. Feintunen: | Vision-Schichten | Sprachschichten | Attention-Module | MLP-Module | | ---------------- | --------------- | ---------------- | ---------- | **Trainingshyperparameter** In drei Tabs organisiert: {% tabs %} {% tab title="Optimierung" %} | Parameter | Standard | | ---------------------- | ----------- | | Epochen | 3 | | Batch-Größe | 4 | | Gradientenakkumulation | 8 | | Gewichtsabfall | 0.01 | | Optimierer | AdamW 8-bit | {% endtab %} {% tab title="Zeitplan" %} | Parameter | Standard | | ---------------------------------- | -------- | | Lernraten-Scheduler | linear | | Warmup-Schritte | 5 | | Gradienten-Checkpointing | unsloth | | Zufalls-Seed | 3407 | | Speicherschritte | 0 | | Evaluierungs-Schritte | 0 | | Packing | false | | Auf Vervollständigungen trainieren | false | | {% endtab %} | | {% tab title="Protokollierung" %} | Parameter | Standard | | ------------------------ | -------------- | | W\&B aktivieren | false | | W\&B-Projekt | llm-finetuning | | TensorBoard aktivieren | false | | TensorBoard-Verzeichnis | runs | | Protokollierungsfrequenz | 10 | | {% endtab %} | | | {% endtabs %} | | {% hint style="info" %} [**Unsloth-Gradienten-Checkpointing**](/docs/de/blog/500k-context-length-fine-tuning.md#unsloth-gradient-checkpointing-enhancements)**: `unsloth`** verwendet Unsloths eigene speichereffiziente Implementierung, die die VRAM-Nutzung im Vergleich zur Standard-PyTorch-Option erheblich reduzieren kann. Sie ist die empfohlene Standardeinstellung. {% endhint %} ### 4. Training und Konfiguration Die Karte unten rechts hat drei Schaltflächen zur Konfigurationsverwaltung und die **Training starten** Schaltfläche. | Schaltfläche | Aktion | | ---------------- | ------------------------------------------------------------- | | **Hochladen** | Laden Sie eine zuvor gespeicherte `.yaml` Konfigurationsdatei | | **Speichern** | Exportieren Sie die aktuelle Konfiguration nach YAML | | **Zurücksetzen** | Setzt alle Parameter auf die Standardwerte des Modells zurück | Die Schaltfläche Training starten bleibt deaktiviert, bis sowohl ein Modell als auch ein Datensatz konfiguriert sind. Validierungsfehler werden direkt angezeigt - zum Beispiel, wenn Evaluierungsschritte festgelegt werden, ohne einen Evaluierungs-Split auszuwählen, oder wenn ein rein textbasiertes Modell mit einem Vision-Datensatz gekoppelt wird. #### Ladebildschirm {% columns %} {% column %} Nachdem Sie auf **Training starten**, erscheint ein bildschirmfüllendes Overlay, während das Backend alles vorbereitet.

{% endcolumn %} {% column %} Das Overlay zeigt ein animiertes Terminal mit Live-Phasenaktualisierungen: * Blau: Modell / Datensatz wird heruntergeladen * Bernstein: Modell / Datensatz wird geladen * Blau: Konfiguration * Grün: Training Sie können jederzeit abbrechen, indem Sie die **×** Schaltfläche in der Ecke verwenden. Bevor etwas gestoppt wird, erscheint ein Bestätigungsdialog. {% endcolumn %} {% endcolumns %} ### Trainingsfortschritt und Beobachtbarkeit Sobald der erste Trainingsschritt erreicht ist, verschwindet das Overlay und die Live-Trainingsansicht wird angezeigt. Der Feintuning-Prozess ist abgeschlossen, wenn die Schritte auf dem Fortschrittsbalken 100 % erreichen. Sie können die verstrichene Zeit und die Token anzeigen.

{% columns %} {% column %} #### Statusbereich Die linke Spalte zeigt: * **Epoche** - aktuelle Bruch-Epoche (z. B. `Epoche 1.23`) * **Fortschrittsbalken** - schrittbasiert, mit Prozentangabe * **Wichtige Kennzahlen**: * **Verlust** - Trainingsverlust auf 4 Dezimalstellen * **LR** - aktuelle Lernrate in wissenschaftlicher Notation * **Grad-Norm** - Gradienten-Norm * **Modell** - das trainierte Modell * **Methode** - `QLoRA` / `LoRA` / `Vollständig` * **Zeitzeile** - verstrichene Zeit, ETA, Schritte pro Sekunde und insgesamt verarbeitete Token {% endcolumn %} {% column %} #### GPU-Monitor Die rechte Spalte zeigt alle paar Sekunden abgefragte Live-GPU-Statistiken: * **Auslastung** - Prozentbalken * **Temperatur** - °C-Balken * **VRAM** - verwendet / insgesamt GB * **Leistung** - Verbrauch / Limit in Watt #### Training beenden Verwenden Sie die **Training stoppen** Schaltfläche oben rechts in der Fortschrittskarte. Ein Dialog bietet Ihnen zwei Optionen: * **Stoppen & Speichern** - speichert einen Checkpoint vor dem Stoppen * **Abbrechen** - stoppt sofort ohne Checkpoint {% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### Diagramme Vier Live-Diagramme aktualisieren sich, während das Training fortschreitet: 1. **Trainingsverlust** - Rohwerte plus eine EMA-geglättete Linie und eine Referenzlinie des laufenden Durchschnitts 2. **Lernrate** - die LR-Planungskurve 3. **Grad-Norm** - Gradienten-Norm über die Schritte 4. **Evaluierungsverlust** - wird nur angezeigt, wenn Sie einen Evaluierungs-Split konfiguriert haben {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column %} Jedes Diagramm hat Einstellungen (Zahnrad-Symbol) mit: | Option | Standard | | --------------------------- | ---------------------------------------- | | Anzeigefenster | Schieberegler für die letzten N Schritte | | EMA-Glättung | `0.6` | | Roh anzeigen | Ein | | Geglättet anzeigen | Ein | | Durchschnittslinie anzeigen | Ein | | Skalierung (pro Reihe) | Linear / Logarithmisch | | Ausreißer-Clipping | Kein Clipping / p99 / p95 | | {% endcolumn %} | | {% column %}

{% endcolumn %} {% endcolumns %} #### Konfigurationsdateien {% columns %} {% column %} Alle Trainingskonfigurationen können als YAML-Dateien gespeichert und erneut geladen werden. Die Dateien werden automatisch benannt als: ``` {model}_{method}_{dataset}_{timestamp}.yaml ``` {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} Die YAML ist in drei Abschnitte unterteilt: {% code expandable="true" %} ```yaml training: max_steps: 0 num_train_epochs: 3 per_device_train_batch_size: 4 ... lora: r: 16 lora_alpha: 32 ... Protokollierung: report_to: keine ... ``` {% endcode %} Dadurch lässt sich das Ausführen von Experimenten einfach reproduzieren, Konfigurationen teilen oder Ihre Experimente per Versionsverwaltung verwalten. ## Datenrezepte - Schnellstart [Unsloth-Datenrezepte](/docs/de/neu/studio/data-recipe.md) ermöglicht Ihnen, Dokumente wie PDFs oder CSV-Dateien hochzuladen und sie in nutzbare Datensätze umzuwandeln. Erstellen und bearbeiten Sie Datensätze visuell über einen Workflow aus Graphenknoten. Die Rezepte-Seite ist der zentrale Einstiegspunkt. Rezepte werden lokal im Browser gespeichert, sodass Sie später zu gespeicherten Arbeiten zurückkehren können. Von hier aus können Sie ein leeres Rezept erstellen oder ein geführtes Lernrezept öffnen.

Data Recipes folgt demselben grundlegenden Ablauf. Sie öffnen die Rezepte-Seite, erstellen oder wählen ein Rezept, bauen den Workflow im Editor auf, validieren ihn, führen eine Vorschau aus und starten dann den vollständigen Datensatz, sobald die Ausgabe korrekt aussieht. Fügen Sie Seed-Daten und Generierungsblöcke hinzu, validieren Sie den Workflow, sehen Sie sich die Beispielausgabe in der Vorschau an und führen Sie dann einen vollständigen Datensatz-Build aus. Unsloth Data Recipes wird von NVIDIA unterstützt [DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner). Auf einen Blick sollte ein typischer Workflow so aussehen: 1. Öffnen Sie die Rezepte-Seite. 2. Erstellen Sie ein neues Rezept oder öffnen Sie ein vorhandenes. 3. Fügen Sie Blöcke hinzu, um Ihren Datensatz-Workflow zu definieren. 4. Klicken Sie auf **Validieren** um Konfigurationsprobleme frühzeitig zu erkennen. 5. Führen Sie eine Vorschau aus, um Beispielzeilen schnell zu überprüfen. 6. Führen Sie einen vollständigen Datensatz-Build aus, wenn das Rezept fertig ist. 7. Überprüfen Sie Fortschritt und Ausgabe live im Graphen oder in **Ausführungen** Ansicht für weitere Details. 8. Wählen Sie den resultierenden Datensatz in **Unsloth** aus und führen Sie ein Modell-Finetuning durch. ## Export - Schnellstart Verwenden Sie Unsloth Studio „Export“, um Modelle für die Bereitstellung, das Teilen oder die lokale Inferenz in Unsloth, llama.cpp, Ollama, vLLM und mehr als GGUF, Safetensors oder LoRA zu exportieren, zu speichern oder zu konvertieren. Exportieren Sie einen trainierten Checkpoint oder konvertieren Sie ein beliebiges vorhandenes Modell.

Hier können Sie unser ausführliches Tutorial / Handbuch zum Exportieren von Modellen mit Unsloth Studio lesen: {% content-ref url="/pages/13c9d0063a9732a68734b74792f3e30153873bf4" %} [Model Export](/docs/de/neu/studio/export.md) {% endcontent-ref %} ## Videoanleitung {% hint style="warning" %} Die in den Videos gezeigten Unsloth-Studio-Versionen sind alt und entsprechen nicht der aktuellen Version. {% endhint %} {% columns %} {% column %} {% embed url="" %} Hier ist eine von NVIDIA erstellte Videoanleitung, um Ihnen den Einstieg mit Unsloth zu erleichtern: {% endcolumn %} {% column %} {% embed url="" %} Videoanleitung: So installieren Sie Unsloth Studio {% endcolumn %} {% endcolumns %} ## Erweiterte Einstellungen ### CLI-Befehle Die Unsloth-CLI (`cli.py`) bietet die folgenden Befehle: ``` Verwendung: cli.py [BEFEHL] Befehle: train Modell feinabstimmen inference Inferenz auf einem trainierten Modell ausführen export Einen trainierten Adapter exportieren list-checkpoints Gespeicherte Checkpoints auflisten ui Die Web-UI von Unsloth Studio starten studio Das Studio starten (Alias) ``` ### Projektstruktur {% code expandable="true" %} ``` new-ui-prototype/ ├── cli.py # CLI-Einstiegspunkt ├── cli/ # Typer-CLI-Befehle │ └── commands/ │ ├── train.py │ ├── inference.py │ ├── export.py │ ├── ui.py │ └── studio.py ├── setup.sh # Bootstrap-Skript (Linux / WSL / Colab) ├── setup.ps1 # Bootstrap-Skript (native Windows) ├── setup.bat # Wrapper zum Starten von setup.ps1 per Doppelklick ├── install_python_stack.py # Plattformübergreifender Installer für Python-Abhängigkeiten └── studio/ ├── backend/ │ ├── main.py # FastAPI-App & Middleware │ ├── run.py # Server-Startprogramm (uvicorn) │ ├── auth/ # Auth-Speicher & JWT-Logik │ ├── routes/ # API-Routenhandler │ │ ├── training.py │ │ ├── models.py │ │ ├── inference.py │ │ ├── datasets.py │ │ └── auth.py │ ├── models/ # Pydantic-Anfrage-/Antwortschemas │ ├── core/ # Trainings-Engine & Konfiguration │ ├── utils/ # Hardwareerkennung, Hilfsfunktionen │ └── requirements.txt ├── frontend/ │ ├── src/ │ │ ├── features/ # Feature-Module │ │ │ ├── auth/ # Anmelde-/Registrierungsablauf │ │ │ ├── training/ # Trainingskonfiguration & -überwachung │ │ │ ├── studio/ # Hauptarbeitsbereich des Studios │ │ │ ├── chat/ # Chat-UI für Inferenz │ │ │ ├── export/ # Modell-Exportablauf │ │ │ └── onboarding/# Onboarding-Assistent │ │ ├── components/ # Gemeinsame UI-Komponenten (shadcn) │ │ ├── hooks/ # Benutzerdefinierte React-Hooks │ │ ├── stores/ # Zustand-State-Stores │ │ └── types/ # TypeScript-Typdefinitionen │ ├── package.json │ └── vite.config.ts └── tests/ # Backend-Testsuite ``` {% endcode %} ### API-Referenz Alle Endpunkte erfordern ein gültiges JWT `Authorization: Bearer ` Header (außer `/api/auth/*` und `/api/health`). | Methode | Endpunkt | Beschreibung | | ------- | --------------------- | ------------------------------------------------------------- | | `GET` | `/api/health` | Integritätsprüfung | | `GET` | `/api/system` | Systeminformationen (GPU, CPU, Arbeitsspeicher) | | `POST` | `/api/auth/signup` | Konto erstellen (erfordert beim ersten Start ein Setup-Token) | | `POST` | `/api/auth/login` | Anmelden und JWT-Token erhalten | | `POST` | `/api/auth/refresh` | Ein abgelaufenes Zugriffstoken aktualisieren | | `GET` | `/api/auth/status` | Prüfen, ob die Authentifizierung initialisiert ist | | `POST` | `/api/train/start` | Einen Trainingsjob starten | | `POST` | `/api/train/stop` | Einen laufenden Trainingsjob stoppen | | `POST` | `/api/train/reset` | Trainingsstatus zurücksetzen | | `GET` | `/api/train/status` | Aktuellen Trainingsstatus abrufen | | `GET` | `/api/train/metrics` | Trainingsmetriken abrufen (Loss, LR, Schritte) | | `GET` | `/api/train/stream` | SSE-Stream des Trainingsfortschritts in Echtzeit | | `GET` | `/api/models/` | Verfügbare Modelle auflisten | | `POST` | `/api/inference/chat` | Eine Chat-Nachricht für die Inferenz senden | | `GET` | `/api/datasets/` | Datensätze auflisten / verwalten | --- # 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://unsloth.ai/docs/de/neu/studio/start.md?ask=&goal= ``` `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.