SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-24

Coding agents-க்கு Graft codebase map பயன்படுத்துவது

Graft கருவியைப் பயன்படுத்தி உங்கள் repository-ஐ tree-sitter மூலம் index செய்வது எப்படி என்று அறிக. MCP வழியாக உங்கள் agent-ன் தேடல் திறனை மேம்படுத்தி நேரத்தை மிச்சப்படுத்துங்கள்.

Coding agents-க்கான codebase map என்றால் என்ன

Coding agents-க்கான codebase map என்பது உங்கள் repository-ன் ஒரு நிலையான index ஆகும். ஒவ்வொரு புதிய session-லும் புதிதாக grep செய்வதற்குப் பதிலாக, agent இந்த index-ஐப் பயன்படுத்தி தகவல்களைத் தேடும். Graft என்பது இந்த கருத்தாக்கத்தின் ஒரு செயல்படுத்தல் முறை ஆகும். இது tree-sitter மூலம் உங்கள் code-ஐப் பகுப்பாய்வு செய்து, இணைக்கப்பட்ட markdown nodes கொண்ட ஒரு கோப்புறையையும், ஒவ்வொரு symbol-க்கும் இடையிலான wiring graph-ஐயும் உருவாக்குகிறது. மேலும், MCP (model context protocol - coding agents வெளிப்புறக் கருவிகளை அழைக்கப் பயன்படுத்தும் தரப்படுத்தப்பட்ட interface) மூலம் retrieval கருவிகளை இது வழங்குகிறது.

Graft ஒரு proxy அல்ல, இது ஒரு gateway-வும் அல்ல. உங்கள் agent-க்கும் model API-க்கும் இடையில் எதுவும் செயல்படுவதில்லை. இந்த map என்பது உங்கள் disk-ல் உள்ள ஒரு கோப்புறை மட்டுமே; அதை agent வாசித்துக் கொள்ளும். இந்த வேறுபாடு நீங்கள் எந்தப் பிரச்சினையைத் தீர்க்கிறீர்கள் என்பதைத் தீர்மானிக்கிறது: a self-hosted token gateway நீங்கள் அனுப்பும் கோரிக்கைகளை அளவிடுகிறது மற்றும் வழிநடத்துகிறது, ஆனால் ஒரு map என்பது நீங்கள் எத்தனை கோரிக்கைகளை அனுப்ப வேண்டும் என்பதையே மாற்றியமைக்கிறது.

இந்த நுட்பம் இந்தக் கருவியை விடப் பழமையானது மற்றும் இது நீண்ட காலம் நிலைத்திருக்கும். முதலில் நுட்பத்தைக் கற்றுக்கொள்ளுங்கள், அதன் பிறகு அதன் செயல்பாட்டு முறைகளைத் தெரிந்துகொள்ளுங்கள்.

கோடிங் ஏஜெண்டுகள் ஏன் கட்டமைப்பை மீண்டும் கண்டறியும் முயற்சியில் context-ஐ வீணடிக்கின்றன

ஏற்கனவே ஐம்பது முறை பார்த்த ஒரு repository-ல் ஒரு ஏஜெண்ட் வேலை செய்யத் தொடங்குவதைக் கவனியுங்கள். அது கோப்பகங்களை (directories) பட்டியலிடுகிறது. ஒரு குறியீட்டை (symbol) தேடுகிறது (grep). எந்தக் கோப்பில் அந்தச் செயல்பாடு (function) வரையறுக்கப்பட்டுள்ளது என்பதைக் கண்டறிய மூன்று கோப்புகளைத் திறக்கிறது, பின்னர் அதை யார் அழைக்கிறார்கள் என்பதைக் கண்டறிய நான்காவது கோப்பைத் திறக்கிறது. இதில் எதுவுமே உண்மையான பணி அல்ல. இது ஒரு திசைநோக்குதல் (orientation) மட்டுமே, ஒவ்வொரு அமர்விலும் இதற்காக input tokens செலவிடப்படுகின்றன.

இதற்கான காரணம் எளிதானது. ஒரு model-க்கு அமர்வுகளுக்கு இடையே நினைவாற்றல் கிடையாது. உங்கள் கோப்பு அமைப்பைப் பற்றி அந்த ஏஜெண்ட் கற்றுக்கொண்ட அனைத்தும், அமர்வு முடிந்ததும் நீக்கப்படும் ஒரு context window-ல் மட்டுமே இருந்தன. எனவே, அதே கண்டறியும் பணி மீண்டும் பூஜ்ஜியத்திலிருந்து தொடங்குகிறது, அதற்கான கட்டணத்தை நீங்கள் மீண்டும் செலுத்துகிறீர்கள். Prompt caching என்பது கடைசி ஐந்து நிமிடங்களுக்குள் அல்லது கூடுதல் கட்டணத்தில் கடைசி ஒரு மணி நேரத்திற்குள் காணப்படும் ஒரே மாதிரியான prompt prefix-க்கு மட்டுமே தள்ளுபடி அளிக்கும், எனவே நேற்றைய ஆய்வை இன்றைய அமர்விற்கு அது கொண்டு செல்ல முடியாது. ஒரு பெரிய repository-ல், திருத்தம் செய்வதை விட திசைநோக்குதல் கட்டணம் அதிகமாக இருக்கும்: குறியீட்டைக் கண்டறிய பத்து tool calls, அதை மாற்ற ஒரு tool call. திசைநோக்குதல் என்பது அந்தச் செலவில் பாதி, திருத்தம் என்பது மீதி. இதனால்தான் வேலை செய்யும் மிகச்சிறிய மாற்றத்திற்கு ஏஜெண்டைக் கட்டுப்படுத்தும் திறன் என்பது, ஒரு வரைபடத்துடன் (map) இணைத்துச் செயல்படுவதற்கு மதிப்புடையது.

