कोडिंग एजेंट्स के लिए Graft codebase map कैसे बनाएं

कोडिंग एजेंट्स के लिए codebase map क्या है

कोडिंग एजेंट्स के लिए codebase map आपके रिपॉजिटरी का एक स्थायी इंडेक्स होता है। एजेंट हर नए सेशन में शुरुआत से grepping करने के बजाय इसमें जानकारी खोजता है। Graft इस विचार का एक कार्यान्वयन (implementation) है। यह tree-sitter का उपयोग करके आपके कोड को पार्स करता है, लिंक्ड markdown नोड्स का एक फोल्डर और प्रति-सिंबल वायरिंग ग्राफ बनाता है, और MCP (model context protocol, वह मानक इंटरफ़ेस जिसका उपयोग कोडिंग एजेंट्स बाहरी टूल्स को कॉल करने के लिए करते हैं) के माध्यम से रिट्रीवल टूल्स प्रदान करता है।

Graft न तो कोई प्रॉक्सी है और न ही कोई गेटवे। आपके एजेंट और मॉडल API के बीच कुछ भी नहीं होता है। मैप डिस्क पर स्थित एक फोल्डर है जिसे एजेंट पढ़ता है। यह अंतर तय करता है कि आप किस समस्या का समाधान कर रहे हैं: एक self-hosted token gateway उन अनुरोधों को मापता और रूट करता है जिन्हें आप पहले से भेज रहे हैं, जबकि एक मैप यह बदल देता है कि आपको कुल कितने अनुरोध भेजने की आवश्यकता है।

यह तकनीक इस टूल से पुरानी है और इसके बाद भी बनी रहेगी। पहले तकनीक को समझें, फिर उसकी कार्यप्रणाली को।

कोडिंग एजेंट्स संदर्भ को फिर से खोजने में कॉन्टेक्स्ट क्यों बर्बाद करते हैं

एक एजेंट को उस रिपॉजिटरी पर काम शुरू करते हुए देखें जिसे वह पचास बार देख चुका है। यह डायरेक्टरीज़ की सूची बनाता है। यह किसी सिंबल के लिए grep चलाता है। यह यह पता लगाने के लिए तीन फाइलें खोलता है कि फंक्शन कहाँ परिभाषित है, फिर चौथा यह जानने के लिए कि उसे कौन कॉल करता है। इनमें से कोई भी कार्य का हिस्सा नहीं है। यह ओरिएंटेशन है, और हर एक सेशन में इसके लिए इनपुट टोकन के रूप में भुगतान किया जाता है।

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

एक मैप डिस्कवरी को मॉडल से हटाकर डिस्क पर ले जाकर उस लूप को तोड़ता है। एक पार्सर रिपॉजिटरी को एक बार स्कैन करता है, रिकॉर्ड करता है कि कौन सा सिंबल कहाँ परिभाषित है और कौन सा सिंबल किसे कॉल करता है, फिर कोड बदलने पर उस रिकॉर्ड को अपडेट रखता है। एजेंट एक सवाल पूछता है और फाइल और लाइन के साथ जवाब प्राप्त करता है। बार-बार की जाने वाली खोज एक सस्ता लुकअप बन जाती है।

आप पहले से ही इसका एक कमजोर संस्करण उपयोग कर रहे हैं। एक AGENTS.md जो आपके कन्वेंशन बताता है एजेंट को हर बार आपके कन्वेंशन को फिर से समझने से रोकता है। एक जनरेट किया गया मैप इसे आपकी संरचना को फिर से खोजने से रोकता है। अंतर यह है कि इसे लिखता कौन है। आप इंस्ट्रक्शन फाइल खुद लिखते हैं, इसलिए यह छोटी रहती है। एक पार्सर मैप जनरेट करता है, इसलिए यह दस हजार फाइलों को कवर कर सकता है। एक सेशन के भीतर बजट वास्तव में कहाँ खर्च होता है, इसके लिए Claude Code अपनी कॉन्टेक्स्ट विंडो कैसे खर्च करता है अकाउंटिंग को कवर करता है।

