> 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/grundlagen/inference-and-deployment/lm-studio.md).

# Modelle in LM Studio bereitstellen

Sie können Ihr feinabgestimmtes LLM direkt in LM Studio ausführen und bereitstellen. [LM Studio](https://lmstudio.ai/) ermöglicht das einfache Ausführen und Bereitstellen von **GGUF** Modellen (llama.cpp-Format).

Sie können unser [LM Studio-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-LMStudio.ipynb) verwenden oder die folgenden Anweisungen befolgen:

1. **Exportieren Sie Ihr mit Unsloth feinabgestimmtes Modell nach `.gguf`**
2. **GGUF in LM Studio importieren / herunterladen**
3. **Laden Sie es im Chat** (oder führen Sie es hinter einer OpenAI-kompatiblen lokalen API aus)

<div><figure><img src="/files/c03dbe766cffaf7ac978ca7af3db5d000e6ae93c" alt="" width="375"><figcaption><p>Vor dem Finetuning in LM Studio</p></figcaption></figure> <figure><img src="/files/16833f5ca17c287d7a9f28edf41a0b926183d7b9" alt="" width="375"><figcaption><p>Nach dem Finetuning in LM Studio</p></figcaption></figure></div>

### 1) Export nach GGUF (aus Unsloth)

Wenn Sie bereits ein `.gguf`exportiert haben, springen Sie zu **Import in LM Studio**.

```python
# Lokal speichern (erstellt GGUF-Artefakte im Ordner)
model.save_pretrained_gguf("my_model_gguf", tokenizer, quantization_method = "q4_k_m")
# model.save_pretrained_gguf("my_model_gguf", tokenizer, quantization_method = "q8_0")
# model.save_pretrained_gguf("my_model_gguf", tokenizer, quantization_method = "f16")

# Oder GGUF zum Hugging Face Hub pushen
model.push_to_hub_gguf("hf_username/my_model_gguf", tokenizer, quantization_method = "q4_k_m")
```

{% hint style="info" %}
`q4_k_m` ist normalerweise der Standard für lokale Ausführungen.

`q8_0` ist optimal für Qualität nahe der Vollpräzision.

`f16` ist am größten / langsamsten, aber die ursprüngliche nicht quantisierte Präzision.
{% endhint %}

### 2) Importieren Sie das GGUF in LM Studio

{% tabs %}
{% tab title="CLI-Import (lms import)" %}
LM Studio stellt ein CLI-Tool namens `lms` bereit, das ein lokales `.gguf` in den Modelle-Ordner von LM Studio importieren kann.

**GGUF-Datei importieren:**

```bash
lms import /pfad/zu/model.gguf
```

**Die Originaldatei behalten (kopieren statt verschieben):**

```bash
lms import /pfad/zu/model.gguf --copy
```

<details>

<summary><strong>Für weitere anpassbare private Einstellungen klicken</strong></summary>

**Das Modell dort belassen, wo es ist (Symlink):**

Das ist hilfreich für große Modelle, die auf einem dedizierten Laufwerk gespeichert sind.

```bash
lms import /pfad/zu/model.gguf --symbolic-link
```

**Eingabeaufforderungen überspringen und den Ziel-Namespace selbst wählen:**

```bash
lms import /pfad/zu/model.gguf --user-repo my-user/my-finetuned-models
```

**Trockenlauf (zeigt, was passieren wird):**

```bash
lms import /pfad/zu/model.gguf --dry-run
```

</details>

Nach dem Import sollte das Modell in LM Studio unter **Meine Modelle**.

<figure><img src="/files/90595ebd1889cf792137924d7ab1ebdb62b5546b" alt=""><figcaption></figcaption></figure>
{% endtab %}

{% tab title="Von Hugging Face" %}
Wenn Sie Ihr GGUF-Repo zu Hugging Face gepusht haben, können Sie es direkt in LM Studio herunterladen.

**Option A: Den In-App-Downloader von LM Studio verwenden**

1. Öffnen Sie LM Studio
2. Gehen Sie zum **Discover** Tab
3. Suchen Sie nach `hf_username/repo_name` (oder fügen Sie die Hugging-Face-URL ein)
4. Laden Sie die gewünschte Quantisierung herunter (z. B. `Q4_K_M`)

**Option B: Den CLI-Downloader verwenden**

```bash
# Von HF anhand des Repo-Namens herunterladen
lms get hf_username/my_model_gguf

# Wählen Sie eine Quantisierung mit @
lms get hf_username/my_model_gguf@Q4_K_M
```

{% endtab %}

{% tab title="Manueller Import (Ordnerstruktur)" %}
Wenn Sie das CLI nicht verwenden möchten, können Sie die `.gguf` Datei in die von LM Studio erwartete Verzeichnisstruktur für Modelle legen.

LM Studio erwartet, dass Modelle so aussehen:

```
~/.lmstudio/models/
└── publisher/
    └── model/
        └── model-file.gguf
```

Beispiel:

```
~/.lmstudio/models/
└── my-name/
    └── my-finetune/
        └── my-finetune-Q4_K_M.gguf
```

Öffnen Sie dann LM Studio und prüfen Sie **Meine Modelle**.

**Tipp:** Sie können Ihr Modelle-Verzeichnis über den **Meine Modelle** Tab in LM Studio verwalten / überprüfen.
{% endtab %}
{% endtabs %}

### 3) Laden und chatten in LM Studio

1. Öffnen Sie LM Studio → **Chat**
2. Öffnen Sie den **Modell-Lader**
3. Wählen Sie Ihr importiertes Modell aus
4. (Optional) Ladeeinstellungen anpassen (GPU-Auslagerung, Kontextlänge usw.)
5. Normal im UI chatten

### 4) Stellen Sie Ihr feinabgestimmtes Modell als lokale API bereit (OpenAI-kompatibel)

LM Studio kann Ihr geladenes Modell hinter einer OpenAI-kompatiblen API bereitstellen (praktisch für Apps wie Open WebUI, benutzerdefinierte Agents, Skripte usw.).

{% tabs %}
{% tab title="GUI (Entwickler-Tab)" %}

1. Laden Sie Ihr Modell in LM Studio
2. Gehen Sie zum **Entwickler** Tab
3. Starten Sie den lokalen Server
4. Verwenden Sie die angezeigte Basis-URL (Standard ist normalerweise `http://localhost:1234/v1`)
   {% endtab %}

{% tab title="CLI (lms load + lms server start)" %}

#### 1) Verfügbare Modelle auflisten

```bash
lms ls
```

#### 2) Laden Sie Ihr Modell (optionale Flags)

```bash
lms load <model-identifier> --gpu=auto --context-length=8192
```

Hinweise:

* `--gpu=1.0` bedeutet „versuche, 100 % auf die GPU auszulagern“
* Sie können einen stabilen Bezeichner festlegen:

```bash
lms load <model-identifier> --identifier="my-finetuned-model"
```

#### 3) Den Server starten

```bash
lms server start --port 1234
```

{% endtab %}
{% endtabs %}

**Schnelltest: Modelle auflisten**

```bash
curl http://localhost:1234/v1/models
```

**Python-Beispiel (OpenAI SDK):**

{% code expandable="true" %}

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:1234/v1",
    api_key="lm-studio",  # LM Studio benötigt möglicherweise keinen echten Schlüssel; dies ist ein gängiger Platzhalter
)

