# Aider KI-Coding

Aider ist ein terminalbasiertes KI-Coding-Assistenztool mit über 39.000 GitHub-Sternen. Es bearbeitet Dateien direkt in Ihrem Repository, erstellt automatisch Git-Commits und unterstützt sowohl Cloud-APIs (OpenAI, Anthropic) als auch vollständig lokale Modelle über Ollama. Auf einer Clore.ai-GPU können Sie große Codiermodelle wie DeepSeek-R1 32B oder Qwen2.5-Coder-32B vollständig auf Ihrer eigenen Hardware ausführen — privat, schnell und kosteneffizient.

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

## Hauptmerkmale

* **Terminal-nativ** — funktioniert über SSH, perfekt für headless Clore.ai-Server
* **Git-bewusst** — commitet jede Änderung automatisch mit beschreibenden Nachrichten, leicht zu prüfen und rückgängig zu machen
* **Mehrfach-Dateibearbeitung** — fügen Sie mehrere Dateien in den Kontext hinzu und bearbeiten Sie sie gleichzeitig
* **Unterstützung für lokale Modelle** — verbinden Sie sich mit Ollama für vollständig private Codierung ohne API-Kosten
* **Architekt-Modus** — verwenden Sie ein starkes Reasoning-Modell zum Planen und ein schnelles Modell zur Umsetzung
* **Repository-Karte** — indexiert automatisch Ihre Codebasis für kontextbewusste Änderungen
* **Linting und Tests** — führen Sie Linter/Tests nach jeder Änderung aus, beheben Sie Fehler automatisch
* **Spracheingabe** — Diktieren von Programmieranweisungen 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.5–2/Tag · RTX 3090 ≈ $0.3–1/Tag · RTX 3060 ≈ $0.15–0.3/Tag

Für ausschließlich Cloud-Modelle (keine lokale Inferenz) ist eine GPU nicht erforderlich — aber Clore.ai-GPUs ermöglichen es Ihnen, Ollama-Modelle lokal auszuführen für vollständige Privatsphäre.

## Schnellstart

### 1. Aider installieren

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

### 2. Ollama für lokale Modelle einrichten

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

# Ein Codiermodell ziehen
ollama pull deepseek-r1:32b

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

### 3. Aider mit einem lokalen Modell starten

```bash
cd /workspace/your-project

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

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

### 4. Mit dem Coden beginnen

Innerhalb des Aider-REPL:

```
> /add src/main.py src/utils.py
> Fügen Sie Fehlerbehandlung zur Funktion parse_config hinzu und schreiben Sie 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 beschreibenden Nachricht erstellen

## Beispielanwendungen

### Architekt-Modus (Zwei-Modell-Setup)

Verwenden Sie ein starkes Modell für Reasoning und ein schnelles Modell für Codegenerierung:

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

Das Architekt-Modell plant die Änderungen, und das Editor-Modell schreibt den eigentlichen Code — kombiniert hochwertige Reasoning-Fähigkeiten mit schneller Umsetzung.

### Dateien hinzufügen und bearbeiten

```bash
# Fügen Sie spezifische Dateien zum Chat-Kontext hinzu
> /add src/api/routes.py src/models/user.py

# Um Änderungen bitten
> Refaktorieren Sie den Benutzer-Registrierungsendpunkt, um async/await zu verwenden, und fügen Sie Eingabevalidierung mit Pydantic hinzu

# Ein ganzes Verzeichnis hinzufügen
> /add src/tests/

# Tests nach der Bearbeitung 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 erzeugt automatisch einen Commit
git log --oneline -5
# a1b2c3d aider: Fehlerbehandlung zu parse_config hinzugefügt
# d4e5f6g aider: Unit-Tests für parse_config geschrieben
# h7i8j9k aider: Benutzer-Registrierungsendpunkt refaktoriert

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

### Lint und Auto-Fix

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

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

### Nicht-interaktiver (geskripteter) Modus

```bash
# Führen Sie eine einzelne Anweisung aus und beenden Sie
aider --model ollama/deepseek-r1:32b \
  --message "Fügen Sie allen Funktionen in src/utils.py Typannotationen 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     | Code-Generierung              |
| qwen2.5-coder:7b      | \~5 GB  | Schnell         | Gut      | Schnelle Änderungen, RTX 3060 |
| codellama:34b         | \~20 GB | Mittel          | Gut      | Legacy-Code, C/C++            |
| deepseek-coder-v2:16b | \~10 GB | Schnell         | Gut      | Ausgewogene Leistung          |

## Tipps

* **Verwenden Sie `/add` selektiv** — fügen Sie nur Dateien hinzu, die Aider sehen muss. Zu viele Dateien verschwenden Kontext-Token
* **Architekt-Modus** 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 — experimentieren Sie frei
* **`/diff`** zeigt die vorgeschlagenen Änderungen vor dem Anwenden — zur Überprüfung verwenden
* **Setze `--auto-commits`** (Standard) für vollständige Git-Historie jeder KI-Änderung
* **Verwenden Sie `.aiderignore`** um Dateien von der Repo-Karte auszuschließen (node\_modules, .venv, etc.)
* **Für große Repositories**, Aiders Repo-Karte hilft dem Modell, die Code-Struktur zu verstehen — lassen Sie sie beim ersten Laden laufen
* **Tests nach Änderungen ausführen** — `/test pytest` erkennt Regressionen sofort

## Fehlerbehebung

| Problem                                | Lösung                                                                                    |
| -------------------------------------- | ----------------------------------------------------------------------------------------- |
| Ollama-Modell zu langsam               | Verwenden Sie eine kleinere Quantisierung (q4\_0) oder ein kleineres Modell               |
| `CUDA out of memory` mit Ollama        | Ziehen Sie eine kleinere Modellvariante oder verwenden Sie `OLLAMA_NUM_GPU=0` für die CPU |
| Git-Commit-Fehler                      | Stelle sicher, dass `git config user.email` und `user.name` sind gesetzt                  |
| Aider ignoriert meine Dateien          | Verwenden Sie `/add filename.py` explizit — Aider bearbeitet nur hinzugefügte Dateien     |
| Modell produziert schlechte Änderungen | Versuchen Sie ein stärkeres Modell oder verwenden Sie den Architekt-Modus                 |
| Verbindung verweigert (Ollama)         | Stellen Sie sicher, dass Ollama läuft: `ollama serve` oder `systemctl start ollama`       |
| Kontextfenster überschritten           | Entfernen Sie Dateien mit `/drop`, behalten Sie nur relevante                             |

## Ressourcen

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