# Aider AI Coding

Aider एक टर्मिनल-आधारित एआई कोडिंग सहायक है जिसे 39K+ GitHub स्टार मिले हैं। यह आपकी रिपो में फाइलों को सीधे संपादित करता है, स्वचालित रूप से Git कमिट बनाता है, और क्लाउड APIs (OpenAI, Anthropic) तथा Ollama के माध्यम से पूरी तरह स्थानीय मॉडल दोनों का समर्थन करता है। एक Clore.ai GPU पर, आप DeepSeek-R1 32B या Qwen2.5-Coder-32B जैसे बड़े कोडिंग मॉडल पूरी तरह अपने हार्डवेयर पर चला सकते हैं — निजी, तेज़ और लागत-कुशल।

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलते हैं जो कि के माध्यम से किराये पर लिए गए हैं [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

## प्रमुख विशेषताएँ

* **टर्मिनल-नेटिव** — SSH पर काम करता है, हेडलेस Clore.ai सर्वरों के लिए उपयुक्त
* **Git-जानकार** — प्रत्येक परिवर्तन को वर्णनात्मक संदेशों के साथ स्वचालित रूप से कमिट करता है, समीक्षा और रिवर्ट करना आसान बनाता है
* **मल्टी-फाइल संपादन** — संदर्भ में कई फाइलें जोड़ें और उन्हें एक साथ संपादित करें
* **लोकल मॉडल समर्थन** — पूरी तरह निजी, शून्य-API-लागत कोडिंग के लिए Ollama से कनेक्ट करें
* **आर्किटेक्ट मोड** — योजना बनाने के लिए एक मजबूत तर्क मॉडल का उपयोग करें, फिर कार्यान्वयन के लिए एक तेज़ मॉडल
* **रिपॉज़िटरी मानचित्र** — संदर्भ-सूचीकृत संपादन के लिए स्वचालित रूप से आपके कोडबेस का इंडेक्स बनाता है
* **लिंटिंग और परीक्षण** — प्रत्येक संपादन के बाद लिंटर/टेस्ट चलाएँ, विफलताओं को स्वचालित रूप से ठीक करें
* **वॉइस इनपुट** — माइक्रोफोन के माध्यम से कोडिंग निर्देश बोल कर दें

## आवश्यकताएँ

| घटक    | न्यूनतम        | अनुशंसित       |
| ------ | -------------- | -------------- |
| GPU    | RTX 3060 12 GB | RTX 4090 24 GB |
| VRAM   | 12 GB          | 24 GB          |
| RAM    | 16 GB          | 32 GB          |
| डिस्क  | 30 GB          | 60 GB          |
| Python | 3.9            | 3.11           |

**Clore.ai मूल्य निर्धारण:** RTX 4090 ≈ $0.5–2/दिन · RTX 3090 ≈ $0.3–1/दिन · RTX 3060 ≈ $0.15–0.3/दिन

केवल क्लाउड-मॉडलों (लोकल इनफेरेंस नहीं) के लिए GPU आवश्यक नहीं है — लेकिन Clore.ai GPUs आपको Ollama मॉडल लोकली चलाने देते हैं ताकि पूर्ण गोपनीयता मिल सके।

## त्वरित प्रारम्भ

### 1. Aider इंस्टॉल करें

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

### 2. लोकल मॉडलों के लिए Ollama सेट करें

```bash
# Ollama इंस्टॉल करें
curl -fsSL https://ollama.com/install.sh | sh

# एक कोडिंग मॉडल खींचें
ollama pull deepseek-r1:32b

# या कम VRAM के लिए एक छोटा मॉडल
ollama pull qwen2.5-coder:7b
```

### 3. लोकल मॉडल के साथ Aider शुरू करें

```bash
cd /workspace/your-project

# Ollama के माध्यम से DeepSeek-R1 32B उपयोग करें (लगभग ~20 GB VRAM की आवश्यकता)
aider --model ollama/deepseek-r1:32b

# या RTX 3060 पर एक छोटा मॉडल उपयोग करें
aider --model ollama/qwen2.5-coder:7b
```

### 4. कोडिंग शुरू करें

Aider REPL के अंदर:

```
> /add src/main.py src/utils.py
> parse_config फ़ंक्शन में एरर हैंडलिंग जोड़ें और उसके लिए यूनिट टेस्ट लिखें
```

Aider निम्न करेगा:

1. फाइलें पढ़ेगा और कोडबेस को समझेगा
2. परिवर्तनों का प्रस्ताव एक diff के रूप में देगा
3. परिवर्तनों को डिस्क पर लागू करेगा
4. वर्णनात्मक संदेश के साथ एक Git कमिट बनाएगा

## उपयोग के उदाहरण

### आर्किटेक्ट मोड (दो-मॉडल सेटअप)

तर्क के लिए एक मजबूत मॉडल और कोड जनरेशन के लिए एक तेज़ मॉडल उपयोग करें:

```bash
# क्लाउड आर्किटेक्ट + लोकल एडिटर
aider --architect --model ollama/deepseek-r1:32b --editor-model ollama/qwen2.5-coder:7b
```

आर्किटेक्ट मॉडल परिवर्तन की योजना बनाता है, और एडिटर मॉडल वास्तविक कोड लिखता है — उच्च गुणवत्ता वाली तर्कशीलता को तेज़ कार्यान्वयन के साथ मिलाता है।

### फाइलें जोड़ें और संपादित करें

```bash
# चैट संदर्भ में विशिष्ट फाइलें जोड़ें
> /add src/api/routes.py src/models/user.py

# परिवर्तन के लिए पूछें
> उपयोगकर्ता पंजीकरण एंडपॉइंट को async/await का उपयोग करने के लिए रीफैक्टर करें और Pydantic के साथ इनपुट वैलिडेशन जोड़ें

# एक पूरी डायरेक्टरी जोड़ें
> /add src/tests/

# संपादन के बाद टेस्ट चलाएं
> /test pytest src/tests/ -v
```

### क्लाउड APIs के साथ उपयोग करें

```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 एकीकरण

```bash
# हर परिवर्तन स्वतः ही एक कमिट बनाता है
git log --oneline -5
# a1b2c3d aider: parse_config में एरर हैंडलिंग जोड़ें
# d4e5f6g aider: parse_config के लिए यूनिट टेस्ट लिखें
# h7i8j9k aider: उपयोगकर्ता पंजीकरण एंडपॉइंट रीफैक्टर करें

# पिछले aider परिवर्तन को पूर्ववत करें
aider --undo
```

### लिंट और आटो-फिक्स

```bash
# एक लिंटर कॉन्फ़िगर करें
aider --lint-cmd "ruff check --fix" --auto-lint

# Aider प्रत्येक संपादन के बाद लिंटर चलाता है और मुद्दों को स्वचालित रूप से ठीक करता है
```

### नॉन-इंटरैक्टिव (स्क्रिप्टेड) मोड

```bash
# एक निर्देश चलाएँ और बाहर निकलें
aider --model ollama/deepseek-r1:32b \
  --message "src/utils.py की सभी फंक्शनों में टाइप हिन्ट जोड़ें" \
  --yes  # परिवर्तनों को स्वचालित रूप से स्वीकार करें
```

## मॉडल सिफारिशें

| मॉडल                  | VRAM    | स्पीड | गुणवत्ता | उत्तम हेतु              |
| --------------------- | ------- | ----- | -------- | ----------------------- |
| deepseek-r1:32b       | \~20 GB | मध्यम | उच्च     | जटिल रीफैक्टोरिंग       |
| qwen2.5-coder:32b     | \~20 GB | मध्यम | उच्च     | कोड जनरेशन              |
| qwen2.5-coder:7b      | \~5 GB  | तेज़  | अच्छा    | त्वरित संपादन, RTX 3060 |
| codellama:34b         | \~20 GB | मध्यम | अच्छा    | लेगेसी कोड, C/C++       |
| deepseek-coder-v2:16b | \~10 GB | तेज़  | अच्छा    | संतुलित प्रदर्शन        |

## टिप्स

* **उपयोग करें `/add` चयनात्मक रूप से** — केवल उन फाइलों को जोड़ें जिन्हें Aider को देखने की आवश्यकता है। बहुत सारी फाइलें संदर्भ टोकन बर्बाद करती हैं
* **आर्किटेक्ट मोड** जटिल परिवर्तनों के लिए शक्तिशाली है — तर्क मॉडल किनारों के मामलों को पकड़ता है जिन्हें एडिटर मॉडल मिस कर सकता है
* **`/undo`** Git के माध्यम से अंतिम परिवर्तन को साफ़ तरीके से पूर्ववत करता है — स्वतंत्र रूप से प्रयोग करें
* **`/diff`** आवेदन करने से पहले प्रस्तावित परिवर्तनों को दिखाता है — समीक्षा के लिए उपयोग करें
* **सेट करें `--auto-commits`** (डिफ़ॉल्ट) हर AI परिवर्तन के लिए पूर्ण Git इतिहास के लिए
* **उपयोग करें `.aiderignore`** रिपो मानचित्र से फाइलों को बाहर करने के लिए (node\_modules, .venv, आदि.)
* **बड़ी रिपोज़िटरीज़ के लिए**, Aider का repo मानचित्र मॉडल को कोड संरचना समझने में मदद करता है — पहले लोड पर इसे चलने दें
* **संपादनों के बाद टेस्ट चलाएँ** — `/test pytest` तुरंत रिग्रेशन पकड़ता है

## समस्याओं का निवारण

| समस्या                                 | समाधान                                                                                         |
| -------------------------------------- | ---------------------------------------------------------------------------------------------- |
| Ollama मॉडल बहुत धीमा                  | एक छोटा क्वांटाइज़ेशन (q4\_0) या छोटा मॉडल उपयोग करें                                          |
| `CUDA में आउट ऑफ मेमोरी` Ollama के साथ | एक छोटे मॉडल वेरिएंट को खींचें या उपयोग करें `OLLAMA_NUM_GPU=0` CPU के लिए                     |
| Git कमिट त्रुटियाँ                     | सुनिश्चित करें `git config user.email` और `user.name` सेट हैं                                  |
| Aider मेरी फाइलों को अनदेखा कर रहा है  | उपयोग करें `/add filename.py` स्पष्ट रूप से — Aider केवल जोड़ी गई फाइलों को ही संपादित करता है |
| मॉडल खराब एडिट्स उत्पन्न कर रहा है     | किसी मजबूत मॉडल को आज़माएँ, या आर्किटेक्ट मोड का उपयोग करें                                    |
| कनेक्शन अस्वीकार किया गया (Ollama)     | सुनिश्चित करें कि Ollama चल रहा है: `ollama serve` या `systemctl start ollama`                 |
| संदर्भ विंडो अधिक हो गई                | के साथ फाइलें हटाएँ `/drop`केवल प्रासंगिक फाइलें रखें                                          |

## संसाधन

* [Aider GitHub](https://github.com/Aider-AI/aider)
* [Aider दस्तावेज़ीकरण](https://aider.chat)
* [Ollama मॉडल लाइब्रेरी](https://ollama.com/library)
* [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)