> 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

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)


---

# 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://docs.clore.ai/guides/guides_v2-de/ki-coding-tools/aider.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.