Graft वास्तव में क्या बनाता है

दो आर्टिफैक्ट्स, दोनों रिपॉजिटरी रूट पर एक graft/ फोल्डर के अंतर्गत।

पहला एक नोड ग्राफ है जिसे लिंक्ड मार्कडाउन के रूप में लिखा गया है, प्रति नोड एक फाइल। प्रत्येक नोड में एक सरल-अंग्रेजी सारांश, सोर्स से निकाली गई महत्वपूर्ण लॉजिक लाइनों का एक "क्रक्स" (crux), कंटेंट हैश के साथ सटीक सोर्स फाइलें, अन्य नोड्स के लिए टाइप्ड विकिलिंक्स (depends_on, part_of, uses, implements), और एक नोट्स सेक्शन होता है जो रीजेनरेशन के बाद भी बना रहता है ताकि आप वह संदर्भ रिकॉर्ड कर सकें जिसे पार्सर अनुमानित नहीं कर सकता।

दूसरा graft/.graph/wiring.json है, जो प्रति-सिंबल स्ट्रक्चरल ग्राफ है जिसे tree-sitter निकालता है: डेफिनिशन, रेफरेंस और उनके बीच के कॉल एजेस।

यह विभाजन महत्वपूर्ण है क्योंकि केवल आधे हिस्से को ही मॉडल की आवश्यकता होती है। graft build पूरी तरह से tree-sitter है और कभी भी LLM (लार्ज लैंग्वेज मॉडल) को कॉल नहीं करता है, इसलिए यह डिटरमिनिस्टिक है और इसकी कोई लागत नहीं है। graft build --deep लिखित सारांश और प्रति-सिंबल क्रक्स को जोड़ता है, और ये वे मॉडल कॉल हैं जिनके लिए आप भुगतान करते हैं।

लैंग्वेज सपोर्ट को टियर में बांटा गया है, और टियर आपको बताता है कि कॉल ग्राफ पर कितना भरोसा करना है। TypeScript, JavaScript, Python, Go और Java को स्कोप-अवेयर क्रॉस-फाइल रिज़ॉल्यूशन मिलता है। Rust, C, C++, C#, Ruby, PHP, Kotlin, Scala, Swift, Elixir, Solidity, OCaml, Zig और Dart को सिंबल के साथ जेनेरिक कॉल एजेस मिलते हैं, जिसका अर्थ है कि एक एज रिज़ॉल्व्ड रेफरेंस के बजाय केवल नाम का मिलान हो सकता है। कंपाइलर-ग्रेड एजेस --lsp और rust-analyzer या gopls जैसे लैंग्वेज सर्वर के साथ ऑप्ट-इन हैं।

Graft इंस्टॉल करें और वर्ज़न पिन करें

Graft के लिए Node.js 20 या उससे नया वर्ज़न आवश्यक है और यह MIT लाइसेंस के अंतर्गत आता है। अगस्त 2026 तक, इसका वर्तमान release 0.10.1 है, और पहला प्रकाशित वर्ज़न, 0.1.0, जुलाई 2026 का है। इसे एक नए सॉफ्टवेयर के रूप में देखें।

npm install -g @nanonets/graft@0.10.1
npm ls -g @nanonets/graft

npm ls -g को @nanonets/graft@0.10.1 प्रिंट करना चाहिए। उस वर्ज़न को जानबूझकर पिन करें। एक साधारण npm install -g @nanonets/graft कमांड उसे चलाने के समय latest टैग को रिज़ॉल्व करता है, और एक ऐसे प्रोजेक्ट पर जो महीने में कई minor releases जारी करता है, यह आपको मंगलवार को वह टूल देगा जो आपके सहकर्मी ने सोमवार को इंस्टॉल किए गए टूल से अलग हो सकता है। एक पिन किया गया वर्ज़न सभी के लिए CLI flags और graph format को समान रखता है, इसलिए आप तब अपग्रेड करते हैं जब आप स्वयं निर्णय लेते हैं।