ஒரு வரைபடம், இந்தச் சுழற்சியை உடைத்து, கண்டறியும் பணியை model-லிருந்து நீக்கி disk-க்கு மாற்றுகிறது. ஒரு parser அந்த repository-ஐ ஒருமுறை ஆய்வு செய்து, எந்தக் குறியீடு எங்கே வரையறுக்கப்பட்டுள்ளது மற்றும் எது எதை அழைக்கிறது என்பதைப் பதிவு செய்கிறது, பின்னர் குறியீடு மாறும்போது அந்தப் பதிவைப் புதுப்பித்த நிலையில் வைத்திருக்கிறது. ஏஜெண்ட் ஒரு கேள்வியைக் கேட்கிறது, அதற்குரிய கோப்பு மற்றும் வரி எண்ணுடன் பதில் கிடைக்கிறது. மீண்டும் மீண்டும் ஆய்வு செய்வது ஒரு மலிவான lookup-ஆக மாறுகிறது.

இதன் ஒரு பலவீனமான பதிப்பை நீங்கள் ஏற்கனவே பயன்படுத்துகிறீர்கள். உங்கள் மரபுகளைக் குறிப்பிடும் ஒரு AGENTS.md கோப்பு, ஒவ்வொரு முறையும் உங்கள் மரபுகளை ஏஜெண்ட் மீண்டும் கண்டறிவதைத் தடுக்கிறது. உருவாக்கப்பட்ட ஒரு வரைபடம், உங்கள் கட்டமைப்பை அது மீண்டும் கண்டறிவதைத் தடுக்கிறது. இதில் உள்ள வித்தியாசம் அதை யார் எழுதுகிறார்கள் என்பதுதான். நீங்கள் அறிவுறுத்தல் கோப்பை கையால் எழுதுகிறீர்கள், எனவே அது சிறியதாக இருக்கிறது. ஒரு parser வரைபடத்தை உருவாக்குகிறது, எனவே அது பத்தாயிரம் கோப்புகளை உள்ளடக்கும். ஒரு அமர்வுக்குள் பட்ஜெட் உண்மையில் எங்கே செலவாகிறது என்பதைப் பற்றி, Claude Code தனது context window-ஐ எவ்வாறு செலவிடுகிறது என்ற பகுதி விளக்குகிறது.

Graft உண்மையில் உருவாக்குபவை

இரண்டு கலைப்பொருட்கள் (artefacts), இவை இரண்டும் களஞ்சியத்தின் (repository) வேர்ப் பகுதியில் உள்ள ஒரே graft/ கோப்புறையின் கீழ் இருக்கும்.

முதலாவது, இணைக்கப்பட்ட markdown கோப்புகளாக எழுதப்பட்ட ஒரு node graph ஆகும்; ஒரு node-க்கு ஒரு கோப்பு. ஒவ்வொரு node-லும் ஒரு எளிய ஆங்கிலச் சுருக்கம், மூலக் குறியீட்டிலிருந்து (source) எடுக்கப்பட்ட முக்கியமான தர்க்க வரிகளின் "crux", உள்ளடக்க hash-உடன் கூடிய துல்லியமான மூலக் கோப்புகள், பிற node-களுக்கான தட்டச்சு செய்யப்பட்ட wikilinks (depends_on, part_of, uses, implements), மற்றும் மறுஉருவாக்கத்தின் போதும் அழியாத ஒரு குறிப்புகள் பகுதி ஆகியவை இருக்கும்; இதனால் ஒரு parser-ஆல் ஊகிக்க முடியாத சூழலை (context) உங்களால் பதிவு செய்ய முடியும்.

இரண்டாவது graft/.graph/wiring.json ஆகும்; இது tree-sitter பிரித்தெடுக்கும் குறியீடு சார்ந்த கட்டமைப்பு வரைபடம் (structural graph): வரையறைகள், குறிப்புகள் மற்றும் அவற்றுக்கிடையேயான அழைப்பு விளிம்புகள் (call edges).

இந்த பிரிப்பு முக்கியமானது, ஏனெனில் இதில் ஒரு பகுதிக்கு மட்டுமே மாதிரி (model) தேவைப்படுகிறது. graft build என்பது முற்றிலும் tree-sitter சார்ந்தது மற்றும் இது ஒருபோதும் LLM-ஐ (large language model) அழைப்பதில்லை, எனவே இது தீர்மானிக்கக்கூடியது (deterministic) மற்றும் கட்டணமற்றது. graft build --deep என்பது எழுதப்பட்ட சுருக்கங்களையும், குறியீடு சார்ந்த cruxes-களையும் சேர்க்கிறது; இவை நீங்கள் கட்டணம் செலுத்தும் மாதிரி அழைப்புகள் (model calls) ஆகும்.

மொழி ஆதரவு அடுக்கு வாரியாகப் பிரிக்கப்பட்டுள்ளது; ஒரு அழைப்பு வரைபடத்தை (call graph) எவ்வளவு தூரம் நம்பலாம் என்பதை இந்த அடுக்கு உங்களுக்குத் தெரிவிக்கும். TypeScript, JavaScript, Python, Go, Java, Kotlin, PHP, Swift மற்றும் R ஆகிய மொழிகள் scope-ஐ உணர்ந்த கோப்புகளுக்கு இடையேயான தீர்மானத்தைப் (cross-file resolution) பெறுகின்றன. Rust, C, C++, C#, Ruby, Scala, Elixir, Solidity, OCaml, Zig, Dart, Clojure, Nix மற்றும் Lua ஆகிய மொழிகள் symbols மற்றும் பொதுவான அழைப்பு விளிம்புகளைப் பெறுகின்றன; அதாவது, ஒரு விளிம்பு என்பது தீர்க்கப்பட்ட குறிப்புக்கு பதிலாக பெயரின் பொருத்தமாக (name match) இருக்கலாம். Compiler-நிலை விளிம்புகள் --lsp மற்றும் rust-analyzer அல்லது gopls போன்ற language server மூலம் விருப்பத்தேர்வாக (opt-in) பெறலாம்.

Graft-ஐ நிறுவுதல் மற்றும் அதன் பதிப்பைப் பூட்டுதல் (Pinning)

