# Octocode: डेवलपर प्रोडक्टिविटी टूल जिसने हमारे लिए grep को बदल दिया

> एक Rust बाइनरी में सिमेंटिक कोड सर्च इंजन, MCP टूल और AI-संचालित डेवलपर प्रोडक्टिविटी टूल। हमने इसे कैसे बनाया और क्यों इसे हर दिन उपयोग करते हैं।

आप अभी-अभी एक प्रोजेक्ट में शामिल हुए हैं जिसमें 12,000 फ़ाइलों में 400,000 लाइनें कोड हैं। कोई आपसे ऑथेंटिकेशन फ्लो ठीक करने के लिए कहता है। आप `grep -r "auth"` करते हैं और 847 परिणाम मिलते हैं। आधे टिप्पणियाँ हैं। एक तिहाई टेस्ट फ़ाइलें हैं। कोई भी आपको यह नहीं बताता कि _ऑथेंटिकेशन वास्तव में कैसे काम करता है_।

यही समस्या थी जिससे हम लगातार टकराते रहे। और इसी वजह से हमने Octocode बनाया।

Octocode Rust में बनाया गया एक डेवलपर प्रोडक्टिविटी टूल है — सिमेंटिक कोड सर्च, MCP सर्वर और AI-संचालित टूलकिट एक बाइनरी में। आप इससे सादी अंग्रेज़ी में पूछते हैं "यूज़र ऑथेंटिकेशन कैसे काम करता है?" और यह वे 3-5 फ़ाइलें लौटाता है जो वास्तव में मायने रखती हैं, साथ ही इस संदर्भ के साथ कि वे कैसे जुड़ती हैं। यह स्थानीय रूप से चलता है, Claude और Cursor के लिए MCP टूल के रूप में काम करता है, और आपके कोडबेस को क्वेरी-योग्य ज्ञान ग्राफ़ में बदल देता है।