फिर इसे अपने स्वामित्व वाले रिपॉजिटरी से जोड़ें:

cd /path/to/your/repo
graft init --dry-run
graft init

graft init पूछता है कि आपके किन कोडिंग एजेंट्स को जोड़ना है, और फिर ग्राफ बनाता है। पहले --dry-run चलाएं और उन फाइलों की सूची पढ़ें जिन्हें यह बदलने की योजना बना रहा है, क्योंकि उनमें से कुछ रिपॉजिटरी के बाहर स्थित होती हैं। graft init एक idempotent कमांड है और मौजूदा कॉन्फ़िगरेशन को ओवरराइट नहीं करता है, इसलिए इसे दूसरी बार चलाना सुरक्षित है।

अगस्त 2026 तक, यह वायरिंग Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf और AdaL को कवर करती है। Claude Code को सबसे गहरा इंटीग्रेशन मिलता है: एक MCP server एंट्री, ग्राफ का आकार और उसकी स्थिति दिखाने वाली एक statusline, post-edit हुक्स जो ग्राफ को फिर से बनाते हैं, और .claude/ के अंतर्गत एक स्किल फाइल। बाकी को एक इंस्ट्रक्शन या रूल फाइल मिलती है जो एजेंट को बताती है कि ये टूल्स मौजूद हैं। इसलिए "Supported" का अर्थ है कि Graft वायरिंग लिखता है, अतः यदि कोई एजेंट अपनी स्वयं की रूल्स फाइल को अनदेखा करता है, तो वह मैप को भी अनदेखा कर देगा। यही वह सामान्य कारण है कि एजेंट आपके द्वारा लिखे गए निर्देशों को अनदेखा क्यों करते हैं, और यह यहाँ भी उतना ही लागू होता है जितना कहीं और।

आपके रिपॉजिटरी में क्या आता है, और क्या git से बाहर रहता है

graft init के बाद, इनकी अपेक्षा करें:

• graft/: मार्कडाउन नोड ग्राफ और graft/.graph/wiring.json। आपके लिए .gitignore में जोड़ा गया।
• .mcp.json: graft MCP सर्वर को रजिस्टर करता है ताकि Claude Code इसे शुरू कर सके।
• .claude/settings.json: यथास्थान मर्ज किया गया, जो statusline और post-edit हुक को जोड़ता है।
• AGENTS.md, GEMINI.md, .github/copilot-instructions.md, .cursor/rules/graft.mdc, .kiro/steering/graft.md, .windsurf/rules/graft.md और .adal/skills/graft/SKILL.md: आपके द्वारा चुने गए एजेंटों से मेल खाने वाली फाइलों में मार्कर-फेंस्ड सेक्शन जोड़े गए।
• ~/.codex/config.toml, ~/.codex/hooks.json और ~/.codex/hooks/graft/graft-hooks.cjs: मशीन-व्यापी, केवल तब लिखे जाते हैं जब आप Codex चुनते हैं। graft init --no-global इन्हें छोड़ देता है, और graft init --no-hooks हुक शिम को अलग से छोड़ देता है।

ग्राफ एक कैश है, जैसे node_modules। इसे कमिट न करें। यह कुछ ही सेकंड में कोड से फिर से बन जाता है, यह लगभग हर बदलाव पर बदलता है, और इसे कमिट करने से एक लाइन का फिक्स कई सौ फाइलों के डिफ (diff) में बदल जाता है जिसे कोई भी समीक्षक नहीं पढ़ेगा। इसके बजाय वायरिंग को कमिट करें, जिनमें AGENTS.md और .mcp.json शामिल हैं। एक टीम का सदस्य रिपॉजिटरी को क्लोन करता है, graft build चलाता है, और अपना स्थानीय ग्राफ प्राप्त कर लेता है।