Graft இயங்க Node.js 20 அல்லது அதற்குப் பிந்தைய பதிப்பு தேவை; இது MIT உரிமம் பெற்றது. 17 அக்டோபர் 2026 நிலவரப்படி, தற்போதைய release 0.23.0 ஆகும்; இது 15 அக்டோபர் 2026 அன்று வெளியிடப்பட்டது. இதன் முதல் பதிப்பான 0.1.0, ஜூலை 2026-ல் வெளியானது. இது புதிய மென்பொருள் என்பதால் கவனத்துடன் கையாளவும். 14 அக்டோபர் 2026 அன்று வெளியான 0.22.0 release, இந்தத் திட்டத்தை Trail-code என மறுபெயரிட்டது: அதே code இப்போது @trailhq/trail-code ஆகவும் trail கட்டளையுடனும் கிடைக்கிறது, அதே சமயம் @nanonets/graft தொடர்ந்து graft கட்டளையைப் பயன்படுத்துகிறது.

இந்த வழிகாட்டி 0.21.1 பதிப்பைப் பூட்டுகிறது. இது 29 செப்டம்பர் 2026 அன்று வெளியிடப்பட்டது மற்றும் மறுபெயரிடுவதற்கு முந்தைய கடைசி release ஆகும். ஏனெனில் 0.22 மற்றும் 0.23 பதிப்புகளில் இந்த வழிகாட்டி சார்ந்திருக்கும் கட்டளைகள் மாற்றப்பட்டுள்ளன. 0.22 முதல், graft check உங்கள் branch-ன் diff-ஐ repo-வின் team learnings-உடன் ஒப்பிட்டு, முரண்பாடு இருந்தால் 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 பற்றியே விவரிக்கிறது. பதிப்பைப் பூட்டுவதற்கு முன் changelog-ஐ வாசித்துவிட்டு --dry-run-ஐ இயக்கவும்.

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

npm ls -g கட்டளை @nanonets/graft@0.21.1 என்பதை அச்சிட வேண்டும். அந்தப் பதிப்பைத் திட்டமிட்டுப் பூட்டவும். வெறும் npm install -g @nanonets/graft கட்டளையை இயக்கினால், அது இயக்கும் நேரத்தில் உள்ள latest tag-ஐ எடுத்துக்கொள்ளும். ஒரு மாதத்திற்குப் பல minor releases வெளியிடும் திட்டத்தில், இது செவ்வாய்க்கிழமை அன்று ஒரு கருவியையும், திங்கட்கிழமை உங்கள் சக ஊழியர் நிறுவிய கருவியையும் வேறுபடுத்திக் காட்டும். பூட்டப்பட்ட பதிப்பு (pinned version) CLI flags மற்றும் graph format-ஐ அனைவருக்கும் ஒரே மாதிரியாக வைத்திருக்கும், எனவே நீங்கள் விரும்பும் போது மட்டும் upgrade செய்யலாம்.

பின்னர், உங்களுக்குச் சொந்தமான repository-ல் இதை இணைக்கவும்:

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

graft init எந்த coding agent-ஐ இணைக்க வேண்டும் என்று கேட்கும், பின்னர் graph-ஐ உருவாக்கும். முதலில் --dry-run-ஐ இயக்கி, அது மாற்றத் திட்டமிட்டுள்ள கோப்புகளின் பட்டியலைப் படிக்கவும், ஏனெனில் அவற்றில் சில repository-க்கு வெளியே இருக்கலாம். graft init என்பது idempotent தன்மை கொண்டது மற்றும் ஏற்கனவே உள்ள config-களை மேலெழுதாது (overwrite), எனவே இதை இரண்டாவது முறை இயக்குவது பாதுகாப்பானது. மாற்றங்களை நீக்க, graft uninstall கட்டளை Graft உருவாக்கிய அனைத்து கோப்புகளையும் config பதிவுகளையும் நீக்கும்; நீங்கள் -y-ஐச் சேர்க்கும் வரை இது dry run ஆக மட்டுமே செயல்படும்.

அதே prompt-ல் telemetry checkbox உள்ளது. 0.12.0 release முதல், Graft இயல்பாகவே அநாமதேய பயன்பாட்டுத் தகவலை (usage ping) அனுப்புகிறது: இதில் bucketed counts மற்றும் fixed labels மட்டுமே இருக்கும்; உங்கள் code, file paths அல்லது repository பெயர் ஒருபோதும் அனுப்பப்படாது. நிகழ்வுகள் ஒரு நாளைக்கு ஒருமுறை மட்டுமே அனுப்பப்படும், ஒரு விதிவிலக்கு உண்டு: நிறுவல் நிகழ்வு (install event), இதை npm-ன் postinstall hook உடனடியாக background sender-க்கு அனுப்பிவிடும். graft init-ன் போது அந்தப் பெட்டியைத் தேர்வு நீக்கவும், graft telemetry disable-ஐ இயக்கவும், அல்லது DO_NOT_TRACK=1-ஐ அமைத்து இதை முடக்கவும் (CI-ல் இது தானாகவே முடக்கப்படும்), மேலும் graft telemetry debug அனுப்பப்பட வேண்டிய batch-ஐ அனுப்பாமலேயே அச்சிட்டுக் காட்டும்.

