# Hermes Agent mit lokalem Modell: Ollama verbinden

> So verbindest du ein lokales Modell mit Hermes Agent: Local Models in der Desktop-App oder Ollama, ein Modell mit Tool-Aufrufen, 64.000 Kontext und wie du überprüfst, ob es funktioniert.

Source: https://ailoot.ai/blog/de/hermes-local-model-ollama-context/
Canonical: https://ailoot.ai/blog/de/hermes-local-model-ollama-context/
Language: de
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-115
Revision: sha256-1522cd1523d476698ecbc51c7e168486212f2a8a08ea8308cbd8bc7a26a62c7f


Du kannst ein lokales Modell in der Desktop-App mit Hermes Agent verbinden: mit vier Klicks über Einstellungen → Anbieter → Local Models oder manuell über Ollama. In beiden Fällen brauchst du keinen Schlüssel, zahlst nicht für jede Anfrage und die Unterhaltung verlässt deinen Rechner nicht.

Ein lokales Modell kostet im Betrieb nichts, und Hermes kann damit arbeiten. Entscheidend ist, ein Modell auszuwählen, das mit Dateien und Befehlen arbeiten kann, und ihm einen Kontext von mindestens 64.000 zu geben. Andernfalls wird der Agent zu einem gewöhnlichen Chat.

Sehen wir uns an, wofür ein lokales Modell heute nützlich ist, wie du es verbindest und wie du überprüfst, ob der Agent mit Dateien arbeitet. Los geht’s.