जांचें कि आपके पहले कमिट से पहले इग्नोर नियम लागू हो गया है:

grep -n graft .gitignore
git status --short

grep को graft/ वाली एक लाइन प्रिंट करनी चाहिए, और git status --short को graft/ के अंतर्गत कुछ भी सूचीबद्ध नहीं करना चाहिए। यदि उस आउटपुट में graft/ के अंतर्गत फाइलें दिखाई देती हैं, तो इसका मतलब है कि इग्नोर एंट्री गायब है या कहीं और ओवरराइड हो गई है। कमिट करने से पहले इसे ठीक करें, क्योंकि एक बार फाइल ऐड हो जाने के बाद git उसे ट्रैक करना जारी रखता है, और बाद में .gitignore में किया गया बदलाव उसे अनट्रैक नहीं करेगा।

यदि आप MCP सर्वर को मैन्युअल रूप से रजिस्टर करना चाहते हैं, या इसे उसी वर्जन पर पिन करना चाहते हैं जिसे आपने इंस्टॉल किया है, तो एंट्री छोटी है:

{
  "mcpServers": {
    "graft": {
      "command": "npx",
      "args": ["-y", "@nanonets/graft@0.10.1", "mcp"]
    }
  }
}

वे retrieval tools जिन्हें आपका agent grep के स्थान पर कॉल करता है

Graft MCP के माध्यम से छह tools उपलब्ध कराता है। graft_find_code कार्य विवरण के लिए file और line के साथ ranked nodes लौटाता है। graft_file_api किसी file में बिना body के सभी signatures लौटाता है। graft_trace_calls callers या callees को कई स्तरों तक गहराई से ट्रैक करता है। graft_find_all symbol के आधार पर grouped regex hits लौटाता है। graft_repo_map किसी अपरिचित repository का प्रारंभिक अवलोकन प्रदान करता है। graft_check_freshness यह रिपोर्ट करता है कि क्या graph अभी भी code से मेल खाता है।

प्रत्येक tool का एक CLI संस्करण भी है, जिससे आप यह जाँच सकते हैं कि आपके agent को वास्तव में क्या दिया जा रहा है:

graft map .
graft ask "where do we validate the refresh token"
graft skeleton src/auth/session.ts
graft callers validateRefreshToken
graft callers validateRefreshToken --direction out
graft grep "refresh_token" --json

graft ask को file contents के बजाय file:line references के साथ ranked nodes प्रिंट करने चाहिए। यही पूरी कार्यप्रणाली है: agent को एक pointer मिलता है और वह सही file खोजने के लिए दस files पढ़ने के बजाय केवल एक file खोलता है। यदि आप स्वयं graph देखना चाहते हैं, तो graft viz localhost पर एक interactive viewer खोलता है। यदि graft ask किसी ऐसे प्रश्न के लिए कुछ भी उपयोगी नहीं लौटाता है जिसका उत्तर आप तीस सेकंड में दे सकते हैं, तो इसका अर्थ है कि graph पुराना (stale) है या आपकी language broad tier में है, और यह map आपके agent की भी सहायता नहीं करेगा।

एक लागत ऐसी है जिसे नजरअंदाज करना आसान है। पूरे session के दौरान प्रत्येक request के system prompt में छह tool definitions इंजेक्ट की जाती हैं। आप यह लागत तब भी चुकाते हैं चाहे agent map का उपयोग करे या न करे। ऐसी repository जो context में समाने के लिए पर्याप्त छोटी हो, वहां यह निश्चित शुल्क उस बचत से अधिक हो सकता है जो exploration से प्राप्त होती है।

कोड बदलने पर ग्राफ का क्या होता है