0.21.1 பதிப்பில், Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent மற்றும் Google Antigravity ஆகியவற்றுக்கான இணைப்பு வசதி உள்ளது. Hermes Agent 0.13.0 release முதல் முதன்மையான graft init host-ஆக உள்ளது, மேலும் பூட்டப்பட்ட பதிப்பில் graft init --agents hermes மற்றும் graft init --agents antigravity ஆகியவை மற்ற host-களைப் போலவே இவற்றையும் தேர்வு செய்யும். Grok 0.13.0 release-ல் இணைந்தது மற்றும் graft init --agents grok மூலம் தேர்வு செய்யப்படுகிறது. Claude Code-க்கு மிக ஆழமான ஒருங்கிணைப்பு கிடைக்கிறது: ஒரு MCP server entry, graph அளவு மற்றும் பழமையைக் காட்டும் statusline, graph-ஐ மீண்டும் உருவாக்கும் post-edit hooks, மற்றும் .claude/-ன் கீழ் ஒரு skill file. மற்றவை, கருவிகள் இருப்பதை agent-க்குத் தெரிவிக்கும் instruction அல்லது rule file-ஐப் பெறுகின்றன (Hermes Agent மற்றும் Antigravity ஆகிய இரண்டும் AGENTS.md பகுதியை வாசிக்கின்றன), மேலும் Grok அதன் சொந்த config-ல் ஒரு MCP block-ஐயும் பெறுகிறது. எனவே "Supported" என்பது Graft இணைப்பை எழுதுகிறது என்று பொருள், எனவே தனது சொந்த rules file-ஐத் தவிர்க்கும் ஒரு agent, map-ஐயும் தவிர்க்கும். agents ignore the instructions you write for them என்பதற்கான பொதுவான காரணம் இதுவே, இது இங்கும் பொருந்தும்.

உங்கள் repository-ல் எவை சேரும், எவை git-ல் தவிர்க்கப்பட வேண்டும்

graft init-க்கு பிறகு, பின்வருவனவற்றை எதிர்பார்க்கலாம்:

  • graft/: markdown node graph மற்றும் graft/.graph/wiring.json. இவை உங்களுக்காக .gitignore-ல் சேர்க்கப்படும்.
  • .mcp.json: graft MCP server-ஐ பதிவு செய்யும், இதன் மூலம் Claude Code அதைத் தொடங்கும்.
  • .claude/settings.json: 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 பிரிவுகள் சேர்க்கப்படும்.
  • .grok/config.toml: repo-அளவிலான [mcp_servers.graft] தொகுதி, நீங்கள் Grok-ஐத் தேர்ந்தெடுக்கும்போது மட்டுமே எழுதப்படும்.
  • ~/.codex/config.toml, ~/.codex/hooks.json மற்றும் ~/.codex/hooks/graft/graft-hooks.cjs: machine-அளவிலானவை, நீங்கள் Codex-ஐத் தேர்ந்தெடுத்து, ~/.codex/ ஏற்கனவே இருந்தால் மட்டுமே எழுதப்படும். graft init --no-global இவற்றைத் தவிர்க்கும், மேலும் graft init --no-hooks hook shim-ஐத் தனியாகத் தவிர்க்கும்.

இந்த graph என்பது node_modules போன்ற ஒரு cache ஆகும். இதை commit செய்ய வேண்டாம். இது சில நொடிகளில் குறியீட்டிலிருந்து மீண்டும் உருவாக்கப்படக்கூடியது, ஒவ்வொரு மாற்றத்தின்போதும் இது மாறும். இதை commit செய்தால், ஒரு வரி மாற்றத்திற்குப் பதிலாக நூற்றுக்கணக்கான கோப்புகள் diff-ல் தோன்றும், அதை யாரும் சரிபார்க்க முடியாது. அதற்குப் பதிலாக, AGENTS.md மற்றும் .mcp.json உள்ளிட்ட wiring கோப்புகளை commit செய்யவும். உங்கள் குழு உறுப்பினர் repository-ஐ clone செய்து, graft build-ஐ இயக்கும்போது, அவர்களுக்கான உள்ளூர் graph-ஐப் பெற்றுக்கொள்வார்கள்.

உங்கள் முதல் commit-க்கு முன்பாக, ignore விதி சரியாகச் சேர்க்கப்பட்டுள்ளதா என்பதைச் சரிபார்க்கவும்:

grep -n graft .gitignore
git status --short

grep கட்டளையானது graft/ அடங்கிய வரியை அச்சிட வேண்டும், மேலும் git status --short கட்டளையானது graft/-ன் கீழ் எதையும் காட்டக்கூடாது. graft/-ன் கீழ் உள்ள கோப்புகள் அந்த வெளியீட்டில் தோன்றினால், ignore பதிவு விடுபட்டுள்ளது அல்லது வேறு எங்காவது override செய்யப்பட்டுள்ளது என்று அர்த்தம். commit செய்வதற்கு முன்பே இதைச் சரிசெய்யவும், ஏனெனில் ஒரு கோப்பு ஏற்கனவே சேர்க்கப்பட்டிருந்தால் git அதைத் தொடர்ந்து கண்காணிக்கும், பின்னர் செய்யப்படும் .gitignore மாற்றம் அதைத் தவிர்க்காது.

நீங்கள் MCP server-ஐ கைமுறையாகப் பதிவு செய்ய விரும்பினால் அல்லது நீங்கள் நிறுவிய அதே பதிப்பிற்கு அதை pin செய்ய விரும்பினால், அந்தப் பதிவு இதோ:

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

grep-க்கு மாற்றாக உங்கள் agent பயன்படுத்தும் retrieval கருவிகள்

Graft, MCP வழியாக ஆறு கருவிகளை வழங்குகிறது. graft_find_code, ஒரு பணி விளக்கத்திற்கான தரவரிசைப்படுத்தப்பட்ட nodes-ஐ, கோப்பு மற்றும் வரி எண்ணுடன் வழங்குகிறது. graft_file_api, ஒரு கோப்பில் உள்ள அனைத்து signatures-களையும், அதன் உடற்பகுதி (bodies) இன்றி வழங்குகிறது. graft_trace_calls, callers அல்லது callees-ஐ பல நிலைகள் ஆழத்திற்குச் சென்று ஆய்வு செய்கிறது. graft_find_all, regex மூலம் கண்டறியப்பட்ட முடிவுகளை symbols வாரியாகத் தொகுத்து வழங்குகிறது. graft_repo_map, அறிமுகமில்லாத ஒரு repository-ஐ மேலோட்டமாகப் பார்க்க உதவுகிறது. graft_check_freshness, graph தற்போதைய code-உடன் ஒத்துப்போகிறதா என்பதை உறுதிப்படுத்துகிறது.

