Graft คือเครื่องมือโอเพนซอร์สที่ทำแผนที่ของโค้ดทั้งโปรเจกต์เก็บไว้ล่วงหน้า ให้ coding agent ผู้ช่วยเขียนโค้ด AI อย่าง Claude Code หรือ Cursor เปิดอ่านก่อนลงมือแก้ไฟล์

คนที่เพิ่งเข้าโปรเจกต์ใหม่ใช้เวลาทำความรู้จักโครงสร้างแค่รอบเดียว แล้วจำไปใช้ได้อีกหลายเดือน แต่ agent เริ่มจากศูนย์ใหม่ทุกครั้งที่เปิดหน้าต่างสนทนา มันค้นคำในไฟล์ เปิดไฟล์ที่เจอ ไล่ตามการเรียกใช้ไปอีกชั้น ย้อนกลับ แล้วลองใหม่ ทุกขั้นตอนกินโทเคน ซึ่งเป็นหน่วยข้อความที่ผู้ให้บริการ AI ใช้คิดเงิน กว่าจะเห็นโครงสร้างแบบเดียวกับที่เพิ่งไล่ดูไปเมื่อชั่วโมงก่อน บิลก็เดินไปแล้วทั้งที่ยังไม่ได้แก้โค้ดสักบรรทัด

แผนที่ที่ว่าไม่ใช่ฐานข้อมูลอะไรที่เปิดดูไม่ได้ มันคือโฟลเดอร์ที่เก็บไฟล์ markdown ซึ่งเป็นไฟล์ข้อความธรรมดาที่คนเปิดอ่านเองได้ ไฟล์เหล่านี้เชื่อมโยงถึงกัน และแบ่งเนื้อหาเป็นหนึ่งไฟล์ต่อหนึ่งระบบย่อย หนึ่ง API หรือหนึ่งแนวคิดในโปรเจกต์ agent เปิดอ่านและตามลิงก์ในนั้นด้วยวิธีเดียวกับที่เปิดไฟล์โค้ดทั่วไป ไม่ต้องติดตั้งอะไรเพิ่มเพื่อให้มันอ่านออก

การค้นซ้ำที่ไม่มีใครเก็บไว้ใช้ต่อ

ต้นทุนไม่ได้มาจากการที่ agent ต้องอ่านโค้ด แต่มาจากการที่มันต้องอ่านของเดิมซ้ำทุกรอบ

สิ่งที่เสียเปล่าจากการค้นแบบนี้มีอยู่สามอย่าง อย่างแรกคือมันเกิดใหม่ทุกงาน งานถัดไปจ่ายค่าอ่านชุดเดิมอีกรอบเต็มๆ อย่างที่สองคือผลของมันหายไปพร้อมหน้าต่างที่ปิด ไม่มีอะไรเหลือไว้ให้รอบหน้า อย่างที่สามคือไม่มีใครได้ใช้ต่อ เพื่อนร่วมทีมที่เปิด agent ของตัวเองก็ต้องไล่ใหม่จากศูนย์เหมือนกัน

ปัญหาข้อนี้มีคนพยายามแก้จากหลายทาง เช่น deja-vu ที่ขุด log เก่าของ agent มาให้มันจำได้ว่าเคยแก้บั๊กนี้ไปแล้ว ส่วนทางที่ Graft เลือกคือย้ายงานอ่านโค้ดออกมาทำนอกรอบ จ่ายครั้งเดียว เก็บผลเป็นไฟล์ แล้วให้ทุก session รอบการทำงานหยิบไปใช้ต่อได้เลย

ตัวเลขจาก 162 รอบทดสอบ กับ 50 เคสบั๊กจริง

ชุดแรกเป็นการทดสอบแบบคุมตัวแปร 162 รอบบน 2 โปรเจกต์ โปรเจกต์แรกคือรีโปหรือคลังโค้ดของ Graft เอง อีกโปรเจกต์คือบริการ auth หรือระบบยืนยันตัวตนที่เขียนด้วย Node/Express ทั้งสองฝั่งใช้ agent ตัวเดียวกันและเครื่องมือเปิดไฟล์ชุดเดียวกัน ต่างกันแค่ว่ามีแผนที่ป้อนให้อ่านก่อนหรือไม่