Structural refresh सस्ता और स्वचालित है। Graft git के बजाय आपकी working tree को पढ़ता है, इसलिए आपके द्वारा किया गया ऐसा बदलाव जिसे आपने commit नहीं किया है और जिसे आपने stage किया है, दोनों ही इसके लिए समान रूप से दृश्यमान होते हैं। एक query केवल उन्हीं फाइलों को फिर से पार्स (re-parse) करती है जिनका stat बदल गया है, जिसे प्रोजेक्ट के दस्तावेज़ लगभग 3 ms का ओवरहेड बताते हैं, और एक turn-end rebuild केवल उन्हीं फाइलों को छूता है जहाँ कोड स्थानांतरित हुआ है। डिस्क पर मौजूद ग्राफ से बिना फिर से पार्स किए उत्तर पाने के लिए GRAFT_NO_REFRESH=1 सेट करें या --no-refresh पास करें। सब कुछ cold re-parse करने के लिए --no-reuse पास करें, जो कि Graft को अपग्रेड करने के बाद आवश्यक होता है।

मॉडल द्वारा लिखा गया आधा हिस्सा अलग तरह से व्यवहार करता है, और यही वह हिस्सा है जो चुपचाप गलत हो जाता है। Summaries और cruxes को कैश (cache) कर लिया जाता है। प्रत्येक node अपने स्रोतों का एक content hash रिकॉर्ड करता है, इसलिए जब कोई source file बदलती है, तो node को current के रूप में दिखाने के बजाय stale के रूप में चिह्नित किया जाता है। वह फ्लैग केवल तभी मदद करता है यदि कोई उस पर कार्रवाई करे। graft build --deep के साथ रिफ्रेश करें, जो फिर से मॉडल टोकन का उपयोग करता है।

Staleness को दृश्यमान बनाएँ:

graft check .
echo $?

Exit status 0 का अर्थ है कि ग्राफ कोड से मेल खाता है। Exit status 1 का अर्थ है drift। इसे pre-push hook से, या CI में branch पर चलाएँ, ताकि छह महीने पुराना मैप मार्च में फिर से लिखे गए कोड के बारे में आत्मविश्वास से उत्तर न दे सके।

प्रकाशित बेंचमार्क आंकड़ों को ध्यान से पढ़ें

Graft का मुख्य दावा है "4 गुना तक सस्ता और 3 गुना तेज, सटीकता में बेहतर या कोई कमी नहीं"। ये आंकड़े प्रोजेक्ट के अपने बेंचमार्क से लिए गए हैं, जो इसके README में प्रकाशित हैं। यहाँ वे दो रन दिए गए हैं जिन्हें यह पूरी तरह से रिपोर्ट करता है।

[
  {
    "label": "Controlled sweep",
    "run_count": 162,
    "token_saving_pct": 42,
    "tool_call_saving_pct": 46,
    "correctness_pct": 93,
    "baseline_correctness_pct": 93
  },
  {
    "label": "SWE-bench Verified",
    "run_count": 50,
    "token_saving_pct": 23,
    "tool_call_saving_pct": 25,
    "correctness_pct": 66,
    "baseline_correctness_pct": 54
  }
]

नियंत्रित स्वीप (controlled sweep) में 162 रन शामिल हैं जो दो रिपॉजिटरी पर किए गए हैं, जिनमें से एक स्वयं Graft है, और प्रत्येक कार्य के लिए तीन ट्रायल किए गए हैं। यह 42% कम टोकन और 46% कम टूल कॉल की रिपोर्ट करता है। SWE-bench Verified रन में 50 इंस्टेंस शामिल हैं, जिसमें दोनों तरफ एक ही मॉडल का उपयोग किया गया है, और यह कम बचत की रिपोर्ट करता है: 23% टोकन और 25% टूल कॉल। एक तीसरे रन में 11.02 अमेरिकी डॉलर की लागत पर पांच मर्ज किए गए PocketBase पुल रिक्वेस्ट को पुन: प्रस्तुत किया गया, जबकि बेसलाइन के लिए यह लागत 13.91 डॉलर थी।