ஒவ்வொரு கருவிக்கும் ஒரு 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:line குறிப்புகளைக் கொண்ட தரவரிசைப்படுத்தப்பட்ட nodes-ஐ அச்சிட வேண்டும். இதுவே முழுமையான செயல்முறை: agent ஒரு pointer-ஐப் பெற்று அந்த ஒரு கோப்பை மட்டும் திறக்கிறது; சரியான கோப்பைக் கண்டறிய பத்து கோப்புகளை வாசிப்பதற்குப் பதிலாக இது உதவுகிறது. நீங்கள் graph-ஐ நீங்களே பார்க்க விரும்பினால், graft viz localhost-ல் ஒரு interactive viewer-ஐத் திறக்கும். முப்பது வினாடிகளில் நீங்கள் பதிலளிக்கக்கூடிய ஒரு கேள்விக்கு graft ask பயனுள்ள முடிவுகளைத் தரவில்லை என்றால், கேள்வியை மாற்றி மீண்டும் கேட்க வேண்டாம். தரவரிசைப்படுத்தப்பட்ட retrieval சில நேரங்களில் தவறலாம்; திட்டத்தின் சொந்த skill கோப்பின்படி, பலவீனமான முடிவுகள் கிடைத்தால் graft grep, graft skeleton அல்லது graft callers-க்கு மாற வேண்டும். அவையும் பலனளிக்கவில்லை என்றால், drift உள்ளதா என்று சரிபார்க்கவும் (pinned 0.21.1-ல் graft check ., 0.22 முதல் graft build --check). உங்கள் language எந்த tier-ல் உள்ளது என்பதை உறுதிப்படுத்தவும்; ஏனெனில், பழைய graph அல்லது broad-tier edges உங்கள் agent-ன் செயல்பாட்டைப் பாதிக்கும்.

ஒரு செலவை கவனிக்கத் தவறுவது எளிது. ஒவ்வொரு session-ன் system prompt-லும் ஆறு கருவி வரையறைகள் (tool definitions) சேர்க்கப்படுகின்றன. agent அந்த வரைபடத்தைப் பயன்படுத்தினாலும் இல்லாவிட்டாலும், இதற்கான கட்டணத்தை நீங்கள் செலுத்த வேண்டும். context-க்குள் அடங்கக்கூடிய சிறிய repository-களில், இந்த நிலையான கட்டணம், அது சேமிக்கும் ஆய்வு நேரத்தை விட அதிகமாக இருக்கலாம்.

குறியீடு மாறும்போது வரைபடத்திற்கு என்ன நடக்கும்

கட்டமைப்பு ரீதியான புதுப்பித்தல் (structural refresh) செலவு குறைவானது மற்றும் தானியங்கி முறையில் நடக்கும். Graft, git-க்கு பதிலாக உங்கள் working tree-ஐ வாசிப்பதால், நீங்கள் commit செய்யாத மாற்றமும், staged செய்த மாற்றமும் அதற்கு சமமாகவே தெரியும். ஒவ்வொரு query-யும் முதலில் working tree-ஐ stat செய்து, மாறிய கோப்புகளை மட்டும் மீண்டும் parse செய்யும். 0.21.1 ஆவணங்களின்படி, எந்த மாற்றமும் இல்லாதபோது இந்தச் சரிபார்ப்பிற்கு சுமார் 3 ms ஆகும்; தற்போதைய README-ன் படி, இது சில பத்து மில்லி விநாடிகள், அதாவது திட்டத்தின் சொந்த repository-ல் சுமார் 50 ms ஆகிறது. ஒரு turn-end rebuild, குறியீடு நகர்த்தப்பட்ட கோப்புகளை மட்டுமே தொடும். வட்டில் (disk) உள்ள வரைபடத்திலிருந்து மீண்டும் parse செய்யாமல் பதிலளிக்க GRAFT_NO_REFRESH=1-ஐ அமைக்கவும் அல்லது --no-refresh-ஐப் பயன்படுத்தவும். Graft-ஐ upgrade செய்த பிறகு, அனைத்தையும் முழுமையாக மீண்டும் parse செய்ய --no-reuse-ஐப் பயன்படுத்தவும்.

Model-ஆல் எழுதப்பட்ட பகுதி வித்தியாசமாகச் செயல்படும், இதுவே அமைதியாகத் தவறாகச் செல்லக்கூடிய பகுதியாகும். சுருக்கங்களும் (summaries) முக்கியக் குறிப்புகளும் (cruxes) cache செய்யப்படுகின்றன. ஒவ்வொரு node-ம் அதன் source-களின் content hash-ஐப் பதிவு செய்கிறது, எனவே ஒரு source கோப்பு மாறும்போது, அந்த node தற்போதைய நிலையில் இருப்பதாகக் காட்டப்படாமல், stale (பழையது) என அடையாளப்படுத்தப்படும். அந்த flag, ஏதேனும் ஒன்று அதன் மீது செயல்பட்டால் மட்டுமே உதவும். graft build --deep மூலம் புதுப்பிக்கவும், இது மீண்டும் model tokens-ஐச் செலவழிக்கும்.

Staleness-ஐத் தெரியப்படுத்தவும்:

graft check .
echo $?

Pinned 0.21.1 பதிப்பில், exit status 0 என்பது வரைபடம் குறியீட்டுடன் ஒத்துப்போவதைக் குறிக்கிறது, exit status 1 என்பது முரண்பாட்டைக் (drift) குறிக்கிறது. 0.22 பதிப்பிலிருந்து, graft check ஒரு team learning-உடன் முரண்படும்போது 1 என exit ஆகும், மேலும் drift gate என்பது graft build --check ஆகும், எனவே pin-ஐ மாற்றும்போது கட்டளையையும் மாற்றவும். இதை ஒரு pre-push hook-லிருந்து இயக்கவும், அப்போதுதான் ஆறு மாதங்களுக்கு முந்தைய வரைபடம், மார்ச் மாதம் மீண்டும் எழுதப்பட்ட குறியீட்டைப் பற்றித் தவறான பதிலைத் தராது. 0.21.1 README, graft check-ஐ ஒரு local freshness signal-ஆக விவரிக்கிறது, தற்போதைய README CI-க்காக build --check-ஐப் பட்டியலிடுகிறது. எப்படியிருந்தாலும் graft/ git-ignore செய்யப்படுகிறது, எனவே ஒரு புதிய CI checkout, அந்த job-ஐ உருவாக்காத வரை வரைபடம் இல்லாமலேயே தொடங்கும்.