แถวสุดท้ายสำคัญพอกับแถวอื่น เพราะข้อกังวลของการทำให้ถูกลงและเร็วขึ้นคือคำตอบหยาบลงตามไปด้วย แต่ในชุดนี้คะแนนความถูกต้องเท่าเดิม

ชุดที่สองเป็นชุดทดสอบมาตรฐานอย่าง SWE-bench Verified ซึ่งหยิบบั๊กจริงจากโปรเจกต์บน GitHub มา 50 เคส แล้วตัดสินด้วยชุดทดสอบของเจ้าของโปรเจกต์เอง ไม่มีโมเดลมานั่งให้คะแนน ผลคือเมื่อไม่มีแผนที่ agent แก้ผ่าน 27 จาก 50 เคส และขยับขึ้นเป็น 33 จาก 50 เคสเมื่อต่อ Graft เข้าไป คิดเป็น 54% กับ 66% ส่วนรอบที่ต่อ Graft ยังใช้โทเคนน้อยลง 23% และใช้เวลารวมน้อยลง 32%

ตัวเลขโทเคน 42% กับ 23% มาจากคนละชุดทดสอบ จึงเทียบกันตรงๆ ไม่ได้ ชุดแรกตอบว่าถูกลงและเร็วขึ้นไหม ส่วนชุดที่สองตอบว่าแก้บั๊กผ่านมากขึ้นไหม

ยังมีอีกชุดที่ลองกับ PocketBase โปรเจกต์โอเพนซอร์สที่เขียนด้วย Go ชุดนี้ชี้ว่าผลต่างชัดที่สุดในคำถามที่ต้องค้นข้ามหลายไฟล์ เช่นคำถามว่าระบบ auth ทำงานอย่างไรเมื่อต่อกับระบบล็อกอินภายนอกอย่าง OAuth2 หลายเจ้า ค่าใช้จ่ายในการตอบคำถามนั้นลดจาก $2.19 เหลือ $0.84

แผนที่โค้ดของ Graft สร้างเป็นสองชั้น

ชั้นแรกคือคำสั่ง graft build ซึ่งใช้ tree-sitter ตัวอ่านไวยากรณ์ของโค้ดที่ไม่พึ่งโมเดล AI เลย มันไล่เก็บทุกฟังก์ชัน ทุกคลาส รวมถึงความสัมพันธ์จากการเรียกใช้และการ import แล้วสร้างเป็นกราฟ ชั้นนี้ให้ผลเหมือนเดิมทุกครั้งที่รัน ไม่ต้องมี API key ไม่ต้องต่อเน็ต และไม่มีค่าใช้จ่าย

ชั้นที่สองคือ graft build --deep ซึ่งเลือกได้ว่าจะทำหรือไม่ ขั้นนี้ให้โมเดลสรุปแต่ละไฟล์เป็นภาษาคน แล้วนำคำสรุปมารวมเป็นโหนดที่มีลิงก์บอกความสัมพันธ์ระหว่างกัน โดย Graft จะเลือกเองว่าจะรวมเป็นกี่โหนด ไม่ใช่หนึ่งไฟล์ต่อหนึ่งโหนด

โหนดหนึ่งเก็บของไว้ห้าอย่าง คือคำสรุปภาษาคน · โค้ดไม่กี่บรรทัดที่เป็นแก่นจริงๆ · รายชื่อไฟล์ต้นทางที่นำมาสร้าง · ลิงก์ไปโหนดอื่น · และช่องว่างให้คนเขียนโน้ตเพิ่มเอง โน้ตที่คนเขียนไว้จะไม่หายไปตอนสร้างแผนที่ใหม่ ส่วนโค้ดที่คัดมาจะเก็บเป็นตัวโค้ดจริง ไม่ใช่เลขบรรทัด ไฟล์ขยับไปแล้วก็ยังตามเจอ

