# 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 einfaches Ausführen und Bereitstellen von **GGUF** Modellen (llama.cpp-Format).

Du kannst unser [LM Studio-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-LMStudio.ipynb) oder folgen Sie den Anweisungen unten:

1. **Exportieren Sie Ihr in Unsloth feinabgestimmtes Modell nach `.gguf`**
2. **Importieren / laden Sie die GGUF in LM Studio**
3. **Laden Sie es im Chat** (oder betreiben Sie es hinter einer OpenAI-kompatiblen lokalen API)

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

### 1) Exportieren 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 ins Hugging Face Hub hochladen
model.push_to_hub_gguf("hf_username/my_model_gguf", tokenizer, quantization_method = "q4_k_m")
```

{% hint style="info" %}
`q4_k_m` ist normalerweise die Standardeinstellung für lokale Läufe.

`q8_0` ist die optimale Wahl für nahezu vollpräzise Qualität.

`f16` ist am größten / langsamsten, aber originale unquantisierte Präzision.
{% endhint %}

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

{% tabs %}
{% tab title="CLI-Import (lms import)" %}
LM Studio bietet ein CLI namens `lms` das eine lokale `.gguf` in den Models-Ordner von LM Studio importieren kann.

**Importieren Sie eine GGUF-Datei:**

```bash
lms import /path/to/model.gguf
```

**Behalten Sie die Originaldatei (kopieren statt verschieben):**

```bash
lms import /path/to/model.gguf --copy
```

<details>

<summary><strong>Klicken Sie für anpassbarere private Einstellungen</strong></summary>

**Behalten Sie das Modell, wo es ist (Symlink):**

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

```bash
lms import /path/to/model.gguf --symbolic-link
```

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

```bash
lms import /path/to/model.gguf --user-repo my-user/my-finetuned-models
```

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

```bash
lms import /path/to/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 innerhalb von LM Studio herunterladen.

**Option A: Verwenden Sie den In-App-Downloader von LM Studio**

1. Öffnen Sie LM Studio
2. Gehen Sie zum **Entdecken** 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: Verwenden Sie den CLI-Downloader**

```bash
# Von HF per Repo-Name 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 Modellverzeichnisstruktur legen.

LM Studio erwartet Modelle in dieser Struktur:

```
~/.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 überprüfen Sie **Meine Modelle**.

**Tipp:** Sie können Ihr Models-Verzeichnis aus dem **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 die **Modell-Lader**
3. Wählen Sie Ihr importiertes Modell aus
4. (Optional) Ladeeinstellungen anpassen (GPU-Offload, Kontextlänge, usw.)
5. Chatten Sie normal in der Benutzeroberfläche

### 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 (Developer-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 typischerweise `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
```

Anmerkungen:

* `--gpu=1.0` bedeutet „versuche, 100 % auf GPU auszulagern“
* Sie können eine stabile Kennung festlegen:

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

#### 3) Starten Sie den Server

```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 entsprechend den Anforderungen Ihres Modells an
)

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

{% endcode %}

**cURL-Beispiel (Chat-Completions):**

{% 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 entsprechend den Anforderungen Ihres Modells an
  }'
```

{% endcode %}

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

### Fehlerbehebung

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

Dies ist fast immer ein **Prompt-Vorlagen- / Chat-Vorlagen-Mismatch**.

LM Studio wird **automatisch erkennen** die Prompt-Vorlage aus den GGUF-Metadaten, wenn möglich, aber benutzerdefinierte oder falsch markierte 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 mit der Vorlage übereinstimmt, mit der Sie trainiert haben
3. Alternativ: Aktivieren Sie in der Chat-Seitenleiste die **Prompt-Vorlage** Box (Sie können erzwingen, dass sie immer angezeigt wird)

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

* Bevorzugen `lms import /path/to/model.gguf`
* Oder bestätigen Sie, dass die Datei in der korrekten Ordnerstruktur liegt: `~/.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 den GPU-Offload an (LM Studio „Standardwerte pro Modell“ / Ladeeinstellungen)

***

### Mehr Ressourcen

* [LM Studio + Unsloth Blog-Beitrag](https://lmstudio.ai/blog/functiongemma-unsloth) (FunctionGemma Durchgang):&#x20;
* LM Studuo [Import Models Dokumentation](https://lmstudio.ai/docs/app/advanced/import-model)
* LM Studio [Prompt Template Dokumentation](https://lmstudio.ai/docs/app/advanced/prompt-template)
* LM Studio [OpenAI-kompatible API-Dokumentation](https://lmstudio.ai/docs/developer/openai-compat)


---

# Agent Instructions: 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.