# Claude Code LSP: अपने एजेंट के लिए नेविगेशन टूल चुनें

> Claude Code LSP लैंग्वेज-सर्वर नेविगेशन जोड़ता है, लेकिन grep, सिमेंटिक सर्च और Tree-sitter अलग-अलग सवालों के जवाब देते हैं। इनके सेटअप और सीमाओं की तुलना करें।

अगर आपने “Claude Code LSP” सर्च किया है, तो हो सकता है आपका एजेंट टेक्स्ट मैच करके डेफिनिशन ढूँढ रहा हो जबकि आपको IDE वाला जवाब चाहिए। एक Claude Code लैंग्वेज सर्वर प्लगइन उसे LSP के ज़रिए वह नेविगेशन दे सकता है, लेकिन कोड खंगालने के चार काम के तरीक़ों में से यह एक है। चुनाव उस सवाल के हिसाब से करें जिसका जवाब आपकी रिपॉज़िटरी को चाहिए, और इस बात के हिसाब से कि आप क्या चालू रख सकते हैं।

**संक्षिप्त उत्तर:** Claude Code का LSP टूल किसी लैंग्वेज सर्वर से go-to-definition, find references और hover जैसे ऑपरेशन रिक्वेस्ट कर सकता है; आधिकारिक चेंजलॉग इस टूल को दर्ज करता है, और Claude Code का प्लगइन सिस्टम लैंग्वेज-सर्वर इंटीग्रेशन उपलब्ध कराता है। जब टाइप-अवेयर नेविगेशन मायने रखती हो और आप सर्वर इंस्टॉल व कॉन्फ़िगर कर सकते हों, तो यही सही शुरुआती बिंदु है। Claude Code का grep पहले से उपलब्ध है और तब अच्छा काम करता है जब आपको कोई नाम या वाक्यांश पता हो। सिमेंटिक सर्च तब मदद करती है जब सवाल किसी जाने-पहचाने सिंबल के बारे में नहीं, बल्कि अर्थ के बारे में हो। Tree-sitter सिंबल टूल लैंग्वेज सर्वर या पर्सिस्टेंट इंडेक्स के बिना डेफिनिशन्स और कोड संबंध सामने रख सकते हैं, लेकिन वे सिंटैक्स और नामों से संबंधों का अनुमान लगाते हैं। हम octofs और octocode बनाते हैं। 15 नवंबर 2026 की एक-रन, छह-टास्क तुलना में, octofs 0.25 कोड ने tokio पर 6,561 टोकन और cargo पर 1,101 टोकन लौटाए; octocode 0.29.0 ने 11,093 और 4,826 लौटाए। ये टूल रिस्पॉन्स हैं, इस बात का सबूत नहीं कि एक तरीक़ा एजेंट के बेहतर नतीजे देता है।

## Claude Code LSP बनाम grep: LSP क्या जोड़ता है?

LSP किसी लैंग्वेज सर्वर से कहता है कि वह सोर्स की किसी स्थिति पर कोड इंटेलिजेंस रिक्वेस्ट हल करे; grep मैच होने वाला टेक्स्ट ढूँढता है। LSP तब इस्तेमाल करें जब “इस सिंबल के हर रेफ़रेंस ढूँढो” में सिंबल को कमेंट, स्ट्रिंग और असंबंधित आइडेंटिफ़ायर से अलग करना ज़रूरी हो।

[Language Server Protocol स्पेसिफ़िकेशन](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/) एक references रिक्वेस्ट परिभाषित करता है जो किसी स्थिति पर मौजूद सिंबल के लिए “प्रोजेक्ट-व्यापी रेफ़रेंस” हल करती है, और उसके इनकमिंग व आउटगोइंग कॉल के लिए call-hierarchy रिक्वेस्ट भी। एक लैंग्वेज सर्वर इन रिक्वेस्ट को हल करने के लिए अपनी भाषा और प्रोजेक्ट की समझ इस्तेमाल कर सकता है। grep का फ़ायदा दूसरा है: यह शाब्दिक टेक्स्ट सर्च करता है, बिना इस ज़रूरत के कि कोई लैंग्वेज सर्वर शुरू हो या प्रोजेक्ट को समझे।