इन सभी को वेंडर बेंचमार्क के रूप में देखें। दो चीजें इसकी उपयोगिता को सीमित करती हैं। नियंत्रित स्वीप में Graft की अपनी रिपॉजिटरी शामिल है, जो वह कोडबेस है जिसके आधार पर इसके लेखकों ने इसे ट्यून किया है। SWE-bench Verified प्रसिद्ध ओपन-सोर्स Python प्रोजेक्ट्स की समस्याओं का एक सार्वजनिक डेटासेट है, और सार्वजनिक डेटासेट वे होते हैं जिनके लिए टूल्स को अनुकूलित (optimize) किया जाता है, चाहे किसी का इरादा ऐसा हो या न हो। इनमें से कोई भी आपके निजी monorepo के बारे में कोई दावा नहीं है, जिसकी अपनी नामकरण आदतें और अपना डेड कोड होता है।

सटीकता (correctness) पर दोबारा गौर करना आवश्यक है। नियंत्रित स्वीप पर इसमें कोई बदलाव नहीं हुआ: map के साथ 93% बनाम बिना map के 93%। 66% तक की उछाल केवल SWE-bench Verified पर दिखाई देती है, जहाँ बेसलाइन 54% थी। एक टूल जो आपके टोकन बिल को कम करता है और गुणवत्ता को स्थिर रखता है, वह अभी भी एक अच्छा सौदा है। बस SWE-bench के सटीकता परिणाम को स्वीप के टोकन परिणाम के साथ न जोड़ें और दोनों को एक ही दावे के रूप में उद्धृत न करें।

किसी भी दावे पर विश्वास करने से पहले अपने स्वयं के टोकन डेल्टा (token delta) को मापें

केवल वही संख्या मायने रखती है जो आपके रिपॉजिटरी से आती है। इस विधि में एक दोपहर का समय लगता है।

कोई ऐसा कार्य चुनें जिसे आप बिल्कुल सटीक रूप से दोहरा सकें। एक प्रश्न पूछना संपादन (edit) करने से बेहतर है, क्योंकि संपादन रिपॉजिटरी को बदल देता है और दूसरा रन अब समान प्रयोग नहीं रहता। "लॉगिन रूट पर रेट लिमिट कौन सा मॉड्यूल लागू करता है" सही प्रकार का प्रश्न है।

टेलीमेट्री चालू करें और इसे अपने टर्मिनल पर भेजें:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console
claude

कंसोल एक्सपोर्टर मीट्रिक रिकॉर्ड्स को वैसे ही प्रिंट करता है जैसे वे एकत्र किए जाते हैं। आपको जिस रिकॉर्ड की आवश्यकता है वह claude_code.token.usage है, जिसमें input, output, cacheRead या cacheCreation का type एट्रिब्यूट होता है। ओरिएंटेशन input और cacheRead में दिखाई देता है, क्योंकि फाइल की सामग्री वहीं पहुँचती है। उन दोनों को जोड़ें।

कार्य को तीन बार चलाएं, प्रत्येक बार एक नए सत्र (session) में, मैप को कनेक्ट करके। फिर .mcp.json से ग्राफ्ट एंट्री को हटा दें और इसे तीन बार और चलाएं। एकल रन के बजाय मेडियन (medians) की तुलना करें, क्योंकि एजेंट रन काफी भिन्न होते हैं और एक खराब रन आपको सच्चाई के विपरीत परिणाम दे सकता है। टूल-कॉल की संख्या भी रिकॉर्ड करें: टूल कॉल एक तंत्र (mechanism) है और टोकन उसका प्रभाव है, इसलिए टूल कॉल में बिना किसी कमी के टोकन की बचत का मतलब है कि कुछ और बदल गया है।

