สรุปสั้นๆ: codebase-memory-mcp จะจัดทำดัชนี (index) โค้ดใน repository ของคุณให้กลายเป็นกราฟความรู้แบบถาวร (persistent knowledge graph) เพื่อให้เอเจนต์เขียนโค้ดของคุณสามารถตอบคำถามเกี่ยวกับโครงสร้างจากกราฟได้โดยตรง แทนที่จะต้องค้นหาและอ่านจากไฟล์ต่างๆ โครงการนี้ได้ทำการวัดผลการค้นหาโครงสร้างห้าครั้ง โดยใช้โทเค็นประมาณ 3,400 โทเค็นผ่านกราฟ เทียบกับประมาณ 412,000 โทเค็นผ่านการสำรวจไฟล์ทีละไฟล์ ซึ่งเป็นการลดลงถึง 99.2% เขียนด้วยภาษา C, มาในรูปแบบไบนารีเดียวแบบ native โดยไม่ต้องมีรันไทม์ (runtime) หรือคีย์ API, รองรับมากกว่า 160 ภาษา และทำงานทั้งหมดบนเครื่องของคุณ ได้รับ 41,536 ดาว (stars) ณ วันที่ 1 กันยายน 2026, ภายใต้ลิขสิทธิ์ MIT หากคุณจะติดตั้งเครื่องมือเพียงอย่างเดียวจากกระแสเครื่องมือเอเจนต์ในปี 2026 ขอให้เป็นตัวนี้
นี่คือการเจาะลึกเครื่องมือหนึ่งจากรายการ เครื่องมือเอเจนต์ AI โอเพนซอร์สห้าตัวที่น่าติดตั้งในปี 2026 ของเรา
ลองถามเอเจนต์ของคุณว่ามีการเรียกใช้ฟังก์ชันหนึ่งที่ไหน แล้วดูว่าเกิดอะไรขึ้น มันจะค้นหา (grep) มันอ่านสามไฟล์ มันค้นหาอีกครั้งด้วยรูปแบบที่แตกต่างกัน มันอ่านอีกสี่ไฟล์ ในที่สุดมันก็ตอบได้ถูกต้อง โดยใช้โทเค็นไปหลายหมื่นโทเค็นเพื่อเติมบริบทด้วยซอร์สโค้ดที่มันจะลืมไปในทันทีที่เซสชันสิ้นสุดลง
จากนั้นคุณถามคำถามต่อเนื่อง และมันก็ทำซ้ำทั้งหมดอีกครั้ง
การวนซ้ำนี้เป็นจุดที่ทำให้ขีดจำกัดการใช้งานของคุณหมดไปส่วนใหญ่ในการทำงานระยะยาว และเป็นเหตุผลว่าทำไมคุณภาพของคำตอบจึงลดลงตลอดช่วงบ่าย: หน้าต่างบริบทที่เต็มไปด้วยเนื้อหาไฟล์มีพื้นที่สำหรับการให้เหตุผลน้อยลง codebase-memory-mcp จัดการทั้งสองปัญหานี้ด้วยวิธีเดียวกัน
สิ่งที่มันทำ
มันแยกวิเคราะห์ repository ของคุณให้เป็นกราฟความรู้แบบถาวร (persistent knowledge graph) ที่ประกอบด้วยฟังก์ชัน, คลาส, สายการเรียกใช้ (call chains), เส้นทาง HTTP, และลิงก์ข้ามบริการ จากนั้นจึงตอบคำถามเกี่ยวกับโครงสร้างจากกราฟนั้น
การแยกวิเคราะห์ (parsing) ทำงานผ่านการวิเคราะห์ AST ของ tree-sitter ครอบคลุมกว่า 160 ภาษา โดยมีเลเยอร์ LSP แบบไฮบริดที่เพิ่มการแก้ไขประเภทเชิงความหมาย (semantic type resolution) สำหรับกลุ่มหลัก 10 ภาษาตามที่ระบุใน README ได้แก่ Python, ตระกูล TypeScript และ JavaScript รวมถึง JSX และ TSX, PHP, C#, Go, C, C++, Java, Kotlin, Rust, และ Perl ความแตกต่างนี้มีความสำคัญ การแยกวิเคราะห์ AST บอกคุณว่ามีการเรียกเมธอดชื่อ save; การแก้ไขประเภทบอกคุณว่ามันเป็นของคลาสใด
ผลลัพธ์ถูกนำเสนอเป็นเครื่องมือ MCP 15 ตัว ครอบคลุมการค้นหา, การติดตามสายการเรียกใช้ (call-chain tracing), ภาพรวมสถาปัตยกรรม, การวิเคราะห์ผลกระทบ (impact analysis), การตรวจสอบความครอบคลุมของดัชนี, การค้นหาด้วย Cypher กับกราฟ, การตรวจจับโค้ดที่ไม่ได้ใช้ (dead code detection), การเชื่อมโยง HTTP ข้ามบริการ, และการจัดการ ADR ลูกค้าใดๆ ที่รองรับ Model Context Protocol สามารถใช้งานได้ และโครงการระบุรายการพื้นผิวเอเจนต์ที่รองรับ 45 รายการ รวมถึง Claude Code, Codex, Cursor, Windsurf, OpenCode, Gemini CLI, Aider, และ Kilocode
ตัวเลข
ข้อมูลสองชุดที่เป็นอิสระต่อกัน และทั้งคู่ควรค่าแก่การอ่านอย่างละเอียด
การวัดผลของโครงการเอง: การค้นหาโครงสร้างห้าครั้งใช้โทเค็นประมาณ 3,400 โทเค็นผ่านกราฟ เทียบกับประมาณ 412,000 โทเค็นผ่านการสำรวจไฟล์ทีละไฟล์ด้วย grep ซึ่งเป็นการลดลง 99.2% หรือประมาณ 120 เท่าของโทเค็นที่น้อยลงสำหรับคำตอบเดียวกัน
ฉบับวิชาการอยู่ในเอกสารฉบับร่างก่อนตีพิมพ์ Codebase-Memory: Tree-Sitter-Based Knowledge Graphs for LLM Code Exploration via MCP ซึ่งประเมินจาก 31 repository จริง รายงานว่ามีคุณภาพคำตอบ 83%, ใช้โทเค็นน้อยลง 10 เท่า และมีการเรียกใช้เครื่องมือน้อยลง 2.1 เท่าเมื่อเทียบกับการสำรวจไฟล์ทีละไฟล์
ช่องว่างระหว่าง 120x และ 10x คือส่วนที่ซื่อสัตย์ ตัวเลข 120x มาจากการค้นหาโครงสร้างห้าครั้ง ซึ่งเป็นกรณีที่ดีที่สุดของกราฟ เพราะคำถามเชิงโครงสร้างคือสิ่งที่กราฟมีไว้สำหรับ ตัวเลข 10x มาจากการผสมผสานที่หลากหลายกว่าใน 31 repository ซึ่งใกล้เคียงกับสิ่งที่คุณจะเห็นในการใช้งานประจำวัน ทั้งคู่เป็นตัวเลขที่มาก ให้ใช้ 10x เป็นตัวเลขสำหรับการวางแผน และมองว่าอะไรก็ตามที่ดีกว่านั้นเป็นผลประโยชน์เพิ่มเติม
ความเร็วเป็นอีกครึ่งหนึ่ง การทำดัชนี Linux kernel ซึ่งมี 28 ล้านบรรทัดใน 75,000 ไฟล์ ใช้เวลาสามนาที repository โดยเฉลี่ยจะถูกทำดัชนีในหน่วยมิลลิวินาที การค้นหาโครงสร้างตอบกลับภายในไม่ถึงหนึ่งมิลลิวินาที ไปป์ไลน์ทำงานโดยใช้ RAM เป็นหลัก พร้อมการบีบอัด LZ4, SQLite ในหน่วยความจำ, และการจับคู่รูปแบบ Aho-Corasick แบบรวม และหน่วยความจำจะถูกปล่อยคืนหลังจากทำดัชนี
การเขียนด้วยภาษา C แทนที่จะเป็น TypeScript หรือ Python คือเหตุผลที่ทำให้ตัวเลขเหล่านี้เป็นจริง และยังเป็นเหตุผลที่ไม่มีรันไทม์ให้ติดตั้งอีกด้วย
การติดตั้ง
macOS และ Linux:
curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash
Windows พร้อมขั้นตอนที่โครงการแนะนำ แทนที่จะเป็นคำสั่งบรรทัดเดียวแบบสุ่มสี่สุ่มห้า:
Invoke-WebRequest -Uri https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.ps1 -OutFile install.ps1
notepad install.ps1 # read it first
Unblock-File .\install.ps1
.\install.ps1
ตัวเลือกต่างๆ รวมถึง `--skip-config` สำหรับไบนารีอย่างเดียวโดยไม่มีการตั้งค่าเอเจนต์ และ `--dir=<path>` สำหรับตำแหน่งที่กำหนดเอง ตัวติดตั้งจะตรวจจับเอเจนต์เขียนโค้ดที่ติดตั้งโดยอัตโนมัติ และเขียนรายการ MCP ที่ระบุไว้ พร้อมคำแนะนำ, ทักษะ, และ lifecycle hooks ในกรณีที่ไคลเอนต์รองรับ บน macOS มันจะลบคุณสมบัติ quarantine และเซ็นชื่อไบนารีแบบ ad-hoc ดังนั้นจึงไม่จำเป็นต้องทำงาน `xattr` หรือ `codesign` ด้วยตนเอง
จากนั้นรีสตาร์ทเอเจนต์ของคุณและสั่งให้มันทำดัชนีโปรเจกต์
สองแฟล็กการกำหนดค่าที่ควรตั้งค่าตั้งแต่วันแรก:
# index new projects automatically on first connection
codebase-memory-mcp config set auto_index true
codebase-memory-mcp config set auto_index_limit 50000
# graph visualization, built into the binary
codebase-memory-mcp --ui=true --port=9749
UI ที่ `localhost:9749` แสดงกราฟความรู้ในรูปแบบ 3 มิติ มันมีประโยชน์อย่างแท้จริงในการมองเห็นโครงสร้างที่คุณไม่รู้ว่ามีอยู่ และยังเป็นการตรวจสอบความถูกต้องที่ดีว่าดัชนีครอบคลุมสิ่งที่คุณคาดหวังไว้
หากคุณทำงานกับ repository หลายแห่ง, `auto_watch false` จะป้องกันไม่ให้เซสชันลงทะเบียนโปรเจกต์กับตัวเฝ้าระวังเบื้องหลัง (background watcher) และ `watcher_enabled false` จะปิดเธรดการสำรวจ (poll thread) ทั้งหมด ตัวเลือกหลังนี้จะถูกอ่านเพียงครั้งเดียวเมื่อ daemon เริ่มทำงาน ดังนั้นให้หยุด daemon หลังจากเปลี่ยนค่าแล้ว
สองสิ่งที่ควรตรวจสอบก่อนที่คุณจะรันมัน
ทั้งสองสิ่งนี้มีการจัดทำเอกสารโดยโครงการ ซึ่งเป็นสัญญาณที่ดี และทั้งคู่สมควรได้รับการพิจารณาเป็นเวลาสามสิบวินาทีของคุณ
Microsoft Defender อาจแจ้งเตือนไบนารีที่เผยแพร่ ว่าเป็น `Trojan:Script/Wacatac.B!ml` โครงการระบุว่านี่เป็นผลบวกลวง (false positive) ที่ทราบกันดี โดยระบุว่าปกติแล้ว 61 จากประมาณ 62 เอ็นจินจะรายงานว่าสะอาด และชี้ให้เห็นว่าครอบครัวการตรวจจับเดียวกันนี้ยังส่งผลกระทบต่อ GitHub CLI, llama.cpp, Godot, และ Go toolchain ของ Microsoft เอง ทุกการเผยแพร่จะถูกสแกนบน VirusTotal ก่อนการตีพิมพ์ และบันทึกการเผยแพร่จะเชื่อมโยงไปยังผลลัพธ์ นี่เป็นท่าทีที่โปร่งใสกว่าโครงการส่วนใหญ่ และปัญหาพื้นฐานคือปัญหา heuristic ที่รู้จักกันดีกับไบนารี native ขนาดเล็กที่ไม่มีการเซ็นชื่อ
มันอ่านโค้ดเบสของคุณและเขียนลงในไฟล์การกำหนดค่าเอเจนต์ของคุณ นั่นคืองานของมัน และโครงการระบุไว้อย่างชัดเจนแทนที่จะปกปิด มาตรการบรรเทาสถานการณ์เป็นของจริง: ซอร์สโค้ดฉบับเต็มมีให้ภายใต้ลิขสิทธิ์ MIT, การเผยแพร่มี OpenSSF Scorecard และ SLSA level 3 provenance, และการประมวลผลเป็นแบบ local ทั้งหมด โครงการยังระบุด้วยว่ามันไม่ได้ทำการร้องขอเครือข่ายด้วยตัวเอง, ไม่ตรวจสอบการอัปเดตในเบื้องหลัง, และไม่โทรกลับบ้าน (phone home) การอัปเดตทำงานจากสคริปต์การติดตั้งที่วางอยู่ข้างไบนารี แทนที่จะมาจากภายในกระบวนการที่กำลังทำงาน ซึ่งเป็นทางเลือกการออกแบบโดยเจตนาที่อธิบายไว้อย่างละเอียดใน README
การตอบสนองที่ถูกต้องต่อทั้งสองสิ่งนี้เหมือนกัน: อ่านสคริปต์การติดตั้งก่อนที่คุณจะส่งไปยัง bash และตรวจสอบการอ้างสิทธิ์ว่าเป็น local-only ด้วยตัวคุณเองหากสิ่งนี้มีความสำคัญสำหรับคุณ จำนวนดาวที่มากคือความนิยม ไม่ใช่การตรวจสอบ
ทำไมสิ่งนี้ถึงเป็นสิ่งที่ควรติดตั้งเป็นอันดับแรก
เครื่องมืออื่นๆ ในกระแสเอเจนต์ปัจจุบันล้วนเปลี่ยนแปลงขั้นตอนการทำงานของคุณ บุคลิกเปลี่ยนวิธีการที่คุณสั่งงาน worktrees แบบขนานเปลี่ยนวิธีการจัดระเบียบงานของคุณ การเข้าถึงเว็บเปลี่ยนสิ่งที่คุณร้องขอ
สิ่งนี้ไม่เปลี่ยนแปลงวิธีการทำงานของคุณ และทำให้ทุกเซสชันมีค่าใช้จ่ายถูกลงและดีขึ้น ไม่มีนิสัยใหม่ที่ต้องเรียนรู้ คุณติดตั้งมัน, ทำดัชนีโปรเจกต์, และเอเจนต์ของคุณก็จะหยุดใช้บริบทไปกับการค้นหาแบบวนซ้ำ (grep loops) ในการปรับโครงสร้างโค้ด (refactor) ครั้งใหญ่ ความแตกต่างระหว่างการถึงขีดจำกัดตอนบ่ายสองโมงกับการทำงานเสร็จในวันนั้นไม่ใช่เรื่องเล็กน้อย
ผลกระทบด้านคุณภาพคือครึ่งหนึ่งที่ถูกประเมินค่าต่ำไป เอเจนต์ที่ใช้โทเค็น 400,000 โทเค็นในการอ่านไฟล์จะมีพื้นที่ในการคิดเกี่ยวกับปัญหาของคุณน้อยลงมาก และความสามารถในการเรียกคืนสิ่งที่อ่านไปในช่วงต้นเซสชันก็จะลดลง การตอบจากกราฟช่วยให้บริบทว่าง พลวัตเดียวกันนี้ใช้ได้กับสิ่งที่เครื่องมือของคุณส่งคืนเข้าสู่บริบทนั้น ซึ่งเป็นหัวข้อของ หน้าต่างบริบทการตอบสนองเครื่องมือเอเจนต์ และเป็นความล้มเหลวเดียวกันที่ทำให้การตอบสนอง API ที่ใหญ่เกินไปมีค่าใช้จ่ายสูงในขั้นตอนการทำงานของเอเจนต์
เครื่องมือที่คุณจะได้ใช้จริง
เครื่องมือ MCP สิบห้าตัวดูเหมือนเป็นจำนวนมากที่ต้องเรียนรู้ ในทางปฏิบัติคุณไม่จำเป็นต้องเรียนรู้เครื่องมือเหล่านี้เลย เพราะเอเจนต์จะเป็นผู้เลือกใช้เอง สิ่งที่ควรทราบคือคำถามใดบ้างที่ตอนนี้สามารถตอบได้ในราคาถูก ดังนั้นคุณควรเริ่มถามคำถามเหล่านั้น
การวิเคราะห์ผลกระทบ (Impact analysis) เป็นเครื่องมือที่มีมูลค่าสูงสุดและมีการใช้งานน้อยที่สุด ก่อนเปลี่ยน signature ของฟังก์ชัน ลองถามดูว่าอะไรจะพัง กราฟจะติดตามผู้เรียกใช้ทั้งหมดใน repository ภายในไม่ถึงหนึ่งมิลลิวินาที ในขณะที่เวอร์ชัน grep จะพลาดการ dispatch แบบ dynamic และยอมแพ้กับสิ่งที่ไม่ใช่โดยตรง สิ่งนี้เปลี่ยนความคิดที่ว่า “ฉันคิดว่ามันปลอดภัย” ให้กลายเป็นรายการ
การติดตามสายการเรียกใช้ (Call-chain tracing) ตอบคำถามว่าการทำงานจริงไปถึงส่วนของโค้ดได้อย่างไร มีประโยชน์ใน repository ที่ไม่คุ้นเคย และดีกว่าการอ่านย้อนขึ้นไปผ่านห้าไฟล์เพื่อหวังว่าจะหาจุดเริ่มต้น
ภาพรวมสถาปัตยกรรม (Architecture overview) ให้แผนที่โครงสร้างโดยที่เอเจนต์ไม่จำเป็นต้องอ่านทั้ง tree นี่คือสิ่งที่ทำให้การเริ่มต้นกับ codebase ที่ไม่รู้จักรู้สึกแตกต่างออกไป และเข้ากันได้ดีกับบุคลิกที่เน้นการสำรวจแบบอ่านอย่างเดียว
การตรวจจับโค้ดที่ไม่ได้ใช้ (Dead code detection) พบสิ่งที่ไม่มีใครเรียกใช้ รันมันก่อนที่จะทำการคลีนอัพ แทนที่จะมานั่งถกเถียงกัน
การเชื่อมโยง HTTP ข้ามบริการ (Cross-service HTTP linking) ติดตามการเรียกใช้ในบริการหนึ่งไปยัง handler ในอีกบริการหนึ่ง ในโค้ดเบสแบบไมโครเซอร์วิส นี่คือความแตกต่างระหว่างเอเจนต์ที่เข้าใจเพียง repository เดียวกับเอเจนต์ที่เข้าใจระบบทั้งหมด และนี่คือจุดที่ช่องว่างของสัญญา (contract gap) ที่จะกล่าวถึงด้านล่างปรากฏขึ้น
การค้นหาด้วย Cypher (Cypher queries) คือช่องทางสำรอง เมื่อคุณต้องการบางอย่างที่เฉพาะเจาะจงซึ่งเครื่องมืออื่นๆ ไม่ครอบคลุม คุณสามารถค้นหากราฟได้โดยตรง
การเปลี่ยนแปลงในทางปฏิบัติอยู่ที่วิธีการที่คุณสั่งงาน คำถามที่คุณเคยหลีกเลี่ยงเพราะต้องใช้โทเค็น 50,000 โทเค็นและเวลาสองนาที ตอนนี้แทบจะฟรีแล้ว ดังนั้นจงถามมัน “อะไรเรียกใช้สิ่งนี้?” ก่อนการปรับโครงสร้างโค้ดทุกครั้ง “เส้นทางคำขอสำหรับ endpoint นี้มีลักษณะอย่างไร?” ก่อนการดีบัก เครื่องมือนี้เปลี่ยนเศรษฐศาสตร์ของความอยากรู้ ซึ่งสำคัญกว่าฟีเจอร์ใดๆ
สิ่งที่กราฟรู้ และสิ่งที่ไม่รู้
นี่คือขอบเขต และเป็นขอบเขตที่สำคัญที่ควรทำความเข้าใจก่อนที่คุณจะเชื่อใจเครื่องมือนี้มากเกินไป
กราฟถูกสร้างขึ้นจากโค้ดของคุณ มันรู้ว่าโค้ดของคุณ คืออะไร ในบรรดาเครื่องมือ 15 ตัวนั้น มีการเชื่อมโยง HTTP ข้ามบริการ ซึ่งติดตามการเรียกใช้ในบริการหนึ่งไปยัง handler ในอีกบริการหนึ่ง และนั่นเป็นสิ่งที่มีประโยชน์อย่างแท้จริงที่เอเจนต์ควรทราบ
สิ่งที่ไม่สามารถบอกคุณได้คือสิ่งที่สัญญา ระบุไว้ มันรู้ว่าเส้นทาง `/v1/invoices/{id}` มีอยู่และฟังก์ชันใดที่ให้บริการ มันไม่รู้ว่า endpoint จะส่งคืน 409 พร้อมซองจดหมายข้อผิดพลาดที่แตกต่างกันเมื่อมีการใช้คีย์ idempotency ซ้ำ, ว่าฟิลด์ `status` มีค่าที่ถูกต้องห้าค่าเท่านั้น, ว่า cursor เป็นแบบทึบแสง (opaque) ไม่ใช่ offset, หรือว่าฟิลด์หนึ่งถูกเลิกใช้งานและจะหายไปในไตรมาสหน้า ไม่มีสิ่งใดเลยที่สามารถอนุมานได้จากซอร์สของ handler เพราะส่วนใหญ่เป็นข้อตกลงมากกว่าการนำไปใช้จริง
ดังนั้นเอเจนต์ ซึ่งตอนนี้มีความสามารถในการจดจำโครงสร้างได้อย่างสมบูรณ์แบบ ก็ยังคงต้องเดาสัญญา มันเขียนไคลเอนต์ตามรูปแบบที่อนุมานและทดสอบกับ mock ที่มันสร้างขึ้นเอง และทุกอย่างเป็นสีเขียวจนกว่าจะถึงขั้นตอน staging
นี่คือเหตุผลที่ Apidog และเครื่องมือเช่นนี้เข้ากันได้ดีมากกว่าที่จะทับซ้อนกัน:
- กราฟตอบว่า “อยู่ที่ไหน” handler ใด, สายการเรียกใช้ใด, อะไรจะพังถ้า signature นี้เปลี่ยนไป
- สเปกตอบว่า “อะไร” สกีมาจริง, รหัสสถานะจริง, ซองจดหมายข้อผิดพลาดจริง, อ่านโดยเอเจนต์แทนที่จะสร้างขึ้นใหม่ เหตุผลอยู่ใน การใช้ OpenAPI spec ของคุณเป็นเครื่องมือเอเจนต์
- Mocks สร้างจากสเปก รวมถึง error branches ที่เอเจนต์ไม่เคยคิดจะสร้างขึ้นมาจำลอง
- การทดสอบสัญญา (Contract tests) ล้มเหลวใน CI เมื่อการนำไปใช้และข้อตกลงแตกต่างกัน ซึ่งเป็นรูปแบบความล้มเหลวที่อธิบายไว้ใน จะเกิดอะไรขึ้นเมื่อการเปลี่ยนแปลง API ทำให้เอเจนต์ AI เสียหาย
มีความสมมาตรที่น่าพึงพอใจในเรื่องนี้ codebase-memory-mcp มีอยู่เพราะการอ่านซอร์สโค้ดเพื่อตอบคำถามเชิงโครงสร้างนั้นมีค่าใช้จ่ายสูงและไม่น่าเชื่อถือ เช่นเดียวกันกับการอ่านซอร์สโค้ดเพื่ออนุมานสัญญา และคำตอบก็เหมือนกัน: ทำดัชนีสิ่งนั้นเพียงครั้งเดียว ในรูปแบบที่สร้างขึ้นสำหรับคำถามนั้น ดาวน์โหลด Apidog หากเอเจนต์ของคุณกำลังเขียนไคลเอนต์ API โดยอ้างอิงรูปร่างที่ไม่มีใครบันทึกไว้ ที่เกี่ยวข้อง: การออกแบบสกีมาเครื่องมือ API สำหรับเอเจนต์ และ คุณยังคงต้องการเครื่องมือ API ในยุคของเอเจนต์ AI หรือไม่
ความจำของโค้ดไม่ใช่ความจำของงาน
ขอบเขตที่สองคือเรื่องขององค์กร
ดัชนีจะอยู่ในไดเรกทอรีแคชบนเครื่องเดียว ภายใต้บัญชีเดียว มันถูกแชร์ข้ามเซสชัน Claude Code, Codex, และ OpenCode ของคุณผ่าน daemon ประสานงาน ซึ่งเป็นงานวิศวกรรมที่ดี และมันจะหยุดทำงานที่ขอบเขตของเครื่องนั้น
ที่สำคัญกว่านั้น กราฟคือความจำของโค้ดเบส ไม่ใช่ความจำของงาน มันสามารถบอกคุณได้ว่า retry helper เรียกใช้ไคลเอนต์การชำระเงิน มันไม่สามารถบอกคุณได้ว่าทำไม backoff ถึงเปลี่ยนในเดือนกรกฎาคม, ใครเป็นคนตัดสินใจ, มีทางเลือกอื่นหรือไม่, หรือมีใครได้ทบทวนมันหรือไม่ ประวัตินั้นมีอยู่ในเซสชันเทอร์มินัลที่หายไปแล้ว
ทีมรู้สึกว่านี่เป็นช่องว่างที่แปลก: เอเจนต์มีความสามารถในการเรียกคืนโค้ดได้ดีกว่ามนุษย์คนใดในทีม แต่ไม่มีความสามารถในการเรียกคืนการตัดสินใจที่สร้างมันขึ้นมาเลย
Sharkly ครอบคลุมอีกครึ่งหนึ่งโดยทำให้งานเป็นบันทึกถาวรแทนที่จะเป็นคำสั่ง (prompt):
- งานจะอยู่ในรูปของงาน (tasks) และผลลัพธ์ของเอเจนต์จะปรากฏเป็นความคิดเห็นที่คุณสามารถตอบกลับได้ ความคืบหน้าและการเรียกใช้เครื่องมือจะไหลกลับไปยังงาน การให้เหตุผลจะคงอยู่ตลอดเซสชัน
- เอเจนต์คือการกำหนดค่าที่บันทึกไว้ คำแนะนำ, รันไทม์, ทักษะ, repository, สภาพแวดล้อม การตั้งค่าที่เอเจนต์ของคุณมีดัชนี, สเปก, และสิทธิ์ที่ถูกต้องจะถูกนำกลับมาใช้ใหม่ แทนที่จะต้องสร้างใหม่สำหรับแต่ละเครื่อง
- การประมวลผลคือ 'นำมาเอง' คุณเชื่อมต่อคอมพิวเตอร์ ซึ่งอาจเป็นแล็ปท็อป, เซิร์ฟเวอร์, หรือคอนเทนเนอร์ และ Sharkly จะใช้ Runtime ที่ติดตั้งอยู่แล้วบนนั้น สิ่งนี้เกี่ยวข้องโดยตรงกับเรื่องนี้ เพราะดัชนีเป็นแบบต่อเครื่อง: การรู้ว่าคอมพิวเตอร์เครื่องใดเก็บ repository ที่ถูกทำดัชนีไว้คือความแตกต่างระหว่างกราฟที่พร้อมใช้งาน (warm graph) กับการเริ่มต้นใหม่ที่ใช้เวลาสามนาที (cold start)
- งานของ Repository จะทำงานใน worktree แยกต่างหากสำหรับแต่ละงาน ดังนั้นงานที่ทำงานแบบขนานกับ repo เดียวกันจะไม่ชนกัน
- งานใน Backlog ไม่ได้เริ่มต้นการรัน ดังนั้นงานจะถูกเตรียมไว้ก่อนที่จะมีการดำเนินการใดๆ
- โครงสร้างที่ทีมเข้าใจอยู่แล้ว: พื้นที่ทำงาน, โปรเจกต์, sprint, งาน, พร้อมการซิงค์ Jira
ความจำโค้ดบวกกับความจำงานคือการผสมผสานที่ลงตัว เครื่องมือหนึ่งให้เอเจนต์ของคุณสามารถเรียกคืนข้อมูลจาก repository ได้ อีกเครื่องมือหนึ่งช่วยให้ทีมของคุณสามารถเรียกคืนสิ่งที่เอเจนต์ทำในนั้นได้
คำถามที่พบบ่อย
- มันทำงานร่วมกับ Cursor, Codex, และ OpenCode ได้หรือไม่ หรือแค่ Claude Code เท่านั้น? มันเป็นเซิร์ฟเวอร์ MCP ดังนั้นไคลเอนต์ MCP ใดๆ ก็ทำงานได้ โครงการระบุรายการพื้นผิวเอเจนต์ที่รองรับ 45 รายการ และตัวติดตั้งจะตรวจจับสิ่งที่คุณมีโดยอัตโนมัติ หากคุณกำลังพิจารณาไคลเอนต์เอเจนต์สำหรับงาน API โปรดดู การพิจารณาไคลเอนต์ API ใน Cursor และ Copilot ของเรา
- โค้ดของฉันออกจากเครื่องหรือไม่? ไม่ กระบวนการทั้งหมดเป็นแบบ local และโครงการระบุว่ามันไม่ได้ทำการร้องขอเครือข่ายด้วยตัวเองและไม่ตรวจสอบการอัปเดตในเบื้องหลัง ซอร์สโค้ดเป็นลิขสิทธิ์ MIT หากคุณต้องการตรวจสอบด้วยตัวเองแทนที่จะเชื่อโดยไม่สงสัย
- การลดโทเค็น 99% เป็นไปได้จริงสำหรับ repository ของฉันหรือไม่? ตัวเลข 99.2% มาจากการค้นหาโครงสร้างห้าครั้ง ซึ่งเป็นกรณีที่แข็งแกร่งที่สุดของกราฟ ตัวเลขที่ได้รับการตรวจสอบโดยผู้ทรงคุณวุฒิจาก 31 repository คือโทเค็นน้อยลง 10 เท่า และการเรียกใช้เครื่องมือน้อยลง 2.1 เท่า ให้วางแผนโดยประมาณ 10 เท่า งานที่เน้นคำถามเชิงโครงสร้างจะทำได้ดีกว่านั้น
- มันสามารถจัดการ repository ขนาดใหญ่แค่ไหน? กรณีสูงสุดที่ระบุคือ Linux kernel ที่มี 28 ล้านบรรทัดและ 75,000 ไฟล์ในสามนาที ขีดจำกัดการทำดัชนีอัตโนมัติเริ่มต้นสามารถกำหนดค่าได้ที่ 50,000 ไฟล์ repository ของแอปพลิเคชันทั่วไปจะถูกทำดัชนีในหน่วยมิลลิวินาที
- ทำไม Defender ถึงแจ้งเตือน? เป็นผลบวกลวง (false positive) ที่รู้จักกันดีของ machine learning สำหรับไบนารี native ขนาดเล็กที่ไม่มีการเซ็นชื่อ โครงการได้จัดทำเอกสารไว้ ระบุว่า 61 จากประมาณ 62 เอ็นจินรายงานว่าสะอาด และเชื่อมโยงผลลัพธ์ VirusTotal ในแต่ละการเผยแพร่ ครอบครัวการตรวจจับเดียวกันนี้ยังกระทบ GitHub CLI และ Go toolchain ของ Microsoft เอง
- สิ่งนี้ใช้แทนการอ่านโค้ดได้หรือไม่? สำหรับคำถามเชิงโครงสร้าง ใช่ และนั่นคือส่วนใหญ่ที่เอเจนต์ถาม สำหรับพฤติกรรม, กรณีขอบ (edge cases), และความตั้งใจ, ไม่ และสำหรับสิ่งที่ API ส่งคืน คุณจำเป็นต้องมีข้อกำหนดเฉพาะ (specification) มากกว่าสิ่งใดสิ่งหนึ่ง ซึ่งเป็นข้อโต้แย้งใน คุณยังคงต้องการเครื่องมือ API ในยุคของเอเจนต์ AI หรือไม่
สรุป
นี่คือเครื่องมือที่ดูไม่หวือหวาที่สุดในกระแสเอเจนต์ปี 2026 แต่ให้ผลตอบแทนที่ดีที่สุด ไม่มีการเปลี่ยนแปลงขั้นตอนการทำงาน, ไม่มีนิสัยใหม่, เป็นไบนารี native เพียงตัวเดียว, และลดโทเค็นที่เอเจนต์ของคุณใช้ในการตอบคำถามที่ไม่ควรจะต้องค้นหาแบบ grep ลงได้เป็นอย่างมาก และยังให้ผลตอบแทนสูงสุดเมื่อมีเอเจนต์หลายตัวทำงานพร้อมกัน ซึ่งเป็นกรณีของ Orca ติดตั้งมัน, ทำดัชนีโปรเจกต์ของคุณ, ตั้งค่า `auto_index`, และเปิดโปรแกรมดูกราฟหนึ่งครั้งเพื่อดูว่ามันสร้างอะไรขึ้นมา
จากนั้นให้ชัดเจนเกี่ยวกับขอบเขตสองประการ กราฟรู้ว่าโค้ดของคุณอยู่ที่ไหน ไม่ใช่สิ่งที่ API ของคุณสัญญาไว้ และช่องว่างนั้นคือสิ่งที่ Apidog ปิดช่องว่างด้วยสเปก, mock, และชุดทดสอบ และมันจดจำ repository ไม่ใช่งาน ซึ่งเป็นสิ่งที่ Sharkly ปิดช่องว่างโดยการทำให้งานเป็นบันทึกแทนที่จะเป็นคำสั่ง
การจดจำโค้ดได้อย่างสมบูรณ์แบบเป็นรากฐานที่แข็งแกร่ง มันไม่เหมือนกับการรู้ว่าอะไรคือความจริงหรือสิ่งที่ถูกตัดสินใจไปแล้ว