हम इसे हर दिन उपयोग करते हैं। यह वह टूल है जिसके पीछे [Octomind](https://octomind.run) — हमारा AI एजेंट रनटाइम — दो लोगों की टीम द्वारा तेज़ी से बनाया और शिप किया जाता है। यह हमारा गुप्त हथियार है। और यह ओपन सोर्स है।

हमने अभी-अभी v0.13.0 शिप किया है — कमिट सर्च, AI-संचालित डिफ्स, स्वचालित रिलीज़, कोड व्याख्या और RaBitQ वेक्टर कम्प्रेशन के साथ। यहाँ पूरी तस्वीर है।

## वह दर्द जिसने इसे शुरू किया

हम बहुत सॉफ़्टवेयर बनाते हैं। कई repos, कई भाषाएँ, ऐसे प्रोजेक्ट जो वर्षों पहले के हैं। समस्या कोड लिखने की नहीं थी — समस्या थी कोड ढूँढने की। कुछ नया लिखने से पहले यह समझना कि पहले से क्या मौजूद है।

`grep` तेज़ है लेकिन बेवकूफ़। यह स्ट्रिंग ढूँढता है, अर्थ नहीं। GitHub सर्च धीमा है और सार्वजनिक repos तक सीमित। ChatGPT 128K टोकन के बाद संदर्भ खो देता है। हर बार जब हम किसी पुराने प्रोजेक्ट पर वापस आते, हम वही फ़ाइलें फिर से पढ़ने में घंटे जला देते जो हमने छह महीने पहले पढ़ी थीं।

सवाल सरल था: क्या होगा अगर कोड सर्च उसी तरह काम करे जैसे आपका दिमाग़ काम करता है? आप यह नहीं सोचते कि "मुझे स्ट्रिंग `authenticate` ढूँढ कर दो" — आप सोचते हैं "लॉगिन कैसे काम करता है?"। टूल को इस फ़र्क को समझना चाहिए।

तो हमने एक बनाया।

![grep बनाम octocode सर्च](/blog/octocode-semantic-code-search/grep-vs-semantic.svg)

## Octocode क्या करता है

मूल रूप से, Octocode चार चीज़ें करता है:

**1. सिमेंटिक सर्च** — प्राकृतिक अंग्रेज़ी में सवाल पूछें। यह आपके क्वेरी को वेक्टर एम्बेडिंग में बदलता है, इसकी तुलना आपके प्रोजेक्ट में हर कोड चंक के एम्बेडिंग से करता है, और सबसे अर्थपूर्ण रूप से प्रासंगिक परिणाम लौटाता है। कीवर्ड मैच नहीं — अर्थ मैच।

**2. कोड संरचना विश्लेषण** — किसी भी फ़ाइल या glob पैटर्न से फ़ंक्शन सिग्नेचर, क्लास परिभाषाएँ और मॉड्यूल इंटरफ़ेस निकालता है। हर लाइन पढ़े बिना समझें कि एक फ़ाइल क्या करती है।

**3. ज्ञान ग्राफ़ (GraphRAG)** — फ़ाइलों के बीच संबंधों का मानचित्रण: कौन क्या आयात करता है, कौन से मॉड्यूल सिबलिंग हैं, सिस्टम के माध्यम से डेटा कैसे बहता है। पूछें "फ़ाइल A फ़ाइल B से कैसे जुड़ी है?" और एक वास्तविक उत्तर पाएँ।

**4. AI-संचालित डेवलपर टूल** — सिमेंटिक डिफ्स, स्वचालित कोड रिव्यू, बुद्धिमान कमिट संदेश, कोडबेस व्याख्या और मल्टी-लैंग्वेज रिलीज़ प्रबंधन। ये अलग टूल नहीं हैं जो ऊपर से बोल्ट किए गए हैं — ये उसी इंडेक्सिंग और सर्च इंजन पर बनाए गए हैं।

यह सब एक MCP सर्वर के रूप में उजागर है — मतलब Claude, Cursor, Windsurf, या कोई भी MCP-संगत AI सहायक इसे सीधे उपयोग कर सकता है। आपका AI आपके कोडबेस के बारे में अनुमान लगाना बंद करता है और जानना शुरू करता है।

## हम इसे वास्तव में कैसे उपयोग करते हैं

फ़ीचर्स में गहराई से जाने से पहले — यह कोई टूल नहीं है जिसे हमने बनाया और भूल गए। हम [Octomind](https://octomind.run) — हमारा AI एजेंट रनटाइम — बनाने के लिए दैनिक आधार पर Octocode का उपयोग करते हैं।

हमारा एक सामान्य दिन ऐसा दिखता है:

- सुबह: `octocode diff --staged` यह देखने के लिए कि Ava (हमारी AI सहयोगी) ने रात भर में क्या शिप किया। 200 लाइनों का डिफ नहीं — एक संक्षिप्त सारांश जो कहता है "MCP ट्रांसपोर्ट लेयर में रिट्राय लॉजिक जोड़ा, 3 फ़ाइलों में एरर हैंडलिंग रीफ़ैक्टर किया।"
- PR से पहले: `octocode review --staged --focus security` उन चीज़ों को पकड़ता है जो हम चूक जाते। ग़लती से हटाए गए रेट लिमिटर्स। SQL इंजेक्शन वेक्टर्स। Rust में असुरक्षित unwraps।
- कमिट के समय: `octocode commit` वास्तविक डिफ से संदेश उत्पन्न करता है। अब "fix stuff" कमिट नहीं।
- रिलीज़: `octocode release` अंतिम टैग के बाद से हर कमिट पढ़ता है, संस्करण बम्प तय करता है, चेंजलॉग उत्पन्न करता है, और Cargo.toml, package.json, या जो भी आपका प्रोजेक्ट उपयोग करता है उसमें संस्करण फ़ाइलें अपडेट करता है।
- पूरे दिन: Claude Code Octocode को अपने MCP सर्वर के रूप में उपयोग करता है। जब हम पूछते हैं "एम्बेडिंग पाइपलाइन कैसे काम करती है?" — Claude वास्तविक कोड में सर्च करता है, उसे पढ़ता है, और उत्तर देता है। कोई मतिभ्रम नहीं।

यह वर्कफ़्लो है जो दो लोगों और एक AI को बहुत बड़ी टीम की तरह शिप करने देता है।

## CLI: डेवलपर प्रोडक्टिविटी के लिए AI टूल्स

Octocode एक MCP टूल के रूप में शुरू हुआ। लेकिन जितना अधिक हमने इसे उपयोग किया, उतना ही महसूस हुआ: इस चीज़ को स्टैंडअलोन भी काम करना चाहिए। सब कुछ AI चैट के अंदर नहीं होता।

### `octocode search` — आपके टर्मिनल से सिमेंटिक सर्च

```bash
# एकल क्वेरी
octocode search "how is user authentication implemented"

# विस्तृत परिणामों के लिए मल्टी-क्वेरी
octocode search "auth middleware" "JWT token validation" "session management"

# विशिष्ट सामग्री प्रकार खोजें
octocode search "database migration" --mode code
octocode search "why did we change the API" --mode commits

# आउटपुट विवरण नियंत्रित करें
octocode search "auth" --detail-level full
```

मल्टी-क्वेरी यहाँ की किलर फ़ीचर है। एक सर्च की उम्मीद में सब कुछ पकड़ने के बजाय, आप 3-4 संबंधित क्वेरी फायर करते हैं और परिणाम पाते हैं जो पूरी तस्वीर को कवर करते हैं। इंजन सभी क्वेरीज़ में डुप्लिकेट हटाता है और रीरैंक करता है।

विवरण स्तर आपको नियंत्रित करने देते हैं कि कितना कोड वापस आता है: त्वरित स्कैन के लिए `signatures`, स्मार्ट ट्रंकेशन के लिए `partial` (डिफ़ॉल्ट), या सब कुछ के लिए `full`।

### `octocode view` — शोर के बिना सिग्नेचर

```bash
# सभी Rust फ़ंक्शन सिग्नेचर देखें
octocode view "src/**/*.rs"

# एक विशिष्ट मॉड्यूल के इंटरफ़ेस की जाँच करें
octocode view "src/api/*.ts" --md

# एक साथ मल्टी-लैंग्वेज
octocode view "**/*.{rs,ts,py}"
```

यह उन फ़ीचर्स में से एक है जो सरल लगता है लेकिन वास्तविक समय बचाता है। आप एक PR की समीक्षा कर रहे हैं जो 8 फ़ाइलों को छूता है। हर एक को खोलने और स्क्रॉल करने के बजाय, आप एक glob के साथ `octocode view` चलाते हैं और एक आउटपुट में हर फ़ंक्शन सिग्नेचर, struct परिभाषा और टाइप एक्सपोर्ट पाते हैं। Markdown मोड (`--md`) इसे पेस्ट-फ़्रेंडली बनाता है।

हम इसका भारी उपयोग MCP सर्वर में भी करते हैं — जब Claude को संपादित करने से पहले किसी मॉड्यूल का इंटरफ़ेस समझने की आवश्यकता होती है, तो `view_signatures` उसे 2000 लाइनें कार्यान्वयन डंप किए बिना संरचना देता है।

### `octocode diff` — सारांश, पैच नहीं

यह v0.13 में नया है। और इसने बदल दिया है कि हम AI-जनरेटेड कोड की समीक्षा कैसे करते हैं।

```bash
# मेरे staging एरिया में क्या बदला?
octocode diff --staged

# ब्रांचों के बीच क्या हुआ?
octocode diff main..feature-branch

# विशिष्ट चिंताओं पर ध्यान दें
octocode diff --staged --focus security
octocode diff --staged --focus performance
```

यह अब क्यों पहले से ज़्यादा मायने रखता है। AI कोडिंग टूल बड़े डिफ्स उत्पन्न करते हैं। एक Claude सेशन 400 लाइनों में 15 फ़ाइलें छू सकता है। उस कच्चे डिफ को पढ़ने में 20 मिनट लगते हैं। `octocode diff` इसे सेकंडों में पढ़ता है और आपको एक सारांश देता है: क्या बदला, यह क्यों मायने रखता है, क्या देखना है।

`--focus` फ्लैग तीक्ष्ण है। `security` पास करें और यह हटाए गए वैलिडेशन, खुले एंडपॉइंट, हार्डकोडेड सीक्रेट्स को फ्लैग करता है। `performance` पास करें और यह नए आवंटन, ब्लॉकिंग कॉल, गुम इंडेक्स को हाइलाइट करता है। हम हर मर्ज से पहले दोनों चलाते हैं।

### `octocode explain` — कुछ भी समझें

```bash
# एक विशिष्ट फ़ाइल समझाएँ
octocode explain src/auth/middleware.rs

# पूरे कोडबेस में एक अवधारणा समझाएँ
octocode explain "how does the embedding pipeline work"
```

इसे किसी फ़ाइल पर पॉइंट करें और एक संरचित विश्लेषण पाएँ: यह क्या करती है, यह किस पर निर्भर करती है, इस पर क्या निर्भर करता है। इसे किसी अवधारणा पर पॉइंट करें और यह सिमेंटिक रूप से सर्च करता है, फिर परिणामों को व्याख्या में संश्लेषित करता है। कोडबेस के अपरिचित हिस्सों पर ऑनबोर्डिंग के लिए बढ़िया।

### `octocode review` — जो इंसान चूक जाते हैं उसे पकड़ता है

```bash
octocode review --staged
octocode review --focus security --severity high
```

मानव समीक्षा का प्रतिस्थापन नहीं। लेकिन यह लगातार उन चीज़ों को पकड़ता है जो हम छोड़ देते: अप्रयुक्त इम्पोर्ट्स, असंगत एरर हैंडलिंग, संभावित रेस कंडीशन, सुरक्षा मुद्दे। हम अब हर PR से पहले इसे चलाते हैं। सीवियरिटी फ़िल्टर इसे शोरगुल होने से रोकता है।

### `octocode commit` — कमिट संदेश जो कुछ मायने रखते हैं

```bash
git add .
octocode commit
octocode commit --yes  # पुष्टि छोड़ें
```

स्टेज किए गए परिवर्तनों का विश्लेषण करता है, एक कमिट संदेश उत्पन्न करता है जो वास्तव में वर्णन करता है कि क्या हुआ। "update files" नहीं — कुछ ऐसा "refactor: extract embedding batch processing into standalone pipeline with retry logic"। छोटी बात, लेकिन जब आप दिन में 20 कमिट करते हैं तो यह बढ़ता है।

### `octocode release` — स्वचालित मल्टी-लैंग्वेज रिलीज़

```bash
octocode release
octocode release --dry-run
octocode release --force-version "2.0.0"
```

यह एक स्लीपर है। यह अंतिम git टैग के बाद से हर कमिट पढ़ता है, सही संस्करण बम्प (patch, minor, या major) निर्धारित करने के लिए LLM का उपयोग करता है, एक संरचित चेंजलॉग उत्पन्न करता है, और संस्करण फ़ाइलें अपडेट करता है।

मल्टी-लैंग्वेज भाग मायने रखता है: यह Cargo.toml (Rust), package.json (Node), composer.json (PHP), pyproject.toml (Python), और go.mod (Go) को हैंडल करता है। यदि आपका प्रोजेक्ट कई भाषाओं का उपयोग करता है, तो यह उन सभी को अपडेट करता है।

हम इसका उपयोग हर Octocode रिलीज़ के लिए करते हैं। [v0.13 चेंजलॉग](https://github.com/Muvon/octocode/blob/master/CHANGELOG.md) — अपनी श्रेणीबद्ध फ़ीचर्स, सुधार, और बग फिक्स के साथ — `octocode release` द्वारा उत्पन्न किया गया था।

### `octocode stats` — त्वरित पल्स चेक

```bash
octocode stats
octocode stats --format json
```

भाषा के अनुसार फ़ाइल काउंट, लाइन काउंट, इंडेक्स की गई स्थिति। CI डैशबोर्ड के लिए या बस इस उत्तर के लिए कि "यह प्रोजेक्ट कितना बड़ा है?"।

## इंडेक्सिंग कैसे काम करती है

![Octocode इंडेक्सिंग पाइपलाइन](/blog/octocode-semantic-code-search/pipeline.svg)

जब आप `octocode index` चलाते हैं, यहाँ हुड के नीचे क्या होता है:

1. **फ़ाइल खोज** — repo को चलता है, `.gitignore` और `.noindex` का सम्मान करता है, सिमलिंक हैंडल करता है
2. **AST पार्सिंग** — Tree-sitter प्रत्येक फ़ाइल को एक अमूर्त सिंटैक्स ट्री में पार्स करता है। Octocode इसी तरह कोड संरचना को समझता है — फ़ंक्शन, क्लास, इम्पोर्ट, एक्सपोर्ट — सिर्फ़ टेक्स्ट नहीं
3. **चंकिंग** — कोड को सिमेंटिक चंक में विभाजित किया जाता है (कॉन्फ़िगर करने योग्य, डिफ़ॉल्ट 2000 बाइट ओवरलैप के साथ)
4. **एम्बेडिंग** — आपकी पसंद के प्रदाता के माध्यम से प्रत्येक चंक को वेक्टर एम्बेडिंग में बदला जाता है
5. **भंडारण** — वेक्टर वैकल्पिक RaBitQ क्वांटाइज़ेशन (~32x संपीड़न) के साथ LanceDB में जाते हैं
6. **GraphRAG** — फ़ाइलों के बीच संबंध निकाले जाते हैं और ज्ञान ग्राफ़ के रूप में संग्रहीत किए जाते हैं

पूरी पाइपलाइन इंक्रीमेंटल है। एक फ़ाइल बदलें, और केवल वह फ़ाइल फिर से इंडेक्स होती है। ब्रांच स्विच करें, और Octocode ट्रैक करता है कि क्या अपडेट करने की आवश्यकता है। यह v0.13 में नई ब्रांच-अवेयर डेल्टा इंडेक्सिंग है।

### एम्बेडिंग प्रदाता

आप अपना खुद का चुनते हैं:

**क्लाउड** (API कुंजी आवश्यक):

- **Voyage AI** — कोड के लिए सबसे अच्छी गुणवत्ता, 200M मुफ़्त टोकन/महीना (हमारा डिफ़ॉल्ट)
- **Jina AI** — मज़बूत कोड एम्बेडिंग
- **Google AI** — gemini-embedding-001
- **OpenAI** — text-embedding-3-small/large
- **Together AI** — वितरित

**स्थानीय** (कोई API नहीं, कोई नेटवर्क नहीं):

- **FastEmbed** — सबसे तेज़, 384-dim (macOS)
- **HuggingFace** — CodeBERT, sentence-transformers (macOS)

एक विवरण जो मायने रखता है: Octocode **असममित पुनर्प्राप्ति** का उपयोग करता है। कोड एम्बेडिंग और क्वेरी एम्बेडिंग अलग-अलग उत्पन्न होते हैं क्योंकि "ऑथ कैसे काम करता है?" और `fn authenticate(token: &str)` अर्थपूर्ण रूप से संबंधित हैं लेकिन संरचनात्मक रूप से अलग हैं। यह उन टूलों की तुलना में सटीकता में एक सार्थक सुधार है जो सब कुछ एक ही तरीके से एम्बेड करते हैं।

### RaBitQ क्वांटाइज़ेशन (v0.13 में नया)

वेक्टर बड़े हैं। एक 1024-dim float32 एम्बेडिंग प्रति चंक 4KB है। हज़ारों चंक से गुणा करें और भंडारण जुड़ जाता है।

RaBitQ न्यूनतम गुणवत्ता हानि के साथ वेक्टर को ~32x संपीड़ित करता है। अधिकांश कोडबेस के लिए, आप सर्च गुणवत्ता में अंतर नहीं देखेंगे। लेकिन आपका इंडेक्स 100MB से 3MB हो जाता है। यह तब मायने रखता है जब आप एक मोनोरेपो को इंडेक्स कर रहे हों।

```bash
octocode config --quantization true
octocode index --force  # संपीड़न के साथ फिर से इंडेक्स करें
```

### संदर्भगत पुनर्प्राप्ति: 49% सुधार

यह [Anthropic के Contextual Retrieval शोध](https://www.anthropic.com/news/contextual-retrieval) पर आधारित है — एक तकनीक जो पुनर्प्राप्ति विफलताओं को 49% कम करती है, और रीरैंकिंग के साथ संयुक्त होने पर 67%। हमने Octocode में दोनों को लागू किया।

कच्चे कोड एम्बेडिंग के साथ समस्या: `process()` नामक फ़ंक्शन का वेक्टर स्पेस में कोई मतलब नहीं है। क्या यह पेमेंट प्रोसेस कर रहा है? HTML पार्स कर रहा है? इमेज कम्प्रेस कर रहा है? एम्बेडिंग मॉडल केवल फ़ंक्शन नाम से नहीं बता सकता।

Octocode इसे दो स्तरों पर हल करता है।

**स्तर 1: संरचनात्मक संदर्भ (हमेशा चालू)।** एम्बेडिंग से पहले प्रत्येक चंक के सामने फ़ाइल पथ, भाषा, और सिंबल नाम जोड़े जाते हैं। तो एम्बेडिंग मॉडल वास्तविक कोड से पहले `# File: src/api/auth.rs / # Language: Rust / # Defines: validate_token, refresh_session` देखता है। यह अकेले ही एक बड़ा सुधार है — एम्बेडिंग को अब पता है कि कोड _कहाँ_ रहता है और _क्या_ परिभाषित करता है।

**स्तर 2: LLM-जनित विवरण (वैकल्पिक)।** जब सक्षम किया जाता है, एक LLM प्रत्येक चंक पढ़ता है और यह 1-2 वाक्य का विवरण लिखता है कि यह क्या करता है। प्रॉम्प्ट विशिष्ट है: "यह कोड क्या करता है इसे ऐसे शब्दों में लिखें जिनसे एक डेवलपर सर्च करेगा।" तो `process()` बनता है "Stripe से आने वाले webhook payloads को मान्य करता है और सही पेमेंट हैंडलर को भेजता है।"

यह विवरण एम्बेडिंग से पहले चंक के सामने जोड़ा जाता है। एम्बेडिंग मॉडल के पास अब कोड और इसके लिए एक प्राकृतिक-भाषा पुल दोनों हैं। वह पुल ठीक वही है जो डेवलपर्स के सर्च करने के तरीके ("webhooks कैसे काम करते हैं?") और कोड के लिखे जाने के तरीके (`fn process(payload: &[u8])`) के बीच की खाई को पाटता है।

```bash
octocode config --contextual-descriptions true
octocode config --contextual-model "openrouter:openai/gpt-4o-mini"
octocode index --force
```

gpt-4o-mini के साथ प्रति हज़ार चंक कुछ सेंट लगते हैं। सर्च गुणवत्ता में उछाल के लिए, यह कोई दिमाग़ की बात नहीं।

### रीरैंकिंग: रिकॉल के बाद सटीकता

वेक्टर सर्च रिकॉल में अच्छा है — घास के ढेर में सही दस्तावेज़ ढूँढना। लेकिन उन परिणामों को सटीक रूप से रैंक करना? वहाँ यह धुंधला हो जाता है। 0.82 और 0.79 समानता पर दो परिणाम ग़लत क्रम में हो सकते हैं।

Octocode दो-चरणीय पुनर्प्राप्ति पाइपलाइन का उपयोग करता है। पहले, वेक्टर सर्च शीर्ष उम्मीदवारों को खींचता है (विस्तृत जाल, उच्च रिकॉल)। फिर एक क्रॉस-एनकोडर रीरैंकर पूर्ण क्वेरी-दस्तावेज़ जोड़ी को एक साथ देखकर प्रत्येक परिणाम को फिर से स्कोर करता है। अलग एम्बेडिंग नहीं — आपके प्रश्न और प्रत्येक कोड चंक के बीच वास्तविक संबंध।

[शोध दिखाता है](https://app.ailog.fr/en/blog/news/reranking-cross-encoders-study) कि क्रॉस-एनकोडर रीरैंकिंग RAG सटीकता में 40% तक सुधार करती है। हमारे परीक्षण में, यह लगातार सबसे प्रासंगिक परिणाम को स्थिति #3 या #4 के बजाय स्थिति #1 पर धकेलता है। "उपयोगी" और "ठीक वही जिसकी आपको ज़रूरत थी" के बीच का अंतर।

रीरैंकर [octolib](https://github.com/Muvon/octolib) के माध्यम से चलता है और कई प्रदाताओं का समर्थन करता है। यह सर्च लेटेंसी में कुछ मिलीसेकंड जोड़ता है। इंसानों के लिए अदृश्य। MCP क्लाइंट के लिए अदृश्य।

```bash
# जब एक प्रदाता कॉन्फ़िगर किया गया हो तो रीरैंकिंग डिफ़ॉल्ट रूप से सक्षम होती है
octocode config --show  # रीरैंकर सेटिंग्स जाँचें
```

संदर्भगत विवरणों के साथ संयुक्त, यह Octocode को एक पुनर्प्राप्ति पाइपलाइन देता है जो पारंपरिक कोड सर्च टूल की तुलना में स्टेट-ऑफ-द-आर्ट RAG सिस्टम के क़रीब है।

## GraphRAG: ज्ञान ग्राफ़

यह वह फ़ीचर है जो Octocode को "सिमेंटिक grep" से अलग करता है।

जब आप GraphRAG सक्षम करते हैं, Octocode एक ग्राफ़ बनाता है जहाँ प्रत्येक फ़ाइल एक नोड है और प्रत्येक संबंध एक एज है। संबंधों में शामिल हैं:

- **imports** — फ़ाइल A फ़ाइल B से इम्पोर्ट करती है
- **sibling_module** — एक ही डायरेक्टरी में फ़ाइलें
- **parent/child_module** — डायरेक्टरी पदानुक्रम

प्रत्येक नोड स्टोर करता है: फ़ाइल पथ, AI-जनित विवरण, निकाले गए सिंबल, इम्पोर्ट/एक्सपोर्ट सूचियाँ, और वेक्टर एम्बेडिंग।

आप इसके साथ क्या कर सकते हैं?

```bash
# ऑथेंटिकेशन से संबंधित सभी फ़ाइलें ढूँढें
octocode graphrag search --query "authentication system"

# ट्रेस करें कि दो फ़ाइलें कैसे जुड़ी हैं
octocode graphrag find-path --source-id src/api/auth.rs --target-id src/db/users.rs

# एक फ़ाइल की भूमिका पर पूर्ण विवरण पाएँ
octocode graphrag get-node --node-id src/api/auth.rs

# एक फ़ाइल के लिए सभी निर्भरताएँ देखें
octocode graphrag get-relationships --node-id src/api/auth.rs

# उच्च-स्तरीय कोडबेस अवलोकन
octocode graphrag overview
```

`find-path` कमांड का कम मूल्यांकन किया गया है। "ऑथ मॉड्यूल डेटाबेस से कैसे जुड़ता है?" एक बड़े प्रोजेक्ट में, वह पथ 4-5 मध्यवर्ती मॉड्यूलों से गुज़र सकता है जिनके बारे में आप नहीं जानते थे। GraphRAG उसे ढूँढ लेता है।

इम्पोर्ट रिज़ॉल्यूशन भाषाओं में भी काम करता है — Rust `use`, Python `import`, TypeScript `import/require`, Go `package`, PHP `use` — सब वास्तविक फ़ाइल पथों पर मैप किए गए।

## MCP टूल्स: AI को आपके कोड में आँखें देना

यहाँ Octocode बदलता है कि आप AI सहायकों के साथ कैसे काम करते हैं।

Claude, Cursor, और Windsurf सभी MCP का समर्थन करते हैं। जब आप Octocode को MCP सर्वर के रूप में कनेक्ट करते हैं, आपका AI सहायक तीन टूल पाता है:

| टूल               | यह क्या करता है                                           |
| ----------------- | --------------------------------------------------------- |
| `semantic_search` | अर्थ के अनुसार कोड, डॉक्स, टेक्स्ट, या कमिट सर्च करें     |
| `view_signatures` | एक glob पैटर्न से मेल खाने वाली फ़ाइलों से संरचना निकालें |
| `graphrag`        | संबंधों और निर्भरताओं के लिए ज्ञान ग्राफ़ क्वेरी करें     |

### सेटअप

अपने Claude Desktop या Cursor कॉन्फ़िग में जोड़ें:

```json
{
	"mcpServers": {
		"octocode": {
			"command": "octocode",
			"args": ["mcp", "--path", "/your/project"]
		}
	}
}
```

बस इतना ही। अब जब आप Claude से पूछते हैं "पेमेंट फ्लो कैसे काम करता है?" — यह मतिभ्रम नहीं करता। यह `semantic_search` कॉल करता है, वास्तविक कोड पढ़ता है, और आपको आपके कोडबेस में आधारित उत्तर देता है।

### LSP इंटीग्रेशन के साथ

```bash
octocode mcp --with-lsp "rust-analyzer"
```

यह 6 और टूल जोड़ता है: `goto_definition`, `hover`, `find_references`, `completion`, `document_symbols`, `workspace_symbols`। आपका AI अब कोड के माध्यम से उसी तरह आगे बढ़ सकता है जैसे आपका IDE करता है — लेकिन प्रोग्रामेटिक रूप से।

### मल्टी-रेपो प्रॉक्सी

कई repos में काम कर रहे हैं? MCP प्रॉक्सी एक डायरेक्टरी में git रिपॉज़िटरी ऑटो-डिस्कवर करता है और उन्हें एकल HTTP एंडपॉइंट के माध्यम से सर्व करता है:

```bash
octocode mcp-proxy --bind 127.0.0.1:8080 --path /workspace
```

## प्रदर्शन

संख्याएँ दावों से अधिक मायने रखती हैं। यह वही है जो हम वास्तविक प्रोजेक्ट पर देखते हैं:

| मेट्रिक                | छोटा (<1K फ़ाइलें) | मध्यम (1-10K) | बड़ा (10K+) |
| ---------------------- | ------------------ | ------------- | ----------- |
| इंडेक्सिंग गति         | 500+ फ़ाइलें/सेक   | 200-400/सेक   | 100-200/सेक |
| सर्च लेटेंसी           | <50ms              | <100ms        | <200ms      |
| मेमोरी                 | 50-100MB           | 100-500MB     | 500MB-2GB   |
| भंडारण (RaBitQ के साथ) | ~300KB             | ~3MB          | ~30MB       |

MCP के लिए सर्च लेटेंसी ही मायने रखती है। जब Claude `semantic_search` कॉल करता है, आप 5 सेकंड इंतज़ार नहीं करना चाहते। सब-100ms का मतलब है कि AI तुरंत महसूस होता है।

इंडेक्सिंग एक बार की है (साथ ही इंक्रीमेंटल अपडेट)। एक 10K फ़ाइल प्रोजेक्ट भी एक मिनट से कम में इंडेक्स होता है।

## 14 भाषाएँ, एक टूल

Octocode पार्सिंग के लिए Tree-sitter का उपयोग करता है, जिसका मतलब है वास्तविक AST विश्लेषण — regex हैक नहीं। वर्तमान में समर्थित:

Rust, Python, TypeScript, JavaScript, Go, PHP, C++, Ruby, Java, Bash, CSS/SCSS, Lua, Svelte, JSON, Markdown।

प्रत्येक भाषा को उचित इम्पोर्ट रिज़ॉल्यूशन, सिंबल निष्कर्षण और संबंध मैपिंग मिलती है। Go पार्सर पैकेज इम्पोर्ट समझता है। Rust पार्सर `use` और `mod` के बारे में जानता है। TypeScript पार्सर `import` और `require` हैंडल करता है। यह एक-आकार-सभी-के-लिए नहीं है — प्रत्येक भाषा पार्सर ट्यून किया गया है।

## v0.13 में क्या बदला

यह हमारी सबसे बड़ी रिलीज़ है। 35 कमिट। यहाँ क्या नया है:

- **कमिट सर्च** — अर्थ के अनुसार git इतिहास सर्च करें, lazy-loaded इंडेक्सिंग के साथ
- **AI CLI कमांड** — `diff`, `explain`, `stats`, `review`, `commit`, `release`
- **संदर्भगत चंक संवर्धन** — Anthropic की Contextual Retrieval तकनीक
- **RaBitQ क्वांटाइज़ेशन** — ~32x वेक्टर संपीड़न
- **OctoHub और Together AI** एम्बेडिंग प्रदाता
- **ब्रांच-अवेयर डेल्टा इंडेक्सिंग** — स्मार्ट इंक्रीमेंटल अपडेट
- **rmcp SDK पर माइग्रेट** — स्थिरता के लिए आधिकारिक Rust MCP कार्यान्वयन
- **बेहतर GraphRAG** — बेहतर नोड रिज़ॉल्यूशन और पथ खोज
- **7 बग फिक्स** — git रूट कमिट, एम्बेडिंग प्रकार, रीरैंकिंग, संबंध गिनती

हम Octocode बनाने के लिए Octocode का उपयोग करते हैं, इसलिए हर रफ़ एज जल्दी पकड़ा जाता है।

## शुरू करना

### macOS (Homebrew)

```bash
brew install muvon/tap/octocode
```

### यूनिवर्सल इंस्टॉल स्क्रिप्ट

```bash
curl -fsSL https://raw.githubusercontent.com/Muvon/octocode/master/install.sh | sh
```

macOS (Intel + Apple Silicon), Linux (x86_64 + ARM64), और Windows पर काम करता है।

### स्रोत से

```bash
cargo install octocode
```

### पहला रन

एक एम्बेडिंग प्रदाता सेट अप करें (Voyage AI 200M मुफ़्त टोकन/महीना देता है):

```bash
export VOYAGE_API_KEY="your-key"
```

इंडेक्स करें और सर्च करें:

```bash
cd your-project
octocode index
octocode search "how does authentication work"
```

GraphRAG सक्षम करें:

```bash
octocode config --graphrag-enabled true
octocode index --force
```

अपने AI सहायक से MCP सर्वर के रूप में कनेक्ट करें — Claude, Cursor, और Windsurf कॉन्फ़िग के लिए [MCP इंटीग्रेशन गाइड](https://github.com/Muvon/octocode#mcp-integration) देखें।

## असली बात

हमने Octocode इसलिए बनाया क्योंकि grep कोड को नहीं समझता। इसलिए नहीं कि grep में कुछ ग़लत है — यह वही करता है जो यह कहता है। लेकिन "स्ट्रिंग `auth` ढूँढो" और "मुझे दिखाओ कि ऑथेंटिकेशन कैसे काम करता है" मौलिक रूप से अलग सवाल हैं।

कीवर्ड सर्च से सिमेंटिक सर्च में बदलाव एक फ़ीचर नहीं है। यह एक श्रेणी परिवर्तन है। और MCP के साथ, यह सिर्फ़ इंसानों के लिए नहीं है — यह वही है जैसे AI सहायक भी आपके कोड को समझते हैं।

हम इसका उपयोग Muvon में सब कुछ बनाने के लिए करते हैं। यह वह टूल है जो दो लोगों की टीम को संभव बनाता है। और यह मुफ़्त है, ओपन सोर्स है, Apache 2.0।

260+ GitHub स्टार। 14 भाषाएँ। एक Rust बाइनरी। [इसे आज़माएँ](https://github.com/Muvon/octocode)।