Graft: coding agents साठी codebase map
Graft tree-sitter वापरून repository चा codebase map तयार करते आणि MCP द्वारे तो coding agent ला उपलब्ध करून देते, त्यामुळे प्रत्येक session मध्ये रचना पुन्हा शोधावी लागत नाही.
कोडिंग एजंटसाठी codebase map म्हणजे काय
कोडिंग एजंटसाठी codebase map हा तुमच्या repository चा कायमस्वरूपी index असतो. प्रत्येक नवीन session मध्ये सुरुवातीपासून grep करण्याऐवजी एजंट या index मधून आवश्यक माहिती शोधतो. Graft हे या संकल्पनेचे एक implementation आहे. ते tree-sitter वापरून तुमचा code parse करते, परस्पर जोडलेल्या markdown nodes चे folder आणि प्रत्येक symbol साठी wiring graph तयार करते. तसेच MCP (model context protocol, coding agents बाहेरील tools कॉल करण्यासाठी वापरत असलेला standard interface) द्वारे retrieval tools उपलब्ध करून देते.
Graft हा proxy नाही आणि gateway देखील नाही. तुमचा agent आणि model API यांच्या मध्ये कोणताही घटक बसत नाही. Map हा disk वरील एक folder असतो, जो agent वाचतो. या फरकामुळे तुम्ही कोणती समस्या सोडवत आहात हे ठरते: self-hosted token gateway तुम्ही आधीच पाठवत असलेल्या requests चे मोजमाप आणि routing करते, तर map मुळे एकूण किती requests पाठवाव्या लागतात ते बदलते.
ही technique या tool पेक्षा जुनी आहे आणि या tool नंतरही वापरली जाईल. आधी technique समजून घ्या. त्यानंतर mechanics समजून घ्या.
कोडिंग एजंट रचना पुन्हा शोधण्यात context का खर्च करतात
एखादा एजंट त्याने यापूर्वी पन्नास वेळा पाहिलेल्या repository वर काम सुरू करताना पहा. तो directories ची यादी तयार करतो. एखाद्या symbol साठी grep करतो. function कुठे define केले आहे हे शोधण्यासाठी तीन files उघडतो आणि ते कोण call करते हे पाहण्यासाठी चौथी file उघडतो. यापैकी काहीही प्रत्यक्ष task नसते. ही orientation प्रक्रिया असते आणि प्रत्येक session मध्ये तिच्यासाठी input tokens खर्च होतात.
कारण सोपे आहे. एका session मधून दुसऱ्या session मध्ये model कडे memory नसते. तुमच्या layout बद्दल एजंटने शिकलेली सर्व माहिती session संपल्यावर discard झालेल्या context window मध्येच असते. त्यामुळे प्रत्येक वेळी तीच discovery पुन्हा शून्यापासून सुरू होते आणि त्यासाठी पुन्हा खर्च होतो. Prompt caching मध्ये फक्त मागील पाच मिनिटांत दिसलेल्या identical prompt prefix वर discount मिळतो; अतिरिक्त खर्च केल्यास ही मर्यादा मागील एका तासापर्यंत वाढते. त्यामुळे कालची exploration आजच्या session मध्ये वापरता येत नाही. मोठ्या repository मध्ये orientation phase चा खर्च edit पेक्षा जास्त असतो: code शोधण्यासाठी दहा tool calls आणि तो बदलण्यासाठी एक. त्या खर्चात orientation हा एक भाग आणि edit हा दुसरा भाग असतो. म्हणून एजंटला कार्य करणाऱ्या सर्वात लहान बदलापुरते मर्यादित ठेवणारे skill map सोबत वापरणे अधिक उपयुक्त ठरते; त्यांपैकी एक निवडण्याची गरज नसते.
Map discovery ची प्रक्रिया model कडून काढून disk वर हलवते आणि हे चक्र थांबवते. Parser repository मध्ये एकदा फिरतो, कोणता symbol कुठे define केला आहे आणि कोणता symbol कोणाला call करतो याची नोंद करतो, आणि code बदलल्यावर ती नोंद अद्ययावत ठेवतो. एजंट एक प्रश्न विचारतो आणि file व line सह उत्तर मिळवतो. वारंवार होणारी exploration स्वस्त lookup मध्ये बदलते.
तुम्ही याची कमकुवत आवृत्ती आधीपासून वापरत आहात. तुमच्या conventions सांगणारी AGENTS.md एजंटला प्रत्येक वेळी त्या conventions पुन्हा शोधण्यापासून थांबवते. Generated map त्याला तुमची structure पुन्हा शोधण्यापासून थांबवतो. फरक एवढाच आहे की ते कोण लिहिते. Instruction file तुम्ही स्वतः लिहिता, त्यामुळे ती लहान राहते. Parser map generate करतो, त्यामुळे ती दहा हजार files व्यापू शकते. एका session मध्ये budget नेमका कुठे खर्च होतो यासाठी Claude Code आपली context window कशी वापरते हे accounting स्पष्ट करते.
Graft प्रत्यक्षात काय तयार करते
Repository root मधील एका graft/ folder अंतर्गत दोन artefacts तयार होतात.
पहिला artefact linked markdown म्हणून लिहिलेला node graph आहे. प्रत्येक node साठी एक file असते. प्रत्येक node मध्ये साध्या इंग्रजीतील सारांश, source मधून घेतलेल्या महत्त्वाच्या logic lines चा "crux", content hash सह exact source files, इतर nodes कडे निर्देश करणारे typed wikilinks (depends_on, part_of, uses, implements) आणि regeneration नंतरही टिकणारा notes section असतो. Parser ला अनुमान करता न येणारा context तुम्ही त्यात नोंदवू शकता.
दुसरा artefact graft/.graph/wiring.json आहे. हा tree-sitter ने extract केलेला per-symbol structural graph आहे. त्यामध्ये definitions, references आणि त्यांच्यामधील call edges असतात.
हा विभाजन महत्त्वाचा आहे, कारण या दोन भागांपैकी फक्त एका भागाला model ची आवश्यकता असते. graft build पूर्णपणे tree-sitter वर आधारित आहे आणि LLM (large language model) ला कधीही call करत नाही. त्यामुळे ते deterministic आहे आणि त्यासाठी कोणताही खर्च होत नाही. graft build --deep मध्ये लिहिलेले summaries आणि per-symbol cruxes जोडले जातात. त्यासाठी model calls होतात आणि त्यांचा खर्च तुम्हाला द्यावा लागतो.
Language support चे tiers आहेत. हा tier call graph वर किती विश्वास ठेवता येईल हे सांगतो. TypeScript, JavaScript, Python, Go, Java, Kotlin, PHP, Swift आणि R साठी scope-aware cross-file resolution मिळते. Rust, C, C++, C#, Ruby, Scala, Elixir, Solidity, OCaml, Zig, Dart, Clojure, Nix आणि Lua साठी symbols तसेच generic call edges मिळतात. त्यामुळे एखादा edge resolved reference ऐवजी name match असू शकतो. Compiler-grade edges साठी --lsp आणि rust-analyzer किंवा gopls सारखा language server opt-in पद्धतीने वापरता येतो.
Graft इन्स्टॉल करा आणि आवृत्ती pin करा
Graft साठी Node.js 20 किंवा त्यानंतरची आवृत्ती आवश्यक आहे आणि त्याचा परवाना MIT आहे. 17 October 2026 रोजीची सध्याची release 0.23.0 आहे. ती 15 October 2026 रोजी प्रकाशित झाली. पहिली प्रकाशित आवृत्ती 0.1.0 असून ती July 2026 मधील आहे. त्यामुळे हे नवीन आणि अजून विकसित होत असलेले software समजा. 14 October 2026 रोजी प्रकाशित झालेल्या 0.22.0 release मध्ये प्रकल्पाचे नाव Trail-code असे बदलले. आता तोच code @trailhq/trail-code म्हणूनही उपलब्ध आहे आणि त्यात trail command आहे. मात्र @nanonets/graft मध्ये graft command कायम आहे.
या मार्गदर्शकात 0.21.1 pin केली आहे. ती 29 September 2026 रोजी प्रकाशित झाली आणि नाव बदलण्यापूर्वीची शेवटची release आहे. 0.22 आणि 0.23 मध्ये या मार्गदर्शकाला आवश्यक असलेल्या commands बदलल्या. 0.22 पासून graft check तुमच्या branch मधील diff ची repo मधील team learnings शी तुलना करते आणि conflict आढळल्यास 1 ने exit होते. Drift detection graft build --check कडे हलवण्यात आले. MCP tools ची नावे trail_* आहेत. Server मात्र जुन्या graft_* नावांना अद्याप उत्तर देतो. 0.23.0 च्या changelog नुसार trail ने तयार केलेल्या repo मध्ये map .trail/cache/ कडे हलतो आणि Claude Code ला MCP server मिळत नाही. मात्र README मध्ये अजूनही graft/ आणि .mcp.json यांचे वर्णन आहे. Pin बदलण्यापूर्वी changelog वाचा आणि --dry-run चालवा.
npm install -g @nanonets/graft@0.21.1
npm ls -g @nanonets/graftnpm ls -g ने @nanonets/graft@0.21.1 दाखवले पाहिजे. ही आवृत्ती जाणीवपूर्वक pin करा. साधा npm install -g @nanonets/graft command तुम्ही तो चालवता त्या क्षणी latest tag resolve करतो. महिन्यात अनेक minor releases प्रकाशित होत असलेल्या project मध्ये यामुळे मंगळवारी तुम्हाला मिळणारे tool सोमवारी तुमच्या सहकाऱ्याने इन्स्टॉल केलेल्या tool पेक्षा वेगळे असू शकते. Pin केलेली आवृत्ती सर्वांसाठी CLI flags आणि graph format समान ठेवते. त्यामुळे upgrade कधी करायचे हे तुम्ही ठरवू शकता.
त्यानंतर तुमच्या मालकीच्या repository मध्ये ते जोडा:
cd /path/to/your/repo
graft init --dry-run
graft initgraft init कोणते coding agents जोडायचे ते विचारते आणि त्यानंतर graph तयार करते. आधी --dry-run चालवा आणि कोणत्या files मध्ये बदल करायचा त्याची यादी वाचा. यापैकी काही files repository च्या बाहेर असू शकतात. graft init idempotent आहे आणि आधीपासून असलेल्या configs overwrite करत नाही. त्यामुळे ते दुसऱ्यांदा चालवणे सुरक्षित आहे. बदल मागे घेण्यासाठी graft uninstall Graft ने लिहिलेली प्रत्येक file आणि config entry काढते. -y pass करेपर्यंत ते dry run असते.
याच prompt मध्ये telemetry checkbox असतो. 0.12.0 release पासून Graft default ने anonymous usage ping पाठवते. यात bucketed counts आणि fixed labels असतात; तुमचा code, file paths किंवा repository name कधीही पाठवले जात नाही. Events दिवसातून जास्तीत जास्त एकदा post केले जातात. एक अपवाद आहे: install event. npm चा postinstall hook तो background sender कडे लगेच देतो. graft init दरम्यान checkbox untick करा, graft telemetry disable चालवा किंवा ते बंद करण्यासाठी DO_NOT_TRACK=1 सेट करा. CI मध्ये ते आपोआपही बंद होते. graft telemetry debug पाठविल्याशिवाय पाठवला जाणारा batch दाखवते.
0.21.1 मध्ये wiring Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent आणि Google Antigravity यांना लागू होते. 0.13.0 release पासून Hermes Agent हा first-class graft init host आहे. Pinned आवृत्तीत graft init --agents hermes आणि graft init --agents antigravity इतर कोणत्याही host प्रमाणे या दोघांची निवड करतात. Grok 0.13.0 release मध्ये जोडले गेले आणि त्याची निवड graft init --agents grok ने केली जाते. Claude Code ला सर्वात सखोल integration मिळते: MCP server entry, graph size आणि staleness दाखवणारी statusline, graph पुन्हा तयार करणारे post-edit hooks आणि .claude/ अंतर्गत skill file. इतर agents ना tools उपलब्ध असल्याचे सांगणारी instruction किंवा rule file मिळते. Hermes Agent आणि Antigravity दोन्ही AGENTS.md section वाचतात. Grok ला त्याच्या स्वतंत्र config मध्ये MCP block देखील मिळतो. त्यामुळे "Supported" याचा अर्थ Graft wiring लिहिते असा आहे. एखादा agent स्वतःची rules file वाचत नसेल, तर तो map देखील वापरणार नाही. तुम्ही त्यांच्यासाठी लिहिलेल्या सूचनांकडे agents दुर्लक्ष करतात याचे हे नेहमीचे कारण आहे आणि येथेही तेच लागू होते.
तुमच्या repository मध्ये काय येते आणि git मधून काय वगळले जाते
graft init नंतर पुढील गोष्टी अपेक्षित आहेत:
graft/: markdown node graph आणिgraft/.graph/wiring.json. ते तुमच्यासाठी.gitignoreमध्ये जोडले जाते..mcp.json: graft MCP server नोंदवतो, त्यामुळे Claude Code ते सुरू करते..claude/settings.json: विद्यमान ठिकाणी merge केले जाते आणि statusline तसेच post-edit hooks जोडले जातात.AGENTS.md,GEMINI.md,.github/copilot-instructions.md,.cursor/rules/graft.mdc,.kiro/steering/graft.md,.windsurf/rules/graft.md,.grok/skills/graft/SKILL.mdआणि.adal/skills/graft/SKILL.md: तुम्ही निवडलेल्या agents शी जुळणाऱ्या फाइल्समध्ये marker-fenced sections जोडले जातात..grok/config.toml: repository-स्तरीय[mcp_servers.graft]block. तो फक्त Grok निवडल्यावर लिहिला जातो.~/.codex/config.toml,~/.codex/hooks.jsonआणि~/.codex/hooks/graft/graft-hooks.cjs: machine-wide नोंदी. त्या फक्त Codex निवडल्यावर आणि~/.codex/आधीपासून अस्तित्वात असल्यावर लिहिल्या जातात.graft init --no-globalत्या वगळते आणिgraft init --no-hookshook shim स्वतंत्रपणे वगळते.
Graph हा node_modules प्रमाणे cache आहे. तो commit करू नका. तो code मधून काही सेकंदांत पुन्हा तयार होतो, जवळजवळ प्रत्येक edit नंतर बदलतो आणि तो commit केल्यास एका ओळीच्या दुरुस्तीचे रूपांतर शेकडो फाइल्सच्या diff मध्ये होते, जे कोणताही reviewer वाचणार नाही. त्याऐवजी wiring commit करा. त्यात AGENTS.md आणि .mcp.json यांचा समावेश आहे. Teammate repository clone करतो, graft build चालवतो आणि स्वतःचा local graph मिळवतो.
पहिला commit करण्यापूर्वी ignore rule लागू झाली आहे का ते तपासा:
grep -n graft .gitignore
git status --shortgrep ने graft/ असलेली एक ओळ दाखवली पाहिजे आणि git status --short ने graft/ अंतर्गत काहीही सूचीबद्ध करू नये. या output मध्ये graft/ अंतर्गत फाइल्स दिसत असल्यास ignore entry गहाळ आहे किंवा इतरत्र override झाली आहे. Commit करण्यापूर्वी ते दुरुस्त करा, कारण एखादी फाइल एकदा add केल्यानंतर git तिचे tracking सुरू ठेवते आणि नंतरचे .gitignore edit तिचे tracking थांबवणार नाही.
MCP server हाताने नोंदवायचा असल्यास किंवा तो तुम्ही install केलेल्या त्याच version वर pin करायचा असल्यास, entry लहान आहे:
{
"mcpServers": {
"graft": {
"command": "npx",
"args": ["-y", "@nanonets/graft@0.21.1", "mcp"]
}
}
}grep ऐवजी तुमचा agent ज्या retrieval tools ला कॉल करतो
Graft MCP द्वारे सहा tools उपलब्ध करून देते. graft_find_code task description साठी ranked nodes परत करते आणि त्यात file व line दिलेले असतात. graft_file_api body शिवाय एखाद्या file मधील प्रत्येक signature परत करते. graft_trace_calls callers किंवा callees चा अनेक स्तरांपर्यंत मागोवा घेते. graft_find_all regex hits ना symbol नुसार गटबद्ध करून परत करते. graft_repo_map अपरिचित repository ची प्राथमिक माहिती देते. graft_check_freshness graph अजून code शी जुळतो का ते कळवते.
प्रत्येक tool ची CLI twin देखील आहे. त्यामुळे तुमच्या 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" --jsongraft ask ने file contents ऐवजी file:line references असलेले ranked nodes दाखवले पाहिजेत. हीच संपूर्ण यंत्रणा आहे: योग्य file शोधण्यासाठी दहा files वाचण्याऐवजी agent ला एक pointer मिळतो आणि तो एक file उघडतो. स्वतः graph पाहायचा असल्यास graft viz localhost वर interactive viewer उघडते. तीस सेकंदांत उत्तर देता आले असते अशा प्रश्नासाठी graft ask कडून काहीही उपयुक्त मिळाले नाही, तर प्रश्नाची मांडणी बदलून पुन्हा विचारू नका. Ranked retrieval मध्ये काही नोंदी सुटू शकतात. प्रकल्पाच्या skill file नुसार hits कमकुवत असतील, तर graft grep, graft skeleton किंवा graft callers कडे वळावे. त्यातूनही पुरेशी माहिती मिळाली नाही, तर drift तपासा (pinned 0.21.1 साठी graft check . आणि 0.22 पासून graft build --check) आणि तुमची language कोणत्या tier मध्ये येते ते निश्चित करा. Stale graph किंवा broad-tier edges मुळे तुमचा agent त्याच प्रकारे अपयशी ठरू शकतो.
एक खर्च सहज लक्षात येत नाही. संपूर्ण session मधील प्रत्येक request च्या system prompt मध्ये सहा tool definitions समाविष्ट केल्या जातात. Agent ने map वापरला नाही तरी हा खर्च होतो. Context मध्ये मावेल इतकी repository लहान असेल, तर ही fixed charge ती वाचवणाऱ्या exploration पेक्षा जास्त असू शकते.
कोड बदलल्यावर ग्राफचे काय होते
संरचनात्मक refresh स्वस्त आणि स्वयंचलित असतो. Graft, git ऐवजी तुमचा working tree वाचतो. त्यामुळे commit न केलेला edit आणि staged केलेला edit त्याला समानपणे दिसतो. प्रत्येक query आधी working tree ची stats तपासते आणि बदललेल्या files पुन्हा parse करते. 0.21.1 docs नुसार काहीही बदलले नसल्यास ही तपासणी साधारण 3 ms घेते; current README नुसार यासाठी काही tens of milliseconds लागतात आणि प्रकल्पाच्या स्वतःच्या repository वर हा वेळ सुमारे 50 ms आहे. Turn-end rebuild केवळ code बदललेल्या files वर परिणाम करतो. पुन्हा parse न करता disk वरील graph मधून उत्तर देण्यासाठी GRAFT_NO_REFRESH=1 सेट करा किंवा --no-refresh पास करा. सर्वकाही नव्याने parse करण्यासाठी --no-reuse पास करा. Graft स्वतः upgrade केल्यानंतर हेच करणे आवश्यक असते.
Model ने लिहिलेला भाग वेगळ्या पद्धतीने वागतो आणि समस्या शांतपणे निर्माण होण्याची शक्यता याच भागात असते. Summaries आणि cruxes cache केले जातात. प्रत्येक node आपल्या sources चा content hash नोंदवतो. त्यामुळे source file बदलल्यावर node current म्हणून दाखवण्याऐवजी stale म्हणून चिन्हांकित केला जातो. मात्र काहीतरी त्यावर कृती केल्यासच हा flag उपयोगी ठरतो. graft build --deep वापरून refresh करा; यासाठी model tokens पुन्हा खर्च होतात.
Staleness स्पष्टपणे दिसण्यासाठी:
graft check .
echo $?Pinned 0.21.1 मध्ये exit status 0 म्हणजे graph code शी जुळतो आणि exit status 1 म्हणजे drift आहे. 0.22 पासून, team learning शी conflict असल्यास graft check exit status 1 देते. त्याऐवजी drift gate graft build --check आहे. त्यामुळे pin बदलताना command देखील बदला. हे pre-push hook मधून चालवा. त्यामुळे March मध्ये rewrite केलेल्या code बाबत सहा महिन्यांचा जुना map आत्मविश्वासाने उत्तर देऊ शकणार नाही. 0.21.1 README मध्ये graft check चे वर्णन local freshness signal म्हणून केले आहे. Current README मध्ये CI साठी build --check दिले आहे. कोणत्याही परिस्थितीत graft/ हे git-ignored आहे. त्यामुळे job ने graph तयार केला नाही, तर fresh CI checkout graph शिवाय सुरू होते.
प्रकाशित benchmark मधील आकडे काळजीपूर्वक वाचा
0.21.1 README ची सुरुवात "up to 4x cheaper and 3x faster, with better or no loss of correctness" या दाव्याने झाली होती. सध्याच्या README मध्ये ही ओळ नाही. त्याऐवजी त्यात लहान आकडे दिले आहेत: "Across 162 runs of the same agent on the same tasks: 32% lower cost, 42% fewer uncached input tokens, 60% less time, and the same share of correct answers." हे आकडे प्रकल्पाच्या स्वतःच्या benchmark मधून घेतले आहेत आणि README मध्ये प्रकाशित केले आहेत. त्यात नोंदवलेल्या दोन runs येथे पूर्णपणे दिल्या आहेत.
या तक्त्यामागील डेटा
[
{
"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
}
]नियंत्रित sweep मध्ये दोन repositories वरील 162 runs आहेत. त्यापैकी एक Graft स्वतः आहे आणि प्रत्येक task साठी तीन trials आहेत. त्यात uncached input tokens 42% ने आणि tool calls 46% ने कमी झाल्याचे नोंदवले आहे. SWE-bench Verified run मध्ये 50 instances आहेत. दोन्ही बाजूंना तोच model वापरला आहे आणि त्यात कमी बचत नोंदवली आहे: tokens मध्ये 23% आणि tool calls मध्ये 25%. PocketBase tasks वरील तिसऱ्या run मध्ये 15 tasks होते. त्यापैकी दहा developer questions आणि पाच पुनरुत्पादित merged pull requests होते. त्याचा एकूण खर्च 11.02 US dollars होता, तर baseline साठी तो 13.91 होता.
हे सर्व vendor benchmark म्हणूनच पहा. यावरून मिळणाऱ्या निष्कर्षांवर दोन गोष्टी मर्यादा आणतात. नियंत्रित sweep मध्ये Graft चे स्वतःचे repository समाविष्ट आहे. हेच codebase त्याच्या लेखकांनी tuning साठी वापरले आहे. SWE-bench Verified हा सुप्रसिद्ध open-source Python projects मधील issues चा public dataset आहे. कोणाचाही तसा हेतू नसला तरी tools ज्या public datasets साठी optimize केले जातात, ते याच प्रकारचे datasets असतात. यापैकी कोणताही benchmark तुमच्या private monorepo विषयी निष्कर्ष देत नाही. तुमच्या monorepo मध्ये स्वतंत्र naming conventions आणि स्वतःचा dead code असतो.
Correctness कडे पुन्हा लक्ष देणे आवश्यक आहे. नियंत्रित sweep मध्ये त्यात बदल झाला नाही: map सह 93%, तर map शिवाय 93%. 54% वरून 66% पर्यंतची वाढ फक्त SWE-bench Verified मध्ये दिसते. तुमचा token खर्च कमी करून quality स्थिर ठेवणारे tool तरीही चांगला व्यवहार ठरतो. मात्र SWE-bench मधील correctness चा परिणाम sweep मधील token परिणामाला लागू करू नका आणि दोन्हींचा एकच दावा म्हणून उल्लेख करू नका.
तुमच्या स्वतःच्या token delta चे मोजमाप केल्याशिवाय यावर विश्वास ठेवू नका
महत्त्वाचा एकच आकडा आहे: तुमच्या repository मधून मिळणारा आकडा. ही पद्धत पूर्ण करण्यासाठी एका दुपारचा वेळ लागतो.
तुम्ही अगदी त्याच पद्धतीने पुन्हा करू शकता असे काम निवडा. edit पेक्षा प्रश्न चांगला असतो, कारण edit मुळे repository बदलते आणि दुसऱ्यांदा चालवलेला प्रयोग तसाच राहत नाही. "login route वर rate limit कोणता module लागू करतो" हा योग्य प्रकारचा प्रश्न आहे.
telemetry सुरू करा आणि ती तुमच्या स्वतःच्या terminal कडे पाठवा:
export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console
claudeconsole exporter metric records गोळा होताच ते दाखवतो. तुम्हाला claude_code.token.usage हवे आहे. त्यामध्ये type, input, output किंवा cacheRead पैकी एकाचे cacheCreation attribute असते. Orientation input आणि cacheRead मध्ये दिसते, कारण file contents तिथे साठवले जातात. या दोन्हींची बेरीज करा.
map जोडलेले असताना, प्रत्येक वेळी नवीन session वापरून task तीन वेळा चालवा. त्यानंतर .mcp.json मधील graft entry काढून task आणखी तीन वेळा चालवा. एकेका run ऐवजी median ची तुलना करा, कारण agent runs मध्ये मोठा फरक असतो आणि एका अपयशी run मुळे निष्कर्ष सत्याच्या उलट येऊ शकतो. tool-call count देखील नोंदवा. tool calls ही कार्यपद्धती आहे आणि tokens हा परिणाम आहे. त्यामुळे tool calls कमी न होता tokens वाचत असतील, तर दुसऱ्या घटकात बदल झाला आहे.
यानंतर benchmark मध्ये न दिसणारे खर्च वजा करा. graft build --deep प्रत्येक full refresh वर model tokens वापरते. सहा tool schemas प्रत्येक request सोबत पाठवले जातात. तुमचे agents तुम्ही भाड्याने घेतलेल्या server वर चालत असतील, तर agent खर्चावर कमाल मर्यादा घालणे यामुळे हा अनपेक्षित खर्च न राहता budget मध्ये बदलतो. तसेच coding agent ची telemetry प्रत्यक्षात काय नोंदवते हा exporter सुरू केल्यानंतर machine बाहेर काय पाठवले जाते ते स्पष्ट करते.
कोडबेस नकाशा कुठे उपयोगी ठरत नाही?
- रिपॉझिटरी आधीच context मध्ये बसते. एका लहान सेवेला नकाशाची गरज नसते. प्रत्येक request साठी सहा tool schemas ची किंमत तरीही मोजावी लागते. तुमचा agent आज कोणतीही file एक किंवा दोन tool calls मध्ये शोधत असेल, तर नकाशा वापरू नका.
- तुमची भाषा broad tier मध्ये आहे. Generic call edges मुळे
graft callerscaller शोधण्यात चूक करू शकते किंवा name collision मुळे चुकीचा caller तयार करू शकते. Blast radius वर विश्वास ठेवण्यापूर्वीgraft grepने पुष्टी करा. - Graph stale झाला आहे आणि कोणाच्याही लक्षात आले नाही. 0.21.1 मध्ये drift आढळल्यास
graft checkexit 1 करते. 0.22 पासूनgraft build --checkतसे करते. हे तेव्हाच उपयुक्त ठरते जेव्हा काहीतरी ते चालवते. यासाठी सवय नव्हे, तर pre-push hook वापरा. - Monorepo ला scoping आवश्यक आहे. Single-git monorepo विभाजित होत नाही. मात्र
graft build,pnpm-workspace.yamlमधून sub-projects शोधते;package.jsonworkspaces किंवा प्रत्येक package मधीलgo.mod,pyproject.tomlकिंवाCargo.tomlदेखील शोधते आणि त्यांचा ranking scopes म्हणून वापरते.graft ask "..." --in services/billing/query एका sub-project पुरती मर्यादित करते. प्रत्येक package साठी nested AGENTS.md files ठेवण्यामागील तोच विचार नकाशालाही लागू होतो. - Agent wiring कडे दुर्लक्ष करतो. नकाशा वापरला जात आहे असे निष्कर्ष काढण्यापूर्वी प्रत्यक्ष session मधील tool calls पहा. Agent अजूनही
grepचालवत असेल, तर त्याने rules file वाचलेली नाही हे स्पष्ट आहे.
FAQ
graft/ फोल्डर git मध्ये commit करावा का?
नाही. graft build तुमच्या .gitignore मध्ये graft/ आपोआप जोडते, कारण हा graph node_modules प्रमाणे पुन्हा निर्माण करता येणारा cache आहे. तो जवळजवळ प्रत्येक edit वेळी बदलतो. त्यामुळे तो commit केल्यास शेकडो generated files मुळे वास्तविक diff शोधणे कठीण होते. Map उपलब्ध आहे हे agents ला सांगणारे wiring commit करा. त्यात AGENTS.md आणि .mcp.json यांचा समावेश आहे. प्रत्येक teammate ने स्थानिक पातळीवर graft build चालवावे. पहिला commit करण्यापूर्वी grep -n graft .gitignore आणि git status --short वापरून पडताळा करा. एखादी file एकदा add केल्यानंतर git तिचे tracking सुरू ठेवते. त्यानंतर .gitignore संपादित केल्याने tracking बंद होत नाही.
Graft चालवण्यासाठी पैसे लागतात का?
Structural भागासाठी पैसे लागत नाहीत. graft build, graft ask, graft check आणि सहा MCP retrieval tools या tree-sitter operations आहेत. ते कधीही model ला call करत नाहीत. graft build --deep हा सशुल्क भाग आहे. तो LLM द्वारे plain-English summaries आणि प्रत्येक symbol चे cruxes तयार करतो. त्याचे configuration GRAFT_PROVIDER, GRAFT_API_KEY आणि GRAFT_MODEL द्वारे केले जाते. OpenAI-compatible endpoint साठी GRAFT_BASE_URL देखील वापरता येते. तुम्ही Graft फक्त structure सह चालवू शकता. Graph साठी एकही token खर्च करण्याची गरज नाही.
माझ्या repository वर codebase map मुळे किती बचत होईल?
मोजमाप केल्याशिवाय कोणीही सांगू शकत नाही. प्रकल्पाच्या अहवालानुसार, स्वतःच्या 162-run sweep मध्ये uncached input tokens 42% ने कमी झाले. SWE-bench Verified वर tokens 23% ने कमी झाले. दोन्ही निकाल map नसलेल्या baseline शी तुलना करून मिळवले आहेत. हे दोन्ही vendor benchmarks आहेत. त्यापैकी एक benchmark Graft च्या स्वतःच्या repository वर अंशतः चालवला गेला आहे. यापैकी कोणताही benchmark तुमच्या private code चे वर्णन करत नाही. एकच repeatable question map सह तीन वेळा आणि map शिवाय तीन वेळा चालवा. त्यावेळी CLAUDE_CODE_ENABLE_TELEMETRY=1 आणि OTEL_METRICS_EXPORTER=console सेट करा. त्यानंतर claude_code.token.usage च्या median ची तुलना input आणि cacheRead प्रकारांसाठी करा.
Refactor केल्यावर graph चे काय होते?
Structure स्वतः पुन्हा parse होते. Graft working tree चे stats घेते आणि बदललेल्या files पुन्हा parse करते. त्यामुळे rename पुढील query वेळी आढळते. काहीही बदलले नसल्यास, 0.21.1 मध्ये या तपासणीसाठी साधारण 3 ms लागतात. Current release मध्ये काही tens of milliseconds लागतात. ही प्रक्रिया uncommitted work देखील पाहते, कारण ती git history ऐवजी files वाचते. Model ने लिहिलेल्या summaries मात्र stale होतात. प्रत्येक node मध्ये त्याच्या sources चा content hash साठवलेला असतो. Source बदलल्यास node पुन्हा लिहिला जात नाही; त्याऐवजी तो stale म्हणून चिन्हांकित केला जातो. Drift तपासा: 0.21.1 मध्ये graft check . आणि 0.22 पासून graft build --check वापरा. त्यानंतर लिखित भाग refresh करण्यासाठी graft build --deep चालवा.
आज कोणते coding agents Graft वापरू शकतात?
Pinned 0.21.1 मध्ये graft init Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent आणि Google Antigravity यांना wire करते. एकूण अकरा hosts आहेत. Changelog मध्ये 0.13.0 पासून Hermes Agent हा first-class host म्हणून नमूद आहे. Pinned release मध्ये hermes आणि antigravity हे सामान्य --agents ids आहेत. Claude Code ला सर्वाधिक integration मिळते. .mcp.json मध्ये MCP server entry, statusline, post-edit hooks आणि .claude/ अंतर्गत skill file असते. Codex ला AGENTS.md section मिळते. तसेच ~/.codex/ अंतर्गत machine-wide entries मिळतात. graft init --no-global त्या entries वगळते. Grok ला skill file आणि .grok/config.toml मधील MCP block मिळतो. Hermes Agent आणि Antigravity AGENTS.md section वाचतात. इतर agents ना rules किंवा steering file मिळते. इतर कोणताही MCP client command npx -y @nanonets/graft@0.21.1 mcp register करून server थेट वापरू शकतो.