फिर उन लागतों को घटाएं जिन्हें बेंचमार्क नहीं दिखाता है। graft build --deep हर पूर्ण रिफ्रेश पर मॉडल टोकन खर्च करता है। छह टूल स्कीमा हर अनुरोध के साथ चलते हैं। यदि आपके एजेंट आपके द्वारा किराए पर लिए गए सर्वर पर चलते हैं, तो एजेंट खर्च पर एक कठोर सीमा निर्धारित करना इसे एक आश्चर्य से बदलकर एक बजट बना देता है, और कोडिंग एजेंट की टेलीमेट्री वास्तव में क्या रिपोर्ट करती है इस बात को कवर करता है कि एक्सपोर्टर को सक्षम करने के बाद मशीन से क्या बाहर जाता है।

Codebase map कब मदद करना बंद कर देता है?

• रिपॉजिटरी पहले से ही कॉन्टेक्स्ट में फिट बैठती है। एक छोटी सर्विस के लिए मैप की आवश्यकता नहीं होती है, और आप अभी भी हर रिक्वेस्ट पर छह टूल स्कीमा के लिए भुगतान कर रहे होते हैं। यदि आपका एजेंट आज एक या दो टूल कॉल में कोई भी फाइल ढूंढ लेता है, तो इसे छोड़ दें।
• आपकी भाषा ब्रॉड टियर में है। जेनेरिक कॉल एजेस का मतलब है कि graft callers किसी कॉलर को मिस कर सकता है, या नाम के टकराव (name collision) से एक गलत कॉल उत्पन्न कर सकता है। ब्लास्ट रेडियस पर भरोसा करने से पहले graft grep के साथ पुष्टि करें।
• ग्राफ पुराना हो गया है और किसी ने ध्यान नहीं दिया। graft check ड्रिफ्ट होने पर 1 के साथ एग्जिट होता है, जो केवल तभी उपयोगी है जब कोई इसे चलाए। यह एक आदत नहीं, बल्कि एक हुक या CI स्टेप होना चाहिए।
• मोनोरैपो को स्कोपिंग की आवश्यकता है। एक सिंगल-git मोनोरैपो को वर्कस्पेस फाइल, go.mod, pyproject.toml या Cargo.toml द्वारा ऑटो-स्प्लिट किया जाता है, और graft ask "..." --in services/billing/ क्वेरी को एक सब-प्रोजेक्ट तक सीमित कर देता है। वही प्रवृत्ति जो प्रति पैकेज नेस्टेड AGENTS.md फाइलों की ओर ले जाती है, मैप पर भी लागू होती है।
• एजेंट वायरिंग को अनदेखा करता है। यह निष्कर्ष निकालने से पहले कि मैप का उपयोग किया जा रहा है, एक वास्तविक सेशन में टूल कॉल्स को देखें। यदि कोई एजेंट अभी भी grep चला रहा है, तो वह आपको बता रहा है कि उसने कभी रूल्स फाइल नहीं पढ़ी।

FAQ

क्या मुझे graft/ फ़ोल्डर को git में commit करना चाहिए?

नहीं। graft build स्वचालित रूप से आपके .gitignore में graft/ जोड़ देता है, क्योंकि यह ग्राफ node_modules की तरह एक पुन: उत्पन्न करने योग्य (regenerable) कैश है। यह लगभग हर संपादन पर बदलता है, इसलिए इसे commit करने से वास्तविक diffs सैकड़ों जनरेट की गई फ़ाइलों के नीचे दब जाते हैं। उस वायरिंग को commit करें जो agents को बताती है कि मैप मौजूद है, जिसमें AGENTS.md और .mcp.json शामिल हैं, और प्रत्येक टीम के सदस्य को स्थानीय रूप से graft build चलाने दें। अपने पहले commit से पहले grep -n graft .gitignore और git status --short के साथ सत्यापित करें, क्योंकि एक बार फ़ाइल जुड़ जाने के बाद git उसे ट्रैक करना जारी रखता है, और बाद में .gitignore को संपादित करने से वह untrack नहीं होती है।

क्या Graft को चलाने में पैसे खर्च होते हैं?