resp = client.chat.completions.create(
    model="model-identifier-from-lm-studio",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello! What did I fine-tune you to do?"},
    ],
    temperature=0.7, # passen Sie die Temperatur an die Anforderungen Ihres Modells an
)

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

{% endcode %}

**cURL-Beispiel (Chat-Vervollständigungen):**

{% code expandable="true" %}

```bash
curl http://localhost:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "model-identifier-from-lm-studio",
    "messages": [
      {"role": "user", "content": "Say this is a test!"}
    ],
    "temperature": 0.7 # passen Sie die Temperatur an die Anforderungen Ihres Modells an
  }'
```

{% endcode %}

{% hint style="info" %}
**Debugging-Tipp:** Wenn Sie Probleme mit Formatierung/Vorlagen beheben, können Sie die *rohe* Eingabeaufforderung, die LM Studio an das Modell sendet, einsehen, indem Sie Folgendes ausführen: `lms log stream`
{% endhint %}

### Fehlerbehebung

#### **Modell läuft in Unsloth, aber die Ausgabe von LM Studio ist Kauderwelsch / wiederholt sich**

Das ist fast immer ein **Mismatch zwischen Prompt-Vorlage / Chat-Vorlage**.

LM Studio wird, **automatisch erkennen** die Prompt-Vorlage aus den GGUF-Metadaten, wenn möglich, aber benutzerdefinierte oder falsch getaggte Modelle benötigen möglicherweise eine manuelle Überschreibung.

**Behebung:**

1. Gehen Sie zu **Meine Modelle** → klicken Sie auf das Zahnrad ⚙️ neben Ihrem Modell
2. Finden Sie **Prompt-Vorlage** und setzen Sie sie so, dass sie zur Vorlage passt, mit der Sie trainiert haben
3. Alternativ können Sie in der Chat-Seitenleiste das **Prompt-Vorlage** Feld aktivieren (Sie können erzwingen, dass es immer angezeigt wird)

#### LM Studio zeigt mein Modell nicht unter „Meine Modelle“ an

* Bevorzugen Sie `lms import /pfad/zu/model.gguf`
* Oder bestätigen Sie, dass sich die Datei in der korrekten Ordnerstruktur befindet: `~/.lmstudio/models/publisher/model/model-file.gguf`

#### OOM / langsame Leistung

* Verwenden Sie eine kleinere Quantisierung (z. B.: `Q4_K_M`)
* Reduzieren Sie die Kontextlänge
* Passen Sie die GPU-Auslagerung an (LM Studio „Vorgaben pro Modell“ / Ladeeinstellungen)

***

### Weitere Ressourcen

* [LM Studio + Unsloth Blogbeitrag](https://lmstudio.ai/blog/functiongemma-unsloth) (FunctionGemma-Durchgang):&#x20;
* LM Studio [Dokumentation zum Import von Modellen](https://lmstudio.ai/docs/app/advanced/import-model)
* LM Studio [Dokumentation zu Prompt-Vorlagen](https://lmstudio.ai/docs/app/advanced/prompt-template)
* LM Studio [Dokumentation zur OpenAI-kompatiblen API](https://lmstudio.ai/docs/developer/openai-compat)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unsloth.ai/docs/de/grundlagen/inference-and-deployment/lm-studio.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.