| ज़रूरत                                                        | इससे शुरू करें                         | क्यों                                                                                   |
| ------------------------------------------------------------- | -------------------------------------- | --------------------------------------------------------------------------------------- |
| जानी-पहचानी स्ट्रिंग, फ़्लैग, एरर या कॉन्फ़िगरेशन key ढूँढ़ें | `rg 'pattern' src`                     | सीधा टेक्स्ट मैच; किसी प्रोजेक्ट मॉडल की ज़रूरत नहीं                                    |
| भाषा की समझ के साथ डेफिनिशन या रेफ़रेंस हल करें               | Claude Code LSP और उससे मेल खाता सर्वर | सर्वर definition और references जैसी रिक्वेस्ट का जवाब देता है                           |
| पूछें कि कोई कॉन्सेप्ट या व्यवहार कहाँ लागू है                | सिमेंटिक कोड सर्च                      | जब सिंबल का नाम न पता हो तो अर्थ के आधार पर सर्च करें                                   |
| चल रहे सर्वर के बिना नाम और सिंटैक्स संबंध मैप करें           | Tree-sitter सिंबल टूल                  | फ़ाइलें माँग पर पार्स करें और सिंबल संबंध सामने रखें, हालाँकि सिमेंटिक गारंटी कमज़ोर है |

टेक्स्ट मैच में कोड के बाहर की जगहें भी आ सकती हैं, जबकि पार्सर से निकला संबंध भाषा-स्तर का रेज़ोल्यूशन चूक सकता है। [सिमेंटिक कोड सर्च](/blog/octocode-semantic-code-search) और [स्ट्रक्चरल सर्च](/blog/octocode-0-14-0-structural-search) पर हमारे ओवरव्यू देखें; इन्हें अलग-अलग काम मानें, रेफ़रेंस का विकल्प नहीं।

## Claude Code में LSP कैसे चालू करें?