แนวคิดจ่ายค่าอ่านครั้งเดียวแล้วให้ agent อ่านของที่เตรียมไว้ ไม่ได้ใช้ได้แค่กับโค้ด book-to-skill ก็ทำแบบเดียวกันกับหนังสือทั้งเล่ม โดยให้ agent เปิดอ่านทีละบทแทนการยัดทั้งเล่มเข้าไป

สิ่งที่ทำให้มันใช้ได้จริงในงานประจำวันคือแผนที่จะอัปเดตตัวเองก่อนที่ agent จะเรียกใช้ ทุกครั้งที่มีคำถามเข้ามา Graft จะเทียบไฟล์ในเครื่องกับข้อมูลจากรอบสร้างล่าสุดภายในเวลาราวสามมิลลิวินาที แล้วรีเฟรชเฉพาะส่วนที่เปลี่ยน ขั้นนี้ฟรีและไม่เรียกโมเดล มันจึงเห็นแม้แต่โค้ดที่เพิ่งแก้ค้างไว้และยังไม่ commit ในรีโปของ Graft เองที่มี 124 ไฟล์ การสร้างรอบแรกใช้เวลา 0.74 วินาที ส่วนรอบถัดไปที่แก้เพียงไฟล์เดียวลดเหลือ 0.18 วินาที

อีกเรื่องที่ตัดออกไปเลยคือไม่มี embedding สำหรับแปลงข้อความเป็นเวกเตอร์ และไม่มีดัชนีเวกเตอร์ที่ต้องคอยดูแล แผนที่เป็นไฟล์ธรรมดาล้วนๆ อยากเห็นว่าหน้าตาเป็นอย่างไรก็สั่ง graft viz เปิดดูในเครื่องได้

ติดตั้ง Graft ใช้แค่สองคำสั่ง

npm install -g @nanonets/graft
graft init

ถ้าไม่อยากติดตั้งค้างไว้ในเครื่อง ใช้ npx @nanonets/graft init แทนได้

graft init จะตรวจก่อนว่าเครื่องมี agent ตัวไหนติดตั้งอยู่แล้วบ้าง จากนั้นจะถามว่าจะต่อกับตัวไหน โดยเลือก Claude Code ไว้ให้ตัวเดียว ส่วนที่เหลือต้องเลือกเอง มันจะยังไม่เขียนไฟล์อะไรลงเครื่องจนกว่าจะกดยืนยัน อยากเห็นรายการไฟล์ที่มันจะแตะก่อนก็สั่ง graft init --dry-run ส่วนถ้ารู้อยู่แล้วว่าจะต่อกับตัวไหน ก็ข้ามคำถามด้วย graft init --agents claude

ของเดิมในโปรเจกต์ไม่ต้องรื้อ Graft จะแทรกเฉพาะส่วนของตัวเองลงในไฟล์คำสั่งที่ agent อ่านอยู่แล้ว พร้อมใส่เครื่องหมายกำกับหัวท้าย เช่น AGENTS.md หรือ .github/copilot-instructions.md ถ้า agent ตัวไหนใช้ไฟล์แยก Graft ก็จะเขียนเป็นไฟล์ของตัวเองอย่าง .claude/skills/graft/SKILL.md รันซ้ำอีกกี่ครั้งมันก็แก้เฉพาะส่วนของตัวเอง ไม่ยุ่งกับบรรทัดที่เราเขียนไว้

Claude Code ต่อกับ Graft ได้ลึกที่สุด ตัวอื่นต่อผ่านไฟล์คำสั่งหรือ MCP

Claude Code ได้ของครบที่สุดในบรรดา agent ที่รองรับ นอกจากไฟล์สกิลแล้วยังได้แถบสถานะที่บอกว่าแผนที่มีกี่โหนด สรุปไปแล้วกี่เปอร์เซ็นต์ และมีโหนดไหนเก่าจนควรสร้างใหม่ ทุกครั้งที่พิมพ์คำถามเข้าไป Graft จะดึงโหนดที่เกี่ยวข้องเข้ามาให้เอง และเมื่อแก้ไฟล์ไหนไป มันจะเตือนขึ้นมาว่ามีใครพึ่งพาไฟล์นั้นอยู่บ้าง พร้อมซิงก์แผนที่ใหม่ให้โดยไม่คิดเงิน เพราะขั้นตอนนี้ใช้เฉพาะข้อมูลโครงสร้าง

