> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-coding-tools/aider.md).

# Aider KI-Coding

Terminalbasiertes KI-Coding mit Aider auf Clore.ai — Git-bewusst, mehrere Dateien, lokale Modelle über Ollama

Aider ist ein terminalbasierter KI-Coding-Assistent mit über 39.000 GitHub-Sternen. Er bearbeitet Dateien direkt in deinem Repo, erstellt Git-Commits automatisch und unterstützt sowohl Cloud-APIs (OpenAI, Anthropic) als auch vollständig lokale Modelle über Ollama. Auf einer Clore.ai-GPU kannst du große Coding-Modelle wie DeepSeek-R1 32B oder Qwen2.5-Coder-32B vollständig auf deiner eigenen Hardware ausführen — privat, schnell und kosteneffizient.

{% hint style="success" %}
Alle Beispiele laufen auf GPU-Servern, die über die [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

## Hauptfunktionen

* **Terminal-nativ** — funktioniert über SSH, perfekt für headless Clore.ai-Server
* **Git-bewusst** — committet jede Änderung automatisch mit aussagekräftigen Nachrichten, leicht zu überprüfen und rückgängig zu machen
* **Bearbeitung mehrerer Dateien** — füge mehrere Dateien zum Kontext hinzu und bearbeite sie gleichzeitig
* **Unterstützung für lokale Modelle** — verbinde dich mit Ollama für vollständig privates Coden ohne API-Kosten
* **Architektenmodus** — verwende ein starkes Reasoning-Modell für die Planung und dann ein schnelles Modell für die Umsetzung
* **Repository-Map** — indexiert deine Codebasis automatisch für kontextbewusste Bearbeitungen
* **Linting und Tests** — führe nach jeder Bearbeitung Linter/Tests aus und behebe Fehler automatisch
* **Spracheingabe** — diktiere Coding-Anweisungen per Mikrofon

## Anforderungen

| Komponente | Minimum        | Empfohlen      |
| ---------- | -------------- | -------------- |
| GPU        | RTX 3060 12 GB | RTX 4090 24 GB |
| VRAM       | 12 GB          | 24 GB          |
| RAM        | 16 GB          | 32 GB          |
| Festplatte | 30 GB          | 60 GB          |
| Python     | 3.9            | 3.11           |

**Clore.ai-Preise:** RTX 4090 ≈ 0,14–0,42 $/Std. · RTX 3090 ≈ 0,07–0,21 $/Std. · RTX 3060 ≈ 0,03–0,07 $/Std.

Für reine Cloud-Modelle (keine lokale Inferenz) ist keine GPU erforderlich — aber Clore.ai-GPUs ermöglichen es dir, Ollama-Modelle lokal auszuführen, für volle Privatsphäre.

## Schnellstart

### 1. Installiere Aider

```bash
pip install aider-chat
```

### 2. Richte Ollama für lokale Modelle ein

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

# Lade ein Coding-Modell herunter
ollama pull deepseek-r1:32b

# Oder ein kleineres Modell für weniger VRAM
ollama pull qwen2.5-coder:7b
```

### 3. Starte Aider mit einem lokalen Modell

```bash
cd /workspace/your-project

# Nutze DeepSeek-R1 32B über Ollama (benötigt ~20 GB VRAM)
aider --model ollama/deepseek-r1:32b

# Oder verwende ein kleineres Modell auf der RTX 3060
aider --model ollama/qwen2.5-coder:7b
```

### 4. Mit dem Coden beginnen

Im Aider-REPL:

```
> /add src/main.py src/utils.py
> Füge der Funktion parse_config Fehlerbehandlung hinzu und schreibe Unit-Tests dafür
```

Aider wird:

1. Die Dateien lesen und die Codebasis verstehen
2. Änderungen als Diff vorschlagen
3. Die Änderungen auf der Festplatte anwenden
4. Einen Git-Commit mit einer aussagekräftigen Nachricht erstellen

## Anwendungsbeispiele

### Architektenmodus (Zwei-Modell-Setup)

Verwende ein starkes Modell für das Reasoning und ein schnelles Modell für die Codegenerierung:

```bash
# Cloud-Architekt + lokaler Editor
aider --architect --model ollama/deepseek-r1:32b --editor-model ollama/qwen2.5-coder:7b
```

Das Architektenmodell plant die Änderungen, und das Editor-Modell schreibt den eigentlichen Code — so werden hochwertige Schlussfolgerungen mit schneller Umsetzung kombiniert.

### Dateien hinzufügen und bearbeiten

```bash
# Bestimmte Dateien dem Chat-Kontext hinzufügen
> /add src/api/routes.py src/models/user.py

# Änderungen anfordern
> Refaktoriere den Endpunkt für die Benutzerregistrierung, um async/await zu verwenden, und füge Eingabevalidierung mit Pydantic hinzu

# Einen ganzen Ordner hinzufügen
> /add src/tests/

# Nach der Bearbeitung Tests ausführen
> /test pytest src/tests/ -v
```

### Mit Cloud-APIs verwenden

```bash
# OpenAI
export OPENAI_API_KEY=sk-...
aider --model gpt-4o

# Anthropic
export ANTHROPIC_API_KEY=sk-ant-...
aider --model claude-sonnet-4-20250514
```

### Git-Integration

```bash
# Jede Änderung erstellt automatisch einen Commit
git log --oneline -5
# a1b2c3d aider: Fehlerbehandlung zu parse_config hinzufügen
# d4e5f6g aider: Unit-Tests für parse_config schreiben
# h7i8j9k aider: Endpunkt für Benutzerregistrierung refaktorisieren

# Die letzte Aider-Änderung rückgängig machen
aider --undo
```

### Linten und automatisch beheben

```bash
# Einen Linter konfigurieren
aider --lint-cmd "ruff check --fix" --auto-lint

# Aider führt nach jeder Bearbeitung den Linter aus und behebt Probleme automatisch
```

### Nicht-interaktiver (skriptgesteuerter) Modus

```bash
# Führe eine einzelne Anweisung aus und beende
aider --model ollama/deepseek-r1:32b \
  --message "Füge allen Funktionen in src/utils.py Typ-Hinweise hinzu" \
  --yes  # Änderungen automatisch akzeptieren
```

## Modell-Empfehlungen

| Modell                | VRAM    | Geschwindigkeit | Qualität | Am besten geeignet für           |
| --------------------- | ------- | --------------- | -------- | -------------------------------- |
| deepseek-r1:32b       | \~20 GB | Mittel          | Hoch     | Komplexes Refactoring            |
| qwen2.5-coder:32b     | \~20 GB | Mittel          | Hoch     | Codegenerierung                  |
| qwen2.5-coder:7b      | \~5 GB  | Schnell         | Gut      | Schnelle Bearbeitungen, RTX 3060 |
| codellama:34b         | \~20 GB | Mittel          | Gut      | Legacy-Code, C/C++               |
| deepseek-coder-v2:16b | \~10 GB | Schnell         | Gut      | Ausgewogene Leistung             |

## Tipps

* **Verwende `/add` selektiv** — füge nur die Dateien hinzu, die Aider sehen muss. Zu viele Dateien verschwenden Kontext-Tokens
* **Architektenmodus** ist leistungsstark für komplexe Änderungen — das Reasoning-Modell erkennt Randfälle, die das Editor-Modell möglicherweise übersieht
* **`/undo`** macht die letzte Änderung sauber über Git rückgängig — experimentiere frei
* **`/diff`** zeigt die vorgeschlagenen Änderungen vor dem Anwenden — zur Überprüfung verwenden
* **Setze `--auto-commits`** (Standard) für den vollständigen Git-Verlauf jeder KI-Änderung
* **Verwende `.aiderignore`** um Dateien aus der Repo-Map auszuschließen (node\_modules, .venv usw.)
* **Für große Repos**, Aiders Repo-Map hilft dem Modell, die Codestruktur zu verstehen — lass sie beim ersten Laden laufen
* **Nach Bearbeitungen Tests ausführen** — `/test pytest` erkennt Regressionen sofort

## Fehlerbehebung

| Problem                                | Lösung                                                                                  |
| -------------------------------------- | --------------------------------------------------------------------------------------- |
| Ollama-Modell zu langsam               | Verwende eine kleinere Quantisierung (q4\_0) oder ein kleineres Modell                  |
| `CUDA-Speicher erschöpft` mit Ollama   | Lade eine kleinere Modellvariante herunter oder verwende `OLLAMA_NUM_GPU=0` für die CPU |
| Git-Commit-Fehler                      | Stelle sicher `git config user.email` und `user.name` gesetzt sind                      |
| Aider ignoriert meine Dateien          | Verwende `/add filename.py` explizit — Aider bearbeitet nur hinzugefügte Dateien        |
| Modell erzeugt schlechte Bearbeitungen | Versuche ein stärkeres Modell oder verwende den Architektenmodus                        |
| Verbindung abgelehnt (Ollama)          | Stelle sicher, dass Ollama läuft: `ollama serve` oder `systemctl start ollama`          |
| Kontextfenster überschritten           | Entferne Dateien mit `/drop`, behalte nur die relevanten                                |

## Ressourcen

* [Aider auf GitHub](https://github.com/Aider-AI/aider)
* [Aider-Dokumentation](https://aider.chat)
* [Ollama-Modellbibliothek](https://ollama.com/library)
* [CLORE.AI-Marktplatz](https://clore.ai/marketplace)


---

# 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://docs.clore.ai/guides/guides_v2-de/ki-coding-tools/aider.md?ask=<question>&goal=<endgoal>
```

`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.