संरचनात्मक (structural) भाग के लिए नहीं। graft build, graft ask, graft check और छह MCP रिट्रीवल टूल्स tree-sitter ऑपरेशन्स हैं जो कभी भी मॉडल को कॉल नहीं करते हैं। graft build --deep भुगतान वाला भाग है: यह LLM के माध्यम से सादे अंग्रेजी सारांश और प्रति-प्रतीक (per-symbol) क्रक्स लिखता है, जिसे GRAFT_PROVIDER, GRAFT_API_KEY और GRAFT_MODEL के साथ कॉन्फ़िगर किया जाता है, साथ ही किसी भी OpenAI-संगत एंडपॉइंट के लिए GRAFT_BASE_URL का उपयोग किया जाता है। आप केवल संरचना के साथ Graft चला सकते हैं और ग्राफ पर कभी भी कोई टोकन खर्च नहीं करना पड़ेगा।

कोडबेस मैप वास्तव में मेरी रिपॉजिटरी पर कितनी बचत करेगा?

मापे बिना कोई भी आपको यह नहीं बता सकता। प्रोजेक्ट अपनी स्वयं की 162-रन स्वीप पर 42% कम टोकन और SWE-bench Verified पर 23% कम टोकन की रिपोर्ट करता है, दोनों ही बिना मैप वाले बेसलाइन के मुकाबले हैं। ये दोनों वेंडर बेंचमार्क हैं, जिनमें से एक आंशिक रूप से Graft की अपनी रिपॉजिटरी पर चलाया गया है, और कोई भी आपके निजी कोड का वर्णन नहीं करता है। CLAUDE_CODE_ENABLE_TELEMETRY=1 और OTEL_METRICS_EXPORTER=console सेट करके एक दोहराने योग्य प्रश्न को तीन बार मैप के साथ और तीन बार बिना मैप के चलाएं, फिर input और cacheRead प्रकारों के लिए claude_code.token.usage के माध्य (median) की तुलना करें।

रिफैक्टरिंग करने पर ग्राफ का क्या होता है?

संरचना स्वयं को फिर से पार्स (re-parse) करती है। Graft वर्किंग ट्री की स्थिति की जांच करता है और केवल उन फ़ाइलों को फिर से पार्स करता है जो बदली हैं, इसलिए एक नाम परिवर्तन को अगली क्वेरी पर लगभग 3 ms के ओवरहेड पर पकड़ लिया जाता है, और यह बिना commit किए गए काम को भी देख लेता है क्योंकि यह git इतिहास के बजाय फ़ाइलों को पढ़ता है। मॉडल द्वारा लिखे गए सारांश पुराने हो जाते हैं: प्रत्येक नोड अपने स्रोतों का एक कंटेंट हैश संग्रहीत करता है, और एक बदला हुआ स्रोत नोड को फिर से लिखने के बजाय उसे पुराना (stale) चिह्नित कर देता है। ड्रिफ्ट देखने के लिए graft check . चलाएं, फिर लिखित भाग को रिफ्रेश करने के लिए graft build --deep चलाएं।

आज कौन से कोडिंग एजेंट्स Graft का उपयोग कर सकते हैं?

अगस्त 2026 तक graft init Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf और AdaL को जोड़ता है। Claude Code को सबसे अधिक मिलता है: .mcp.json में एक MCP सर्वर एंट्री, एक स्टेटसलाइन, पोस्ट-एडिट हुक और .claude/ के अंतर्गत एक स्किल फ़ाइल। Codex को एक AGENTS.md सेक्शन के साथ-साथ ~/.codex/ के अंतर्गत मशीन-व्यापी एंट्री मिलती है, जिसे graft init --no-global छोड़ देता है। अन्य को एक रूल्स या स्टीयरिंग फ़ाइल प्राप्त होती है। कोई भी अन्य MCP क्लाइंट npx -y @nanonets/graft@0.10.1 mcp कमांड को रजिस्टर करके सीधे सर्वर का उपयोग कर सकता है।