Ailoot-Referenzdokumentation: [ailoot.ai/docs/](https://ailoot.ai/docs/).



<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Das Wichtigste in diesem Abschnitt">

Das Wichtigste

Am einfachsten geht es in Hermes Desktop: Einstellungen → Anbieter → Local Models, Install runtime auswählen, ein Modell wählen, auf Download und dann auf Use klicken. Die App wählt die Kontextgröße für dich aus. Mit Ollama: Lade ein Modell mit Tool-Aufrufen herunter (aus Hermes’ Tabelle unterstützt nur `gemma4:31b` diese Funktion, und es benötigt mindestens 24 GB Arbeitsspeicher), stelle den Kontext auf 64.000 statt auf den Standardwert 2.048 ein und wähle in `hermes setup` Custom Endpoint mit der Adresse `http://localhost:11434/v1` und ohne Schlüssel. Überprüfe es mit einer Aufgabe, deren Ergebnis auf der Festplatte landet, und nicht anhand des Antworttexts.

</div>

## Solltest du einen Agenten mit einem lokalen Modell betreiben?





Wofür lokale Modelle bereits nützlich sind:

- **Sprache transkribieren.** Dafür gibt es kostenlose Open-Source-Modelle: Sie sind klein und erkennen Sprache gut. Deine Stimme gelangt nicht in die Cloud, sodass all deine raffinierten Pläne bei dir bleiben. Eine Anleitung zur Einrichtung findest du [in einem separaten Artikel](https://ailoot.ai/blog/de/free-voice-input-whisper/).
- **Routineaufgaben.** Für Routineaufgaben kannst du bereits kleine, dumme Modelle einsetzen: Damit kommen sie zurecht.
- **Daten, die du nicht nach außen senden möchtest.** Wenn du wirklich Bedenken hast, kannst du ein Modell auf deinem eigenen Rechner ausführen. Die Qualität wird allerdings schlecht sein.

Nächstes Jahr werden lokale Modelle wahrscheinlich noch weniger Platz beanspruchen. Es gibt bereits leistungsstarke Komprimierungsmethoden, und du kannst statt Videospeicher den Arbeitsspeicher verwenden. Ich denke, in etwa einem Jahr wird jeder eine kleine Box mit einem kleinen, dummen Modell haben, das Aufgaben auf dem Niveau von Sonnet 5 erledigt. Mal sehen.

Für die Einrichtung ist es hilfreich, eine Tabelle „Welches Modell für welche Aufgabe“ und ein PDF mit Hermes-Installationsbefehlen bereitzuhalten.

## Der einfachste Weg: Local Models in Hermes Desktop

Wenn du die Hermes-Desktop-App hast, musst du nichts manuell installieren. Hermes installiert den lokalen llama.cpp-Server, lädt ein Modell herunter und wählt die Kontextgröße für dich aus:

1. Öffne **Einstellungen → Anbieter → Local Models** oder wähle beim ersten Start **Run models locally**.
2. Klicke auf **Install runtime**: Hermes lädt einen llama.cpp-Build für deine Hardware herunter. Er ist einige Hundert Megabyte groß.
3. Wähle ein Modell aus dem Katalog und klicke auf **Download**.
4. Klicke auf **Use**: Neue Chats werden dann über das lokale Modell geführt.

Jedes Modell im Katalog hat eine farbige Kennzeichnung: Grün bedeutet, dass es vollständig in den Videospeicher passt; Gelb bedeutet, dass es über den Arbeitsspeicher läuft und langsamer ist; Rot bedeutet, dass es für deinen Rechner zu groß ist. Für empfohlene Modelle stellt die App einen Kontext von mindestens 64.000 ein. Eine Grafikkarte mit mindestens 8 GB kann die kleineren Modelle aus dem Katalog ausführen; eine mit mindestens 16 GB kann Modelle mit 27-35B ausführen. Wenn du ein Modell 15 Minuten lang nicht verwendest, entlädt die App es aus dem Speicher. Sobald du wieder eine Nachricht sendest, lädt sie es erneut.

Der Abschnitt ist in den Test- (Canary-)Builds der App enthalten. In anderen Builds kannst du ihn mit dem Startflag `--local` öffnen. Wenn Local Models nicht in den Einstellungen angezeigt wird, liegt es höchstwahrscheinlich daran. Im Terminal führt derselbe Weg über `hermes model` → **Local models**.

Nachdem du ein Modell ausgewählt hast, überprüfe es mit einer Aufgabe, bei der eine Datei verwendet wird, wie im folgenden Abschnitt beschrieben.

Wenn du eigene Projekte mit KI-Agenten entwickelst, überprüfe das Ergebnis anhand einer kleinen, realen Aufgabe.



## Ollama verwenden: Welche Hardware du brauchst

Du brauchst Ollama, wenn Hermes auf einem Server installiert ist oder der Abschnitt Local Models fehlt. Die Hardwareanforderungen laut Hermes-Anleitung:

| Was | Minimum | Besser |
|----|----|----|
| Arbeitsspeicher | 8 GB (3B-Modelle) | mindestens 32 GB (27B+-Modelle) |
| Speicherplatz | 5 GB | mindestens 30 GB, wenn du mehrere Modelle hast |
| Prozessor | 4 Kerne | mindestens 8 Kerne |
| Grafikkarte | Nicht erforderlich | NVIDIA mit mindestens 8 GB Videospeicher macht einen deutlichen Unterschied |

8 GB reichen nur für ein kleines Modell, das ausschließlich Text ausgibt. Damit das Modell als Agent arbeiten kann, brauchst du mindestens 24 GB; Details dazu findest du in Schritt 2. Alles funktioniert auch ohne Grafikkarte, aber langsam: Ein 9B-Modell auf einem Prozessor mit 8 Kernen erzeugt etwa 10 Tokens pro Sekunde, ein 31B-Modell 2-5, und jede Antwort dauert 30-120 Sekunden.

## Schritt 1. Ollama installieren

Ollama führt Modelle direkt auf deinem Rechner aus. Installiere es auf Mac und Linux mit einem Befehl im Terminal:

```bash
curl -fsSL https://ollama.com/install.sh | sh
```

Unter Windows lautet der PowerShell-Befehl:

```powershell
irm https://ollama.com/install.ps1 | iex
```

Überprüfe, ob das Programm installiert ist und der Server antwortet:

```bash
ollama --version
curl http://localhost:11434/api/tags
```

Wenn du noch keine Modelle hast, gibt der zweite Befehl eine leere Liste zurück. Merke dir Port 11434: Über ihn greift Hermes auf das Modell zu.

## Schritt 2. Ein Modell herunterladen, das handeln kann

Was macht ein Modell? Es erzeugt Text. Der Wrapper darum, Hermes, übernimmt die Arbeit mit Dateien, Terminalbefehlen und der Suche. Damit der Wrapper funktioniert, muss das Modell Tools aufrufen können. Ohne diese Fähigkeit antwortet der Agent nur und tut nichts.

| Modell        | Auf dem Datenträger | Arbeitsspeicher | Tool-Aufrufe |
|---------------|----------|--------|--------------------|
| `gemma4:31b`  | ~20 GB   | mindestens 24 GB | ja                |
| `gemma2:27b`  | ~16 GB   | mindestens 20 GB | nein                 |
| `gemma2:9b`   | ~5 GB    | mindestens 8 GB  | nein                 |
| `llama3.2:3b` | ~2 GB    | mindestens 4 GB  | nein                 |

Von diesen vier Modellen funktioniert nur `gemma4:31b` als Agent. Wenn du weniger als 24 GB Arbeitsspeicher hast, kannst du keinen Agenten ausführen: Die Modelle in der Tabelle geben dann nur Text aus. In der Ollama-Bibliothek erscheinen ständig neue Modelle. Prüfe bei jedem zuerst, ob es Tools aufrufen kann.

```bash
ollama pull gemma4:31b
```

Du kannst mehrere Modelle herunterladen und in Hermes mit dem Befehl `/model` zwischen ihnen wechseln.

## Schritt 3. Den Kontext auf 64.000 erhöhen

Standardmäßig gibt Ollama dem Modell einen Kontext von 2.048 Tokens, während Hermes für die Arbeit mit Tools mindestens 64.000 braucht. Mit dem Standardkontext passt die Aufgabe nicht hinein, und beim Agenten treten Fehler auf.

Erstelle eine Modellvariante mit größerem Kontext. Führe dazu Folgendes im Terminal aus:

```bash
cat > Modelfile << 'EOF'
FROM gemma4:31b
PARAMETER num_ctx 64000
EOF

ollama create gemma4-64k -f Modelfile
```

Jetzt hast du das Modell `gemma4-64k`. Verwende von nun an überall dieses Modell statt des Originals.

## Schritt 4. Mit Hermes verbinden

Starte den Einrichtungsassistenten:

```bash
hermes setup
```

Wenn du nach dem Anbieter gefragt wirst, wähle **Custom Endpoint** und gib Folgendes ein:

- Adresse: `http://localhost:11434/v1`;
- Schlüssel: leer lassen oder `no-key` eingeben;
- Modell: `gemma4-64k`.

Du kannst dieselbe Konfiguration auch manuell in `~/.hermes/config.yaml` eintragen:

```yaml
model:
  default: "gemma4-64k"
  provider: "custom"
  base_url: "http://localhost:11434/v1"
```

## So überprüfst du, ob der Agent funktioniert

Führe `hermes` aus und gib dem Agenten eine Aufgabe, deren Ergebnis auf der Festplatte sichtbar ist. Zum Beispiel: „Liste alle Python-Dateien in diesem Ordner auf und zähle die Zeilen in jeder Datei.“ Gib ihm anschließend den Auftrag: „Erstelle eine Datei namens test.txt.“ Prüfe mit dem Befehl `ls` oder direkt im Ordner, ob die Datei erschienen ist. Ein Modell ohne Tools kann problemlos eine plausibel wirkende Liste ausgeben, ohne auch nur eine einzige Datei zu öffnen.

Je günstiger das neuronale Netz ist, das du verwendest, desto fortgeschrittener muss der Editor aus Leder sein, den es braucht. Das bist du. Je intelligenter dein neuronales Netz ist, desto weniger musst du deinen eigenen Kopf einsetzen, aber arbeiten musst du immer.

Video zur vollständigen Einrichtung von Hermes Agent von Grund auf:

<figure>
Das Video wird geladen, wenn du weiter nach unten scrollst.
<figcaption>Vollständige Anleitung zu Hermes Agent von Grund auf für die Geschäftsautomatisierung</figcaption>
</figure>

Das Video zeigt, wie du Hermes von Grund auf installierst, deinen ersten KI-Mitarbeiter erstellst und die Bezahlung pro Anfrage mit einem Abonnement vergleichst.

## Warum die erste Antwort mehrere Minuten dauert

Bei jeder Anfrage sendet Hermes einen festen Teil mit: die Systemanweisungen und Beschreibungen aller aktivierten Tools. Ohne Grafikkarte braucht das Modell lange, um diesen Teil zu verarbeiten, und schreibt anschließend mit seiner üblichen Geschwindigkeit. Das ist normal.

Was hilft:

- `hermes prompt-size` zeigt, wie groß der feste Teil ist;
- `hermes tools` deaktiviert nicht benötigte Tool-Sets, und mit `hermes skills` kannst du überflüssige Skills entfernen. Jedes verbundene MCP (externer Dienst) macht jede Anfrage größer: Wenn du es nicht nutzt, schalte es aus;
- `ollama ps` zeigt, wie viele Modellschichten auf die Grafikkarte ausgelagert wurden. Auch eine teilweise Auslagerung beschleunigt die Verarbeitung: Ein 31B-Modell legt auf einer Grafikkarte mit 12 GB etwa 40 Schichten ab; den Rest übernimmt der Prozessor;
- stelle auf einem langsamen Rechner `HERMES_API_TIMEOUT=1800` in `~/.hermes/.env` ein, damit Hermes die Anfrage nicht wegen einer Zeitüberschreitung abbricht.

Wenn der Agent rund um die Uhr auf einem Server läuft oder über Telegram antwortet, beachte Folgendes: Ollama entlädt das Modell nach 5 Minuten Inaktivität, und die nächste Antwort beginnt wieder mit dem Laden. Die Ollama-Einstellung `OLLAMA_KEEP_ALIVE=24h` hält das Modell im Speicher. Eine Anleitung, wie du den Agenten auf einen Server verschiebst, findest du [im Artikel über den rund um die Uhr laufenden Hermes Agent auf einem Server](https://ailoot.ai/blog/de/hermes-agent-vps-24-7/), eine Anleitung zum Einrichten eines Bots [in der Hermes-Anleitung zur Telegram-Einrichtung](https://ailoot.ai/blog/de/hermes-agent-telegram-setup/).

## Wenn etwas schiefläuft

| Was du siehst | Was zu tun ist |
|----|----|
| „Connection refused“ beim Start | Ollama läuft nicht: `ollama serve` oder `sudo systemctl start ollama` |
| `provider 'ollama' has no endpoint configured` | Trage die Ollama-Adresse in `providers.ollama.base_url` oder `model.base_url` ein |
| Der Agent antwortet, tut aber nichts | Das Modell kann keine Tools aufrufen; installiere `gemma4:31b` und gib ihm einen Kontext von 64.000 |
| Fehler wegen des Kontexts | Schritt 3 wurde nicht ausgeführt |
| Lange Unterhaltungen sind langsam | Führe regelmäßig `/compress` aus |

## Ein Cloud-Modell als Ausweichlösung

Die Hermes-Dokumentation empfiehlt, ein lokales Modell als Hauptmodell zu verwenden und ein Cloud-Modell als Ausweichlösung zu verbinden. Füge dazu den Dokumentationsblock neben dem Abschnitt `model` in `~/.hermes/config.yaml` ein:

[Anleitungen zu Tools in der Ailoot-Dokumentation finden](https://ailoot.ai/docs/)

Wenn das lokale Modell dreimal fehlschlägt, sendet Hermes die Aufgabe an das Cloud-Modell. Diese Anfragen sind kostenpflichtig und gehen an die Cloud.

Eine weitere Möglichkeit ist, ein leistungsstarkes Abonnementmodell zum Nachdenken und für Entscheidungen einzusetzen und das lokale Modell Routineaufgaben übernehmen zu lassen. Ziel ist es, die Qualität zu erhalten und die Tokenkosten schrittweise zu senken. Bei diesem Ansatz kommen für einzelne Schritte günstigere Modelle zum Einsatz; lokale Modelle können später eine Option sein. Im Artikel „Wie viel kostet ein KI-Agent für Unternehmen?“ erfährst du, was Agenten mit Abonnement kosten. Wenn du Hermes noch nicht installiert hast, beginne mit der Anleitung zur [Installation von Hermes Agent](https://ailoot.ai/blog/de/hermes-agent-install-setup/).

Hast du schon versucht, ein lokales Modell einzurichten? Was lässt du darauf laufen? Erzähl es uns; wir sind neugierig.

<div class="section" role="doc-bibliography" aria-label="Quellen">

### Quellen

- [Hermes Agent: Run Hermes Locally with Ollama](https://raw.githubusercontent.com/NousResearch/hermes-agent/357f51c49106f47136caf9b01015467b7b633fe8/website/docs/guides%2Flocal-ollama-setup.md) – Hardwareanforderungen, Installation und Überprüfung von Ollama, Modelltabelle und Tool-Aufrufe, Kontextgrößen von 2.048 und 64.000, Verbindung über Custom Endpoint, erste Antwort und Zeitüberschreitung, Entladen nach 5 Minuten, Fehlerbehebung und Fallback-Anbieter (geprüft am 7. Oktober 2026; entspricht der aktuellen Version).
- [Hermes Agent: Local Models](https://raw.githubusercontent.com/NousResearch/hermes-agent/main/website/docs/user-guide/local-models.md) – Local Models in der Desktop-App, Speicherkennzeichnungen, 64K-Kontext, Entladen nach 15 Minuten, `hermes model`, Flag `--local` (abgerufen am 7. Oktober 2026).
- [Ollama: download for Windows](https://ollama.com/download/windows) – Installationsbefehle für Mac, Linux und Windows (abgerufen am 7. Oktober 2026).

</div>








Erkunde Ailoot weiter unter [ailoot.ai](https://ailoot.ai/).

## Fragen und Antworten

### Wie prüfe ich Toolnutzung statt einer plausiblen Textantwort?

Gib Hermes eine kleine Dateiaufgabe und prüfe danach selbst den tatsächlichen Ordner und Dateiinhalt. Eine im Chat erzeugte Liste belegt nicht, dass das Modell Dateien gelesen oder ein Artefakt erstellt hat.

### Hält ein Fallback des lokalen Modells jede Anfrage auf meinem Rechner?

Nur solange Anfragen beim lokalen Modell bleiben. Der hier beschriebene optionale Fallback sendet die Aufgabe nach wiederholtem lokalem Scheitern an den Cloud-Anbieter. Diese Anfragen verlassen den Rechner und können kostenpflichtig sein.


## Ailoot · Das Unternehmen und sein Projektportfolio

Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle.

Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.

Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.