Cursor · Codex · Gemini · Copilot ต่อผ่านไฟล์คำสั่งของแต่ละตัว หรือต่อผ่าน MCP server ซึ่งเป็นช่องทางมาตรฐานสำหรับให้ AI เรียกใช้เครื่องมือภายนอก MCP server มีเครื่องมือให้ใช้หกอย่าง เช่น graft_find_code สำหรับหาว่าโค้ดเรื่องนี้อยู่ไฟล์ไหน graft_trace_calls สำหรับไล่สายการเรียกใช้ และ graft_repo_map สำหรับขอภาพรวมทั้งโปรเจกต์ สิ่งที่ไม่ได้คือแถบสถานะและตัวเตือนตอนแก้ไฟล์แบบที่ Claude Code ได้

ส่วนภาษาที่อ่านได้เต็มรูปแบบจนตามการเรียกใช้ข้ามไฟล์ได้มีอยู่ห้าภาษา คือ TypeScript · JavaScript · Python · Go · Java ภาษาอื่นอ่านได้ในระดับสัญลักษณ์และการเรียกใช้ภายในไฟล์ เช่น Rust · C · C++ · C# · Ruby · PHP · Kotlin · Swift ซึ่งทางผู้พัฒนานับรวมทั้งหมดว่ายี่สิบภาษา ไฟล์ที่เป็นภาษานอกรายการนี้ Graft จะข้ามไป ไม่เอาเข้าแผนที่

ข้อควรรู้ก่อนรัน graft init

แผนที่อยู่ในเครื่องใครเครื่องมัน graft build ใส่โฟลเดอร์ graft/ ลงใน .gitignore ให้อัตโนมัติ เพราะมันคือแคชที่สร้างใหม่ได้เสมอ ไม่ใช่ของที่ commit ขึ้นไป สิ่งที่แชร์กับทีมมีแค่ไฟล์ตั้งค่าการเชื่อมต่อใน .claude/ คนที่โคลนโปรเจกต์ไปจึงได้การตั้งค่านี้ไปด้วย แต่ต้องสั่งสร้างแผนที่ของตัวเองอยู่ดี เอกสารระบุว่าสามารถ commit แผนที่ขึ้นไปทั้งชุดได้เหมือนกัน เพียงแต่นั่นไม่ใช่ค่าเริ่มต้น

ชั้นสรุปด้วยโมเดลต้องใช้ API key ของตัวเอง ตั้งค่าผ่าน GRAFT_PROVIDER GRAFT_API_KEY และ GRAFT_MODEL ส่วนค่าใช้จ่ายส่วนนี้ขึ้นอยู่กับอัตราที่ผู้ให้บริการโมเดลคิด ชั้นโครงสร้างยังฟรีและทำงานแบบไม่ต่อเน็ตได้ ใครอยากลองแบบไม่เสียอะไรเลยก็หยุดไว้แค่ชั้นแรก

Graft ไม่ส่งข้อมูลการใช้งานกลับไปหาผู้พัฒนา และจะต่อออกเน็ตเฉพาะตอนส่งคำขอไปยังโมเดลที่ตั้งค่าไว้เอง

ตัวเลขในหน้ารีโปเป็นของโปรเจกต์ที่ผู้พัฒนาเลือกมาเอง ส่วนตัวเลขที่จะช่วยตัดสินใจได้จริงมีอยู่ชุดเดียว คือตัวเลขจากโปรเจกต์ที่เปิดอยู่ทุกวัน รัน graft init กับรีโปที่ใหญ่ที่สุดในเครื่อง แล้วเทียบบิลรอบถัดไปดูเอง

ที่มา: โปรเจกต์ Graft บน GitHub จาก NanoNets