வெளியிடப்பட்ட benchmark எண்களை கவனமாகப் படிக்கவும்

0.21.1 README-ன் தொடக்கத்தில் "4 மடங்கு வரை மலிவானது மற்றும் 3 மடங்கு வேகமானது, துல்லியத்தன்மையில் எந்த சமரசமும் இல்லை" என்று குறிப்பிடப்பட்டிருந்தது. தற்போதைய README அந்த வரியை நீக்கிவிட்டு, சிறிய எண்களைக் குறிப்பிடுகிறது: "ஒரே agent-ஐக் கொண்டு ஒரே மாதிரியான பணிகளில் செய்யப்பட்ட 162 சோதனைகளில்: 32% குறைந்த செலவு, 42% குறைவான uncached input tokens, 60% குறைந்த நேரம் மற்றும் அதே அளவு சரியான பதில்கள்." இவை திட்டத்தின் சொந்த benchmark-களில் இருந்து பெறப்பட்டவை, அவை அதன் README-ல் வெளியிடப்பட்டுள்ளன. அது முழுமையாகப் புகாரளிக்கும் இரண்டு சோதனைகள் கீழே கொடுக்கப்பட்டுள்ளன.

விளக்கப்படம்Graft's own published benchmark results, versus a no-map baseline, as of October 2026
இந்த விளக்கப்படத்தின் தரவு
[
  {
    "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 என்பது 162 சோதனைகளைக் கொண்டது. இது இரண்டு repositories-ல் மேற்கொள்ளப்பட்டது, அதில் ஒன்று Graft-ன் சொந்த repository ஆகும்; ஒவ்வொரு பணிக்கும் மூன்று trials செய்யப்பட்டன. இது 42% குறைவான uncached input tokens மற்றும் 46% குறைவான tool calls-ஐக் காட்டுகிறது. SWE-bench Verified சோதனை என்பது 50 instances-ஐக் கொண்டது, இதில் இரண்டு தரப்பிலும் ஒரே model பயன்படுத்தப்பட்டது. இது சிறிய சேமிப்பையே காட்டுகிறது: 23% tokens மற்றும் 25% tool calls. 15 PocketBase பணிகளைக் கொண்ட மூன்றாவது சோதனையில், பத்து developer கேள்விகள் மற்றும் ஐந்து pull requests ஆகியவை அடங்கும். இதற்கு baseline-ன் 13.91 டாலர்களுக்கு எதிராக, மொத்தம் 11.02 அமெரிக்க டாலர்கள் செலவானது.

இவை அனைத்தையும் ஒரு vendor benchmark-ஆகக் கருதவும். இது உங்களுக்கு எதை உணர்த்துகிறது என்பதை இரண்டு விஷயங்கள் கட்டுப்படுத்துகின்றன. கட்டுப்படுத்தப்பட்ட sweep-ல் Graft-ன் சொந்த repository அடங்கும், இது அதன் ஆசிரியர்கள் எதனை அடிப்படையாகக் கொண்டு உருவாக்கினார்களோ அந்த codebase ஆகும். SWE-bench Verified என்பது நன்கு அறியப்பட்ட open-source Python திட்டங்களின் சிக்கல்களைக் கொண்ட ஒரு பொதுவான dataset ஆகும். கருவிகள் வேண்டுமென்றோ அல்லது தற்செயலாகவோ பொதுவான dataset-களுக்காகவே மேம்படுத்தப்படுகின்றன. இவை எதுவும் உங்கள் சொந்த monorepo-வைப் பற்றியது அல்ல; உங்கள் monorepo-விற்கு என்று தனித்துவமான பெயரிடும் முறைகளும், பயன்படுத்தப்படாத code-களும் இருக்கும்.

துல்லியத்தன்மையை (correctness) மீண்டும் ஒருமுறை கவனிக்க வேண்டும். கட்டுப்படுத்தப்பட்ட sweep-ல் அது மாறவில்லை: map-உடன் 93% மற்றும் அது இல்லாமல் 93%. SWE-bench Verified சோதனையில் மட்டுமே 54%-லிருந்து 66%-ஆக உயர்வு காணப்படுகிறது. உங்கள் token செலவைக் குறைத்து, தரத்தை மாற்றாமல் வைத்திருக்கும் ஒரு கருவி நல்ல லாபகரமானதே. ஆனால், SWE-bench-ன் துல்லியத்தன்மை முடிவையும், sweep-ன் token முடிவையும் ஒன்றாக இணைத்து ஒரே கூற்றாகக் கூற வேண்டாம்.

எந்தவொரு தகவலையும் நம்புவதற்கு முன் உங்கள் சொந்த token delta-வை அளவிடுங்கள்

உங்கள் repository-லிருந்து கிடைக்கும் எண் மட்டுமே முக்கியமானது. இந்த முறைக்கு ஒரு மதிய நேரம் தேவைப்படும்.

துல்லியமாக மீண்டும் செய்யக்கூடிய ஒரு பணியைத் தேர்வு செய்யுங்கள். ஒரு திருத்தத்தை விட ஒரு கேள்வி சிறந்தது, ஏனெனில் திருத்தம் repository-ஐ மாற்றும், இரண்டாவது முறை செய்யப்படும் சோதனை அதே சோதனையாக இருக்காது. "login route-ல் rate limit-ஐ எந்த module அமல்படுத்துகிறது" என்பது சரியான வடிவம்.

Telemetry-ஐ இயக்கி, அதை உங்கள் terminal-க்கு அனுப்புங்கள்:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console
claude

Console exporter, metric பதிவுகளைச் சேகரிக்கும்போது அவற்றை அச்சிடும். உங்களுக்குத் தேவையானது claude_code.token.usage ஆகும், இது input, output, cacheRead அல்லது cacheCreation ஆகியவற்றுள் ஏதேனும் ஒன்றின் type பண்பைக் கொண்டிருக்கும். கோப்பின் உள்ளடக்கங்கள் அங்குதான் சேர்வதால், orientation என்பது input மற்றும் cacheRead ஆகியவற்றில் தெரியும். அந்த இரண்டையும் கூட்டிக்கொள்ளுங்கள்.

வரைபடம் (map) இணைக்கப்பட்ட நிலையில், ஒவ்வொரு முறையும் புதிய session-ல் அந்தப் பணியை மூன்று முறை செய்யுங்கள். பிறகு .mcp.json-லிருந்து graft entry-ஐ நீக்கிவிட்டு, மீண்டும் மூன்று முறை செய்யுங்கள். ஒற்றை ஓட்டங்களை விட median மதிப்புகளை ஒப்பிடுங்கள், ஏனெனில் agent ஓட்டங்கள் பெருமளவில் மாறுபடும், ஒரு துரதிர்ஷ்டவசமான ஓட்டம் உண்மையை மாற்றிச் சொல்லக்கூடும். Tool-call எண்ணிக்கையையும் பதிவு செய்யுங்கள்: tool calls என்பது செயல்முறை, tokens என்பது அதன் விளைவு; எனவே tool calls குறையாமல் token சேமிப்பு ஏற்பட்டால், ஏதோ ஒன்று மாறியிருக்கிறது என்று அர்த்தம்.

பிறகு, benchmark காட்டாத செலவுகளைக் கழித்துவிடுங்கள். graft build --deep ஒவ்வொரு முழு refresh-க்கும் model tokens-ஐச் செலவிடுகிறது. ஆறு tool schemas-ம் ஒவ்வொரு கோரிக்கையிலும் உடன் செல்கின்றன. உங்கள் agents நீங்கள் வாடகைக்கு எடுத்த server-ல் இயங்கினால், agent செலவுக்கு ஒரு உச்ச வரம்பை நிர்ணயிப்பது இதை ஒரு எதிர்பாராத செலவிலிருந்து திட்டமிடப்பட்ட வரவுசெலவாக மாற்றும், மேலும் coding agent-ன் telemetry உண்மையில் எதைப் புகாரளிக்கிறது என்பது, exporter-ஐ இயக்கிய பிறகு கணினியிலிருந்து வெளியேறுவது என்ன என்பதை விளக்குகிறது.

Codebase map எப்போது பயனளிக்காது?

  • Repository ஏற்கனவே context-க்குள் அடங்கிவிடுகிறது. ஒரு சிறிய service-க்கு map தேவையில்லை, ஆனால் ஒவ்வொரு request-க்கும் ஆறு tool schemas-க்கான கட்டணத்தை நீங்கள் செலுத்த வேண்டியிருக்கும். உங்கள் agent இன்று ஒன்று அல்லது இரண்டு tool calls-ல் எந்தக் கோப்பையும் கண்டறிந்தால், map-ஐத் தவிர்க்கவும்.
  • உங்கள் language broad tier-ல் உள்ளது. பொதுவான call edges இருப்பதால் graft callers ஒரு caller-ஐத் தவறவிடலாம் அல்லது பெயர் மோதலால் (name collision) தவறான ஒன்றைக் காட்டலாம். ஒரு blast radius-ஐ நம்புவதற்கு முன் graft grep மூலம் உறுதிப்படுத்தவும்.
  • Graph காலாவதியாகிவிட்டது, யாரும் கவனிக்கவில்லை. 0.21.1 பதிப்பில் graft check drift ஏற்பட்டால் 1 என exit ஆகும் (0.22 முதல், graft build --check அவ்வாறு செய்யும்), ஆனால் இதை யாராவது இயக்கினால் மட்டுமே பயன் உண்டு. இது ஒரு பழக்கமல்ல, ஒரு pre-push hook ஆக இருக்க வேண்டும்.
  • Monorepo-க்கு scoping தேவைப்படுகிறது. ஒரு single-git monorepo பிரிக்கப்படவில்லை, ஆனால் graft build ஆனது pnpm-workspace.yaml, package.json workspaces அல்லது per-package go.mod, pyproject.toml அல்லது Cargo.toml ஆகியவற்றிலிருந்து sub-projects-ஐக் கண்டறிந்து அவற்றை ranking scopes-ஆகப் பயன்படுத்துகிறது, மேலும் graft ask "..." --in services/billing/ ஒரு query-ஐ ஒரு sub-project-க்குள் சுருக்குகிறது. ஒவ்வொரு package-க்கும் nested AGENTS.md கோப்புகள் என்ற அதே அணுகுமுறைதான் map-க்கும் பொருந்தும்.
  • Agent wiring-ஐப் புறக்கணிக்கிறது. map பயன்படுத்தப்படுகிறது என்று முடிவெடுக்கும் முன், ஒரு உண்மையான session-ல் tool calls-ஐக் கவனியுங்கள். ஒரு agent இன்னும் grep-ஐ இயக்குகிறது என்றால், அது rules கோப்பை ஒருபோதும் படிக்கவில்லை என்று அர்த்தம்.

FAQ

graft/ கோப்புறையை git-ல் commit செய்ய வேண்டுமா?

வேண்டாம். graft build தானாகவே graft/-ஐ உங்கள் .gitignore-ல் சேர்க்கிறது. ஏனெனில், இந்த வரைபடம் (graph) node_modules போன்ற மீண்டும் உருவாக்கக்கூடிய ஒரு cache ஆகும். இது ஒவ்வொரு திருத்தத்தின் போதும் மாறுவதால், இதை commit செய்வது நூற்றுக்கணக்கான கோப்புகளை உருவாக்கி உண்மையான diff-களை மறைத்துவிடும். வரைபடம் இருப்பதை agents-க்குத் தெரிவிக்கும் wiring-ஐ மட்டும் commit செய்யுங்கள் (அவற்றில் AGENTS.md மற்றும் .mcp.json அடங்கும்). ஒவ்வொரு குழு உறுப்பினரும் graft build-ஐ உள்ளூர் அளவில் இயக்கட்டும். உங்கள் முதல் commit-க்கு முன்பே grep -n graft .gitignore மற்றும் git status --short மூலம் சரிபார்க்கவும்; ஏனெனில் ஒரு கோப்பு git-ல் சேர்க்கப்பட்ட பிறகு, அதைத் தொடர்ந்து கண்காணிக்கும். அதன் பிறகு .gitignore-ஐத் திருத்தினாலும் அது கண்காணிப்பிலிருந்து நீங்காது.

Graft-ஐ இயக்க பணம் செலவாகுமா?

அதன் கட்டமைப்புப் பகுதிக்கு (structural half) செலவாகாது. graft build, graft ask, graft check மற்றும் ஆறு MCP retrieval கருவிகள் ஆகியவை tree-sitter செயல்பாடுகள் ஆகும்; இவை ஒருபோதும் model-ஐ அழைப்பதில்லை. graft build --deep என்பது கட்டணப் பகுதி: இது LLM மூலம் எளிய ஆங்கிலச் சுருக்கங்களையும், ஒவ்வொரு குறியீட்டிற்குமான முக்கிய அம்சங்களையும் எழுதுகிறது. இது GRAFT_PROVIDER, GRAFT_API_KEY மற்றும் GRAFT_MODEL ஆகியவற்றைக் கொண்டும், OpenAI-இணக்கமான endpoint-களுக்கு GRAFT_BASE_URL-ஐக் கொண்டும் கட்டமைக்கப்படுகிறது. நீங்கள் Graft-ஐ அதன் கட்டமைப்புடன் மட்டும் இயக்கலாம், வரைபடத்திற்காக ஒரு token-ஐக் கூட செலவிட வேண்டியதில்லை.

ஒரு codebase map எனது repository-ல் எவ்வளவு சேமிப்பைத் தரும்?

அளவிடாமல் யாராலும் இதைக் கூற முடியாது. இந்தத் திட்டம் அதன் சொந்த 162-முறை இயக்கத்தில் 42% குறைவான uncached input tokens-ஐயும், SWE-bench Verified-ல் 23% குறைவான tokens-ஐயும் சேமிப்பதாகக் குறிப்பிடுகிறது. இவை இரண்டும் vendor benchmarks ஆகும்; இதில் ஒன்று Graft-ன் சொந்த repository-ல் இயக்கப்பட்டவை. இவை உங்கள் தனிப்பட்ட குறியீட்டை விவரிக்கவில்லை. வரைபடத்துடன் ஒரு repeatable கேள்வியை மூன்று முறையும், வரைபடம் இல்லாமல் மூன்று முறையும் இயக்கவும். அப்போது CLAUDE_CODE_ENABLE_TELEMETRY=1 மற்றும் OTEL_METRICS_EXPORTER=console ஆகியவற்றை அமைத்து, input மற்றும் cacheRead வகைகளுக்கான claude_code.token.usage-ன் median மதிப்பை ஒப்பிடவும்.

நான் refactor செய்யும்போது வரைபடத்திற்கு என்னவாகும்?

கட்டமைப்பு தன்னைத்தானே மீண்டும் பகுப்பாய்வு (re-parse) செய்துகொள்ளும். Graft working tree-ஐச் சரிபார்த்து, மாறிய கோப்புகளை மட்டும் மீண்டும் பகுப்பாய்வு செய்கிறது. எனவே, ஒரு பெயர் மாற்றம் அடுத்த query-ல் கண்டறியப்படும். எதுவும் மாறவில்லை என்றால், 0.21.1 பதிப்பில் இந்தச் சரிபார்ப்பிற்கு சுமார் 3 ms-ம், தற்போதைய பதிப்பில் சில பத்து மில்லி விநாடிகளும் மட்டுமே ஆகும். இது git வரலாற்றை விட கோப்புகளை நேரடியாகப் படிப்பதால், commit செய்யப்படாத மாற்றங்களையும் இது காணும். model-ஆல் எழுதப்பட்ட சுருக்கங்கள் மட்டுமே பழையதாகிவிடும் (stale): ஒவ்வொரு node-ம் அதன் மூலங்களின் content hash-ஐச் சேமித்து வைத்திருக்கும். ஒரு மூலம் மாறினால், அது node-ஐ மீண்டும் எழுதுவதற்குப் பதிலாக 'stale' என்று குறிக்கும். drift-ஐச் சரிபார்க்க (0.21.1-ல் graft check ., 0.22-லிருந்து graft build --check) கட்டளையிடவும், பின் எழுதப்பட்ட பகுதியைத் தற்போதைய நிலைக்கு மாற்ற 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 ஆகிய பதினொரு hosts-ஐ இணைக்கிறது. changelog-ல் 0.13.0 பதிப்பிலிருந்து Hermes Agent ஒரு முதன்மை host-ஆகப் பட்டியலிடப்பட்டுள்ளது. மேலும் hermes மற்றும் antigravity ஆகியவை pinned பதிப்பில் சாதாரண --agents ids ஆகும். Claude Code அதிக வசதிகளைப் பெறுகிறது: .mcp.json-ல் ஒரு MCP server entry, ஒரு statusline, post-edit hooks மற்றும் .claude/-ன் கீழ் ஒரு skill file. Codex ஒரு AGENTS.md பகுதியையும், ~/.codex/-ன் கீழ் machine-wide entries-ஐயும் பெறுகிறது (இதை graft init --no-global தவிர்க்கிறது). Grok ஒரு skill file மற்றும் .grok/config.toml-ல் ஒரு MCP block-ஐப் பெறுகிறது. Hermes Agent மற்றும் Antigravity ஆகியவை AGENTS.md பகுதியைப் படிக்கின்றன, மற்றவை rules அல்லது steering file-ஐப் பெறுகின்றன. பிற MCP clients, npx -y @nanonets/graft@0.21.1 mcp கட்டளையைப் பதிவு செய்வதன் மூலம் server-ஐ நேரடியாகப் பயன்படுத்தலாம்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?