आधिकारिक [Code intelligence plugins](https://code.claude.com/docs/en/plugins/code-intelligence) पेज के अनुसार चलें। टर्मिनल सत्र में पहले सर्वर बाइनरी इंस्टॉल करें, फिर Claude Code लॉन्च करें और उसके प्रॉम्प्ट पर लैंग्वेज प्लगइन इंस्टॉल करें। Claude Code TypeScript LSP सेटअप के लिए, जो JavaScript को भी कवर करता है, डॉक्स `typescript-language-server` और यह बाइनरी इंस्टॉल कमांड बताते हैं:

```text
npm install -g typescript-language-server typescript
```

फिर, Claude Code के अंदर:

```text
/plugin install typescript-lsp@claude-plugins-official
```

ये सिर्फ़ डॉक्स वाली कमांड हैं; हमने इन्हें चलाया नहीं है। Claude पहली बार किसी मैचिंग फ़ाइल को एडिट करते समय सर्वर शुरू करता है। डॉक्स कहते हैं कि `Found N new diagnostic issues in M files (ctrl+o to expand)` वाली लाइन इसकी पुष्टि करती है कि वह शुरू हो गया; वरना `/plugin` चलाएँ और Errors टैब देखें। चेंजलॉग LSP टूल सपोर्ट की तारीख़ Claude Code v2.0.74, 19 दिसंबर 2025 बताता है। `ENABLE_LSP_TOOL` 15 नवंबर 2026 को जाँचे गए मौजूदा डॉक्स में नहीं दिखता।

अगर Claude Code LSP काम नहीं कर रहा और Claude `No LSP server available for file type` रिपोर्ट करता है, तो जाँचें कि प्लगइन इंस्टॉल और सक्रिय है और सर्वर बाइनरी `PATH` पर है। एक [दिसंबर 2025 की इशू रिपोर्ट](https://github.com/anthropics/claude-code/issues/15619) दर्ज करती है कि सर्वर इंस्टॉल होने के बावजूद यह एरर आया था, और उस समय `ENABLE_LSP_TOOL=1` वर्कअराउंड था। एक Anthropic सहयोगी ने इसे 17 अगस्त 2026 को “यह LSP प्लगइन्स के ज़रिए काम करता है” कहकर बंद कर दिया, इसलिए इस रिपोर्ट को इतिहास मानें, मौजूदा रिलीज़ की स्थिति नहीं।

हमने 15 नवंबर 2026 को Anthropic के डॉक्स और चेंजलॉग जाँचे। LSP तब काम का है जब वह आपके प्रोजेक्ट के साथ चल जाए, लेकिन प्लगइन और लैंग्वेज-सर्वर सेटअप एक असली निर्भरता बनी रहती है। अगर आप एजेंट एनवायरनमेंट में एक इंस्टॉल नहीं कर सकते, तो नेविगेशन का कोई दूसरा रास्ता चुनें।

## LSP, सिमेंटिक सर्च, grep या Tree-sitter सिंबल: आपका सवाल कौन हल करता है?

सवाल का सटीक जवाब देने में सक्षम सबसे संकीर्ण टूल इस्तेमाल करें। कॉल हायरार्की जाने-पहचाने सिंबल के बीच के संबंधों के बारे में है; सिमेंटिक सर्च उन कॉन्सेप्ट्स के लिए है जिनका नाम आप अभी नहीं ले सकते।

| तरीक़ा                      | किसका जवाब अच्छा देता है                                            | सेटअप और रनटाइम                                                                                    | कहाँ ग़लत हो सकता है                                                                | इसे तब चुनें…                                                                   |
| --------------------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Grep (`rg`)                 | “यह बिल्कुल वही नाम या टेक्स्ट कहाँ आता है?”                        | कोई इंडेक्स या सर्वर नहीं                                                                          | कमेंट, स्ट्रिंग, मिलते-जुलते नाम वाले सिंबल मैच करता है; किसी सिंबल को हल नहीं करता | आपको सर्च करने के लिए कोई शाब्दिक टेक्स्ट पता है, या एक भरोसेमंद पहला पास चाहिए |
| LSP के ज़रिए लैंग्वेज सर्वर | “इस सिंबल की डेफिनिशन, रेफ़रेंस, कॉलर या टाइप क्या है?”             | लैंग्वेज सर्वर इंस्टॉल करें और क्लाइंट/प्लगइन कॉन्फ़िगर करें; सर्वर प्रोजेक्ट स्टेट लोड कर सकता है | कवरेज और व्यवहार सर्वर, भाषा और प्रोजेक्ट कॉन्फ़िगरेशन पर निर्भर करते हैं           | टाइप-अवेयर जवाब मायने रखते हैं और प्रोजेक्ट का सर्वर उपलब्ध है                  |
| सिमेंटिक सर्च               | “रिट्राई पॉलिसी कहाँ लागू है?”                                      | आमतौर पर एक एम्बेडिंग मॉडल और एक इंडेक्स; बारीकियाँ प्रोडक्ट के हिसाब से बदलती हैं                 | अर्थ का मिलना किसी कॉल या रेफ़रेंस संबंध का सबूत नहीं है                            | आपको व्यवहार पता है, नाम या फ़ाइलें नहीं                                        |
| Tree-sitter सिंबल           | “इस नाम के आस-पास कौन-सी डिक्लेरेशन और सिंटैक्स-स्तर के संबंध हैं?” | पार्सर ग्रामर और एक टूल; LSP सर्वर या पर्सिस्टेंट इंडेक्स के बिना चल सकता है                       | सिंटैक्स और नाम न टाइप तय करते हैं, न हर हल किया गया कॉल                            | आपको बिना सर्वर सेटअप के हल्का सिंबल नेविगेशन चाहिए                             |

[Tree-sitter प्रोजेक्ट](https://tree-sitter.github.io/tree-sitter/) के अनुसार, Tree-sitter एक पार्सर जेनरेटर और इंक्रीमेंटल पार्सिंग लाइब्रेरी है जो कंक्रीट सिंटैक्स ट्री बनाती है। सिंटैक्स ट्री टूल को जाँचने लायक ढाँचा देती है; अकेला पार्सर न टाइप चेकर देता है, न किसी प्रोजेक्ट का हल किया गया कॉल ग्राफ़। Aider का [repo map इम्प्लीमेंटेशन](https://github.com/Aider-AI/aider/blob/main/aider/repomap.py) सोर्स ढाँचे को एजेंट के लिए एक सघन मैप में बदलने की एक और मिसाल है।

यह फ़र्क़ “एजेंटिक सर्च बनाम RAG” जैसा नहीं है। एक रिट्रीवल इंडेक्स अर्थ के आधार पर प्रासंगिक हिस्से ढूँढने में मदद कर सकता है; स्पष्ट नेविगेशन टूल सटीक स्ट्रक्चरल सवालों के जवाब देते हैं। उस अलग वर्कफ़्लो के लिए हमारी [लोकल सिमेंटिक इंडेक्सिंग गाइड](/blog/indexing-large-codebase-semantic-search-locally) देखें।

## Claude Code जैसे कोडिंग एजेंट को अब भी कोडबेस इंडेक्सिंग चाहिए?

हमेशा नहीं: Claude Code और Cline बिना पहले से इंडेक्स किए कोड कॉन्टेक्स्ट जुटाते हैं, और Cursor, जिसने नवंबर 2025 में सिमेंटिक सर्च से फ़ायदा मापा था, ने जुलाई 2026 में कहा कि वह grep के पक्ष में अपना सिमेंटिक इंडेक्स बंद कर रहा है। अगस्त 2026 के एक प्रीप्रिंट ने रीड-ओनली सवालों पर रिट्रीवल को फिर भी आगे पाया, इसलिए जवाब टास्क पर निर्भर करता है।

Anthropic की 2025 की इंजीनियरिंग पोस्ट एक हाइब्रिड का वर्णन करती है: कुछ कॉन्टेक्स्ट शुरू में ही लोड होता है, बाक़ी एजेंट ज़रूरत पड़ने पर टूल से लाता है। वह कहती है, “Claude Code एक एजेंट है जो इस हाइब्रिड मॉडल को अपनाता है”, जिसमें `CLAUDE.md` फ़ाइलें शुरू से कॉन्टेक्स्ट में रहती हैं और फ़ाइलें ठीक वक़्त पर ढूँढने के लिए `glob` और `grep` इस्तेमाल होते हैं। Claude Code टीम के Boris Cherny ने [Latent Space पॉडकास्ट](https://www.latent.space/p/claude-code) (7 मई 2025) पर कहा कि शुरुआती वर्ज़न इंडेक्स किए गए कोडबेस पर RAG इस्तेमाल करते थे और एजेंटिक सर्च “बाक़ी हर चीज़ से बेहतर निकली”; यह पूछे जाने पर कि किस बेंचमार्क पर, उन्होंने कहा “ज़्यादातर वाइब्स”। Cline के Nick Baumann ने 27 मई 2025 को लिखा: “हम आपका कोडबेस इंडेक्स नहीं करते”। ये उनके अपने तरीक़ों का वर्णन हैं; इनमें से कोई यह तय नहीं करता कि हर कोडबेस के लिए सबसे अच्छा क्या है।

Cursor की 6 नवंबर 2025 की पोस्ट रिपोर्ट करती है कि सिमेंटिक सर्च ने उसके अपने मूल्यांकन सेट पर, उसके अपने एम्बेडिंग मॉडल के साथ, “औसतन 12.5% ज़्यादा सटीकता हासिल की सवालों के जवाब देने में (मॉडल के हिसाब से 6.5%–23.5%)”। उसके ऑनलाइन A/B टेस्ट में असर छोटा निकला: एजेंट कोड रिटेंशन 0.3% बढ़ा, और 1,000 या उससे ज़्यादा फ़ाइलों वाले कोडबेस पर 2.6%। 12.5% सवाल-जवाब की सटीकता है, उत्पादन में हर जगह होने वाला सुधार नहीं।

Cursor ने तब से अपना रुख़ बदल लिया है। जुलाई 2026 में उसके फ़ोरम पर एक स्टाफ़ सदस्य ने [लिखा](https://forum.cursor.com/t/what-do-you-think-about-cursor-removing-the-codebase-indexing-settings/165899/5) कि मॉडल grep और इंडेक्स्ड सर्च इस्तेमाल करने में बहुत अच्छे हो गए हैं, इसलिए “पुराना समर्पित सिमेंटिक सर्च रास्ता तेज़ी से किसी मायने में मददगार नहीं रह गया था”। एक सपोर्ट इंजीनियर ने अगले दिन [पुष्टि की](https://forum.cursor.com/t/what-do-you-think-about-cursor-removing-the-codebase-indexing-settings/165899/10): “सिमेंटिक/एम्बेडिंग इंडेक्सिंग को grep-आधारित रिट्रीवल के पक्ष में बंद किया जा रहा है।” Cursor अब भी एक लोकल इंडेक्स बनाता है, लेकिन रेगेक्स सर्च के लिए, जिसमें कोई एम्बेडिंग नहीं होता।

सबूत एकतरफ़ा नहीं हैं। [अगस्त 2026 का एक प्रीप्रिंट](https://arxiv.org/abs/2608.01507), जो रिव्यू के अधीन है, रिपोर्ट करता है कि SWE-QA बेंचमार्क पर सिमेंटिक सर्च ने 65.2% रिपॉज़िटरी सवालों के सही जवाब दिए, जबकि सबएजेंट को सौंपी गई grep सर्च ने 46.2%। यह पहले से इंडेक्स की गई रिपॉज़िटरी पर रीड-ओनली सवालों को कवर करता है।

**हमारा नज़रिया:** आज के मॉडल के साथ साधारण टूल जीतते हैं। वे सटीक सर्च से कोड खंगालना सीख चुके हैं, और वे इसे अच्छी तरह करते हैं: नाम सर्च करो, फ़ाइल पढ़ो, सिंबल का पीछा करो। हमारे इस्तेमाल में, एजेंट के लिए सिमेंटिक सर्च उतना नहीं जोड़ती जितना हमने सोचा था, और Cursor भी इसी नतीजे पर पहुँचा; हमारे पास जो कमी थी वह थी बिना सेटअप वाला सिंबल नेविगेशन। एम्बेडिंग इंडेक्स एक सेटअप स्टेप है (octocode की सिमेंटिक सर्च के लिए पहले `octocode index` चलाना पड़ता है), इसलिए यह तब तक बंद रहता है जब तक कोई इसे सेटअप न करे, और हम पाते हैं कि यह किसी अनजाने कोडबेस को खंगाल रहे इंसान की मदद एजेंट से ज़्यादा करता है। इसलिए हमने सिमेंटिक सर्च रखी (octocode डिफ़ॉल्ट सिमेंटिक प्रोवाइडर बना रहता है) और सिंबल वाले सवालों को फ़ाइल सर्वर में ले गए। यह दोनों टूल बनाने और इस्तेमाल करने से बनी हमारी राय है; हमने एजेंट के नतीजों की तुलना करने वाला कोई प्रयोग नहीं चलाया है।

| एजेंट के सामने सवाल                                                  | बिना इंडेक्स के इसका जवाब क्या देता है / इसके लिए इंडेक्स चाहिए         |
| -------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| यह बिल्कुल वही नाम या स्ट्रिंग कहाँ है?                              | grep सीधे जवाब देता है, इंडेक्स नहीं।                                   |
| इस सिंबल की डेफिनिशन या कॉलर क्या है?                                | LSP या सिंटैक्स-आधारित सिंबल नेविगेशन; पर्सिस्टेंट इंडेक्स ज़रूरी नहीं। |
| यह व्यवहार कहाँ लागू है जब मैं उसे बता सकता हूँ पर नाम नहीं ले सकता? | इंडेक्स पर सिमेंटिक सर्च अर्थ के आधार पर प्रासंगिक कोड ला सकती है।      |

## सिंबल नेविगेशन को फ़ाइल सर्वर में ले जाते समय हमने क्या मापा?

हमने tokio और cargo पर छह नेविगेशन टास्क की तुलना की: आउटलाइन, डेफिनिशन्स, रेफ़रेंस, कॉलर, सुपरटाइप या सबटाइप, और एक कॉल पाथ। इस रन में टूल रिस्पॉन्स टोकन और कॉल मापे गए, यह नहीं कि एजेंट ने कोई कोडिंग टास्क बेहतर पूरा किया या नहीं।

हम दो MCP सर्वर बनाते हैं: octocode सिमेंटिक सर्च और एक सिंबल ग्राफ़ देता है, जबकि octofs फ़ाइल टूल देता है। 15 नवंबर 2026 को रिलीज़ हुए octofs 0.25.0 में, `symbol` टूल डेफिनिशन्स, रेफ़रेंस, कॉलर, कॉली, सुपरटाइप, सबटाइप, इम्पोर्ट, imported-by संबंध और कॉल पाथ जोड़ता है। यह Tree-sitter इस्तेमाल करता है, बिना लैंग्वेज सर्वर, डिस्क पर पर्सिस्टेंट इंडेक्स या एम्बेडिंग के।

15 नवंबर 2026 को हमने octocode 0.29.0 की तुलना octofs की उस बिल्ड से की जो वर्ज़न बंप से पहले 0.25.0 सोर्स से बनी थी (बाइनरी 0.24.0 छापती है), और टोकन `o200k_base` टोकनाइज़र से गिने। तुलना में दो रिपॉज़िटरी, tokio और cargo, और एक रन में छह टास्क शामिल थे; यह एजेंट के नतीजों का बेंचमार्क नहीं था। octofs के जवाब 12-कोर Linux मशीन पर लिए गए थे और 10 कोर वाले Apple M5 लैपटॉप पर बाइट-दर-बाइट एक जैसे लौटे, जहाँ octocode चला और दोनों टूल की टाइमिंग ली गई।

| रिपॉज़िटरी | octofs रिस्पॉन्स टोकन | octocode रिस्पॉन्स टोकन | कॉल: octofs / octocode |
| ---------- | --------------------: | ----------------------: | ---------------------: |
| tokio      |                 6,561 |                  11,093 |                 8 / 12 |
| cargo      |                 1,101 |                   4,826 |                 7 / 10 |
| कुल        |                 7,662 |                  15,919 |                15 / 22 |

रिस्पॉन्स-टोकन के कुल आँकड़े छह टास्क में लौटे टूल टेक्स्ट की गिनती हैं। इनमें मॉडल का अपना रिक्वेस्ट टेक्स्ट शामिल नहीं है, और ये नहीं बताते कि कौन-सा नतीजा एजेंट को बेहतर पैच तक ले जाएगा। ख़ास तौर पर, एक references टास्क को octocode के पेजिनेटेड 111-मैच नतीजे से मिलाकर नहीं जाँचा गया, और हाथ से की गई जाँच कोई सटीकता अध्ययन नहीं है।

टूल-डेफिनिशन का आकार भी बदलता है जब स्ट्रक्चरल और ग्राफ़ सर्च octofs में चली जाती हैं। ये आँकड़े मापे गए दोनों बिल्ड की प्रति-टूल डेफिनिशन साइज़ का जोड़ हैं; इन्हें किसी चल रहे Octomind सत्र के अंदर नहीं लिया गया, और बदलाव से पहले की octofs `view` डेफिनिशन मापी नहीं गई।

| कॉन्फ़िगरेशन                          | दिए गए टूल | डेफिनिशन टोकन |
| ------------------------------------- | ---------: | ------------: |
| octocode पर स्ट्रक्चरल और ग्राफ़ सर्च |         10 |         6,455 |
| octofs पर स्ट्रक्चरल और ग्राफ़ सर्च   |          8 |         5,468 |

फ़र्क़ 987 टोकन का है। सिमेंटिक सर्च octocode पर ही रहती है। टैप में, वह रजिस्ट्री बदलाव जो स्ट्रक्चरल और ग्राफ़ सर्च के लिए octofs को डिफ़ॉल्ट बनाता है, अगले टैप अपडेट के साथ आएगा; 15 नवंबर 2026 को वह अभी `master` पर नहीं था। octocode की ग्राफ़ क्वेरी चुने जा सकने वाले प्रोवाइडर के रूप में उपलब्ध बनी रहती हैं।

उसी M5 लैपटॉप पर, octofs की हर कॉल अधिकतम 0.105 सेकंड लगी, जिसमें नया प्रोसेस और उसका इन-मेमोरी टेबल बिल्ड शामिल था। हमने इस पोर्ट को उसी एक काम के लिए ऑप्टिमाइज़ किया: प्रति क्वेरी एक सीमित जवाब। octocode अलग तरह काम करता है: किसी प्रोसेस में पहली `graphrag` कॉल पूरा ग्राफ़ बनाती है, जबकि इसकी स्ट्रक्चरल सर्च और सिग्नेचर व्यू ग्राफ़ बनने का इंतज़ार नहीं करते। हमने octocode को सिर्फ़ `.git` के बिना कॉपियों पर चलाया, `--no-git` के साथ, और उसकी तुलना सामान्य चेकआउट से नहीं की, इसलिए हम इसके ग्राफ़ बिल्ड की कोई टाइमिंग नहीं देते। ये आँकड़े हमारे छह टास्क और हमारे तरीक़े का वर्णन करते हैं; ये दोनों टूल की रैंकिंग नहीं करते।

## Tree-sitter सिंबल नेविगेशन कहाँ ग़लत होती है?

Tree-sitter के संबंधों को नेविगेशन में मददगार चीज़ मानें, टाइप-रेज़ॉल्व्ड सच नहीं। हमारा octofs इम्प्लीमेंटेशन नाम और इम्पोर्ट निकालता है, अनिश्चित संबंधों को `(guess)` से चिह्नित कर सकता है, और ग्राफ़ संबंधों को लोकल पाथ तक सीमित रखता है।

प्रति क्वेरी इसकी दर्ज सीमाएँ 800 ms, 600 पार्स की गई फ़ाइलें और 100 लिस्ट किए गए नतीजे हैं, और ग्राफ़ संबंध 1 MB से बड़ी फ़ाइलें छोड़ देते हैं। यह मैनिफ़ेस्ट या TypeScript पाथ एलियास नहीं पढ़ता। अगर यह किसी कैप तक पहुँच जाए, तो जवाब अधूरा हो सकता है और उसमें एक दोहराव की सूचना शामिल होती है। टाइप-सटीक रेफ़रेंस या एलियास के ज़रिए प्रोजेक्ट-व्यापी रेज़ोल्यूशन के लिए लैंग्वेज सर्वर बेहतर फ़िट है।

इस तुलना ने एक ठोस साझा चूक उजागर की। tokio में, फ्री फ़ंक्शन `spawn_blocking` के ऐसे कॉलर हैं जो उस तक पाथ-क्वालिफ़ाइड कॉल और एक री-एक्सपोर्ट के ज़रिए पहुँचते हैं। किसी भी टूल ने वे असली कॉलर नहीं गिनाए। octofs ने डेफिनिशन के लिए `(none)` लौटाया; octocode ने कोई इनकमिंग कॉल एज नहीं दिखाया। इसलिए दिखने में सही लगने वाली खाली कॉलर लिस्ट इस बात का सबूत नहीं है कि किसी फ़ंक्शन के कॉलर नहीं हैं। octofs 0.25.0 में यह चूक है। वर्ज़न 0.25.1 इसे ठीक करता है: वही संकरी की गई क्वेरी फ्री फ़ंक्शन के 10 कॉलर गिनाती है, जिनमें `JoinSet::spawn_blocking` भी है। ऊपर दी टोकन तालिका 0.25.0 कोड से है और उसे दोबारा नहीं चलाया गया।

किसी अहम संबंध पर काम करने से पहले उसे सोर्स से मिलाकर जाँच लें। tree-sitter कॉल ग्राफ़ जेनरेटर या कॉल हायरार्की के लिए, अपनी भाषा में एक सकारात्मक नतीजा और एक जाना-पहचाना नकारात्मक या री-एक्सपोर्ट केस, दोनों की पुष्टि करें। जब जवाब किसी बड़े रीफ़ैक्टर को प्रभावित करता हो, तो लैंग्वेज सर्वर इस्तेमाल करें या कॉल साइट सीधे देखें।

## अपने एजेंट को कौन-सा कोड नेविगेशन टूल दें?

टाइप-अवेयर सिंबल जवाब के लिए LSP चुनें, जाने-पहचाने टेक्स्ट के लिए grep, आम भाषा में बताए गए व्यवहार के लिए सिमेंटिक सर्च, और Tree-sitter तब जब आपको बिना सर्वर या पर्सिस्टेंट इंडेक्स के सिंटैक्स-स्तर की नेविगेशन चाहिए।

हम [octofs](https://github.com/Muvon/octofs) बनाते हैं, एक ओपन-सोर्स MCP फ़ाइल सर्वर जिसमें वर्ज़न 0.25.0 से `symbol` नेविगेशन है। इसे `cargo install octofs` से इंस्टॉल करें। इसके संबंध सिंटैक्स-आधारित, सीमित हैं और अनुमान हो सकते हैं; इन्हें टाइप-सटीक सबूत की तरह इस्तेमाल न करें। इसे तब चुनें जब एजेंट को LSP सेटअप के बिना डेफिनिशन्स और लोकल कोड संबंध चाहिए हों। लैंग्वेज सर्वर बनाए रखें जब हल किए गए रेफ़रेंस और टाइप मायने रखते हों, और सिमेंटिक सर्च उपलब्ध रखें उन सवालों के लिए जो सिंबल के नाम से नहीं, अर्थ से शुरू होते हैं।

- अगर रिपॉज़िटरी में काम करने वाला लैंग्वेज सर्वर है और सटीकता मायने रखती है, तो Claude Code LSP कॉन्फ़िगर करें।
- अगर आपको बिल्कुल वही नाम या स्ट्रिंग पता है, तो `rg` से शुरू करें।
- अगर आप व्यवहार बता सकते हैं लेकिन उसका इम्प्लीमेंटेशन नहीं, तो सिमेंटिक सर्च इस्तेमाल करें।
- अगर आपको हल्का लोकल सिंबल नेविगेशन चाहिए, तो Tree-sitter आज़माएँ और अहम संबंधों की सोर्स में पुष्टि करें।

— Don

---

_हम समर्पित कोडिंग वर्कफ़्लो के लिए ओपन-सोर्स टूल बनाते हैं। [GitHub पर octofs देखें](https://github.com/Muvon/octofs) या बताएँ कि अगली बार हम किस नेविगेशन केस को डॉक्यूमेंट करें।_
