# Octocode: เครื่องมือเพิ่มประสิทธิภาพนักพัฒนาที่มาแทน grep สำหรับเรา

> เครื่องมือค้นหาโค้ดเชิงความหมาย เครื่องมือ MCP และเครื่องมือเพิ่มประสิทธิภาพนักพัฒนาที่ขับเคลื่อนด้วย AI รวมอยู่ใน Rust binary เดียว เราสร้างมันขึ้นมาได้อย่างไร และทำไมเราใช้มันทุกวัน

คุณเพิ่งเข้าร่วมโปรเจกต์ที่มีโค้ด 400,000 บรรทัด กระจายอยู่ใน 12,000 ไฟล์ มีคนขอให้คุณซ่อมขั้นตอนการตรวจสอบตัวตน คุณ `grep -r "auth"` และได้ผลลัพธ์ 847 รายการ ครึ่งหนึ่งเป็นคอมเมนต์ หนึ่งในสามเป็นไฟล์ทดสอบ ไม่มีใครบอกคุณว่า _การตรวจสอบตัวตนทำงานอย่างไรจริง ๆ_

นั่นคือปัญหาที่เราเจอซ้ำแล้วซ้ำเล่า และนั่นคือเหตุผลที่เราสร้าง Octocode

Octocode คือเครื่องมือเพิ่มประสิทธิภาพนักพัฒนาที่สร้างด้วย Rust — การค้นหาโค้ดเชิงความหมาย เซิร์ฟเวอร์ MCP และชุดเครื่องมือที่ขับเคลื่อนด้วย AI ในไบนารีเดียว คุณถามมันว่า "การตรวจสอบตัวตนของผู้ใช้ทำงานอย่างไร?" เป็นภาษาอังกฤษธรรมดา และมันจะส่งคืนไฟล์ 3-5 ไฟล์ที่สำคัญจริง ๆ พร้อมบริบทว่าเชื่อมต่อกันอย่างไร มันทำงานบนเครื่องของคุณ ใช้งานเป็นเครื่องมือ MCP สำหรับ Claude และ Cursor และเปลี่ยน codebase ของคุณให้เป็นกราฟความรู้ที่ค้นหาได้

เราใช้มันทุกวัน มันคือเครื่องมือที่อยู่เบื้องหลังการที่ [Octomind](https://octomind.run) — รันไทม์เอเจนต์ AI ของเรา — ถูกสร้างและส่งมอบอย่างรวดเร็วโดยทีมเพียงสองคน มันคืออาวุธลับของเรา และมันเป็นโอเพนซอร์ส

เราเพิ่งปล่อย v0.13.0 พร้อมการค้นหา commit, diff ที่ขับเคลื่อนด้วย AI, การปล่อยรุ่นอัตโนมัติ, การอธิบายโค้ด และการบีบอัดเวกเตอร์ด้วย RaBitQ นี่คือภาพรวมทั้งหมด

## ความเจ็บปวดที่เริ่มต้นทุกอย่าง

เราสร้างซอฟต์แวร์เยอะมาก หลาย repo หลายภาษา โปรเจกต์ที่ย้อนหลังไปหลายปี ปัญหาไม่ใช่การเขียนโค้ด — แต่คือการหาโค้ด การเข้าใจว่ามีอะไรอยู่แล้วก่อนที่จะเขียนสิ่งใหม่

`grep` เร็วแต่โง่ มันหาสตริง ไม่ใช่ความหมาย การค้นหาของ GitHub ช้าและจำกัดเฉพาะ repo สาธารณะ ChatGPT สูญเสียบริบทหลังผ่านโทเค็น 128K ทุกครั้งที่เราเข้ามาทำโปรเจกต์เก่า เราเผาไปเป็นชั่วโมงในการอ่านไฟล์ซ้ำที่เราเคยอ่านไปเมื่อหกเดือนก่อน

คำถามนั้นง่าย: ถ้าการค้นหาโค้ดทำงานในแบบที่สมองของคุณทำงานล่ะ? คุณไม่ได้คิดว่า "หาสตริง `authenticate` ให้ฉัน" — คุณคิดว่า "การล็อกอินทำงานอย่างไร?" เครื่องมือควรเข้าใจความแตกต่างนั้น

เราจึงสร้างมันขึ้นมา

![grep vs การค้นหา octocode](/blog/octocode-semantic-code-search/grep-vs-semantic.svg)

## Octocode ทำอะไรบ้าง

ที่แก่นแล้ว Octocode ทำสี่อย่าง:

**1. การค้นหาเชิงความหมาย** — ถามคำถามเป็นภาษาอังกฤษธรรมชาติ มันแปลงคำค้นของคุณเป็น vector embedding เปรียบเทียบกับ embedding ของทุกชิ้นโค้ดในโปรเจกต์ของคุณ และส่งคืนผลลัพธ์ที่เกี่ยวข้องเชิงความหมายมากที่สุด ไม่ใช่การจับคู่คีย์เวิร์ด — แต่เป็นการจับคู่ความหมาย

**2. การวิเคราะห์โครงสร้างโค้ด** — แยก function signature, การกำหนด class และ interface ของ module จากไฟล์หรือ glob pattern ใด ๆ เข้าใจว่าไฟล์ทำอะไรโดยไม่ต้องอ่านทุกบรรทัด

**3. กราฟความรู้ (GraphRAG)** — แมปความสัมพันธ์ระหว่างไฟล์: ใคร import อะไร module ใดเป็น sibling ข้อมูลไหลผ่านระบบอย่างไร ถามว่า "ไฟล์ A เชื่อมต่อกับไฟล์ B อย่างไร?" และได้คำตอบจริง

**4. เครื่องมือนักพัฒนาที่ขับเคลื่อนด้วย AI** — semantic diff, การรีวิวโค้ดอัตโนมัติ, ข้อความ commit ที่ฉลาด, การอธิบาย codebase และการจัดการการปล่อยรุ่นหลายภาษา ไม่ใช่เครื่องมือแยกที่ติดมา — สร้างขึ้นบน engine การ index และค้นหาเดียวกัน

ทั้งหมดนี้เปิดเผยเป็นเซิร์ฟเวอร์ MCP — หมายความว่า Claude, Cursor, Windsurf หรือผู้ช่วย AI ที่รองรับ MCP ใด ๆ สามารถใช้ได้โดยตรง AI ของคุณหยุดเดาเกี่ยวกับ codebase ของคุณและเริ่มรู้จริง ๆ

## เราใช้มันจริง ๆ อย่างไร

ก่อนเจาะลึกฟีเจอร์ — นี่ไม่ใช่เครื่องมือที่เราสร้างแล้วลืม เราใช้ Octocode ทุกวันเพื่อสร้าง [Octomind](https://octomind.run) รันไทม์เอเจนต์ AI ของเรา

นี่คือลักษณะของวันทั่วไปของเรา:

- เช้า: `octocode diff --staged` เพื่อรีวิวสิ่งที่ Ava (ผู้ร่วมงาน AI ของเรา) ส่งมาในช่วงข้ามคืน ไม่ใช่ diff 200 บรรทัด — แต่เป็นสรุปสั้น ๆ ที่ระบุว่า "เพิ่ม retry logic ใน MCP transport layer, refactor การจัดการ error ใน 3 ไฟล์"
- ก่อนทำ PR: `octocode review --staged --focus security` จับสิ่งที่เราอาจพลาด rate limiter ที่ถูกลบโดยไม่ตั้งใจ vectors ของ SQL injection unsafe unwraps ใน Rust
- ตอน commit: `octocode commit` สร้างข้อความจาก diff จริง ไม่มี commit "fix stuff" อีกต่อไป
- การปล่อยรุ่น: `octocode release` อ่านทุก commit ตั้งแต่ tag ล่าสุด ตัดสินใจเรื่องการเพิ่มเวอร์ชัน สร้าง changelog และอัปเดตไฟล์เวอร์ชันใน Cargo.toml, package.json หรืออะไรก็ตามที่โปรเจกต์ของคุณใช้
- ตลอดทั้งวัน: Claude Code ใช้ Octocode เป็นเซิร์ฟเวอร์ MCP เมื่อเราถาม "ไปป์ไลน์ embedding ทำงานอย่างไร?" — Claude ค้นหาในโค้ดจริง อ่านมัน และตอบ ไม่มีการ hallucinate

นี่คือ workflow ที่ทำให้คนสองคนและ AI สามารถส่งมอบงานได้เหมือนทีมขนาดใหญ่กว่ามาก

## CLI: เครื่องมือ AI สำหรับเพิ่มประสิทธิภาพนักพัฒนา

Octocode เริ่มต้นเป็นเครื่องมือ MCP แต่ยิ่งเราใช้มัน เรายิ่งตระหนักว่า: สิ่งนี้ต้องทำงานแบบสแตนด์อโลนด้วย ไม่ใช่ทุกอย่างเกิดขึ้นใน AI chat

### `octocode search` — การค้นหาเชิงความหมายจากเทอร์มินัล

```bash
# คำค้นเดียว
octocode search "how is user authentication implemented"

# Multi-query สำหรับผลลัพธ์ที่ครบถ้วน
octocode search "auth middleware" "JWT token validation" "session management"

# ค้นหาประเภทเนื้อหาที่เฉพาะเจาะจง
octocode search "database migration" --mode code
octocode search "why did we change the API" --mode commits

# ควบคุมรายละเอียดผลลัพธ์
octocode search "auth" --detail-level full
```

Multi-query คือฟีเจอร์ killer ตรงนี้ แทนที่จะใช้การค้นหาเดียวและหวังว่าจะจับได้ทุกอย่าง คุณยิง query ที่เกี่ยวข้อง 3-4 รายการและได้ผลลัพธ์ที่ครอบคลุมภาพรวม engine จะ deduplicate และ rerank ข้าม query ทั้งหมด

ระดับรายละเอียดช่วยให้คุณควบคุมว่าโค้ดกลับมาเท่าใด: `signatures` สำหรับการสแกนอย่างรวดเร็ว `partial` (ค่าเริ่มต้น) สำหรับการตัดอย่างชาญฉลาด หรือ `full` สำหรับทุกอย่าง

### `octocode view` — signature โดยไม่มีเสียงรบกวน

```bash
# ดู function signature ของ Rust ทั้งหมด
octocode view "src/**/*.rs"

# ตรวจสอบ interface ของ module เฉพาะ
octocode view "src/api/*.ts" --md

# หลายภาษาพร้อมกัน
octocode view "**/*.{rs,ts,py}"
```

นี่คือหนึ่งในฟีเจอร์ที่ฟังดูเรียบง่ายแต่ประหยัดเวลาได้จริง คุณกำลังรีวิว PR ที่แตะ 8 ไฟล์ แทนที่จะเปิดแต่ละไฟล์และเลื่อน คุณรัน `octocode view` ด้วย glob และได้ทุก function signature, การกำหนด struct และการส่งออก type ใน output เดียว Markdown mode (`--md`) ทำให้มันเหมาะกับการ paste

เราใช้สิ่งนี้อย่างหนักในเซิร์ฟเวอร์ MCP ด้วย — เมื่อ Claude ต้องเข้าใจ interface ของ module ก่อนแก้ไข `view_signatures` ให้โครงสร้างแก่มันโดยไม่ต้องทิ้งโค้ด 2000 บรรทัด

### `octocode diff` — สรุป ไม่ใช่ patch

นี่เป็นของใหม่ใน v0.13 และมันเปลี่ยนวิธีที่เรารีวิวโค้ดที่ AI สร้าง

```bash
# มีอะไรเปลี่ยนใน staging area ของฉัน?
octocode diff --staged

# มีอะไรเกิดขึ้นระหว่าง branch?
octocode diff main..feature-branch

# โฟกัสที่ประเด็นเฉพาะ
octocode diff --staged --focus security
octocode diff --staged --focus performance
```

นี่คือเหตุผลที่สิ่งนี้สำคัญตอนนี้มากกว่าที่เคย เครื่องมือ AI coding สร้าง diff ขนาดใหญ่ Claude session เดียวอาจแตะ 15 ไฟล์ใน 400 บรรทัด การอ่าน diff ดิบนั้นใช้เวลา 20 นาที `octocode diff` อ่านมันในไม่กี่วินาทีและให้สรุปแก่คุณ: อะไรเปลี่ยน ทำไมมันสำคัญ ต้องจับตาดูอะไร

แฟล็ก `--focus` คม ส่ง `security` และมันจะแฟล็กการ validate ที่ถูกลบ endpoint ที่เปิด secret ที่ hardcode ส่ง `performance` และมันจะไฮไลต์การจัดสรรใหม่ การเรียกที่บล็อก index ที่หายไป เรารันทั้งคู่ก่อนทุกการ merge

### `octocode explain` — เข้าใจอะไรก็ได้

```bash
# อธิบายไฟล์เฉพาะ
octocode explain src/auth/middleware.rs

# อธิบายแนวคิดข้าม codebase
octocode explain "how does the embedding pipeline work"
```

ชี้ไปที่ไฟล์และได้รับการวิเคราะห์ที่มีโครงสร้าง: มันทำอะไร พึ่งพาอะไร อะไรพึ่งพามัน ชี้ไปที่แนวคิด และมันค้นหาเชิงความหมาย จากนั้นสังเคราะห์ผลลัพธ์เป็นคำอธิบาย เยี่ยมสำหรับการ onboarding เข้าสู่ส่วนที่ไม่คุ้นเคยของ codebase

### `octocode review` — จับสิ่งที่มนุษย์มองข้าม

```bash
octocode review --staged
octocode review --focus security --severity high
```

ไม่ใช่ตัวแทนการรีวิวของมนุษย์ แต่มันจับสิ่งที่เราอาจข้ามอย่างสม่ำเสมอ: import ที่ไม่ได้ใช้ การจัดการ error ที่ไม่สอดคล้อง race condition ที่อาจเกิดขึ้น ปัญหาความปลอดภัย ตอนนี้เรารันมันก่อนทุก PR ตัวกรอง severity ช่วยไม่ให้มันส่งเสียงดัง

### `octocode commit` — ข้อความ commit ที่มีความหมาย

```bash
git add .
octocode commit
octocode commit --yes  # ข้ามการยืนยัน
```

วิเคราะห์การเปลี่ยนแปลงที่ staged สร้างข้อความ commit ที่อธิบายสิ่งที่เกิดขึ้นจริง ไม่ใช่ "update files" — แต่เป็นบางอย่างเช่น "refactor: extract embedding batch processing into standalone pipeline with retry logic" สิ่งเล็ก ๆ แต่มันสะสมเมื่อคุณทำ 20 commits ต่อวัน

### `octocode release` — การปล่อยรุ่นหลายภาษาอัตโนมัติ

```bash
octocode release
octocode release --dry-run
octocode release --force-version "2.0.0"
```

อันนี้เป็น sleeper มันอ่านทุก commit ตั้งแต่ git tag ล่าสุด ใช้ LLM เพื่อกำหนดการเพิ่มเวอร์ชันที่ถูกต้อง (patch, minor หรือ major) สร้าง changelog ที่มีโครงสร้าง และอัปเดตไฟล์เวอร์ชัน

ส่วนหลายภาษาสำคัญ: มันจัดการ Cargo.toml (Rust), package.json (Node), composer.json (PHP), pyproject.toml (Python) และ go.mod (Go) ถ้าโปรเจกต์ของคุณใช้หลายภาษา มันอัปเดตทั้งหมด

เราใช้สิ่งนี้สำหรับทุกการปล่อย Octocode เอง [changelog v0.13](https://github.com/Muvon/octocode/blob/master/CHANGELOG.md) — พร้อมฟีเจอร์ การปรับปรุง และการแก้ไขบั๊กที่จัดหมวดหมู่ — ถูกสร้างโดย `octocode release`

### `octocode stats` — ตรวจชีพจรอย่างรวดเร็ว

```bash
octocode stats
octocode stats --format json
```

จำนวนไฟล์ตามภาษา จำนวนบรรทัด สถานะการ index มีประโยชน์สำหรับ dashboard CI หรือเพียงตอบคำถามว่า "โปรเจกต์นี้ใหญ่แค่ไหน?"

## การ index ทำงานอย่างไร

![Octocode indexing pipeline](/blog/octocode-semantic-code-search/pipeline.svg)

เมื่อคุณรัน `octocode index` นี่คือสิ่งที่เกิดขึ้นเบื้องหลัง:

1. **การค้นหาไฟล์** — เดินผ่าน repo เคารพ `.gitignore` และ `.noindex` จัดการ symlink
2. **การ parse AST** — Tree-sitter parse แต่ละไฟล์เป็น abstract syntax tree นี่คือวิธีที่ Octocode เข้าใจโครงสร้างโค้ด — function, class, import, export — ไม่ใช่แค่ text
3. **การทำ chunk** — โค้ดถูกแบ่งเป็น chunk เชิงความหมาย (configurable ค่าเริ่มต้น 2000 ไบต์พร้อม overlap)
4. **Embedding** — แต่ละ chunk ถูกแปลงเป็น vector embedding ผ่านผู้ให้บริการที่คุณเลือก
5. **การจัดเก็บ** — vector ถูกใส่ใน LanceDB พร้อม RaBitQ quantization เป็นทางเลือก (บีบอัด ~32 เท่า)
6. **GraphRAG** — ความสัมพันธ์ระหว่างไฟล์ถูกแยกและจัดเก็บเป็นกราฟความรู้

pipeline ทั้งหมดเป็นแบบ incremental เปลี่ยนไฟล์เดียวและมีเพียงไฟล์นั้นเท่านั้นที่ re-index สลับ branch และ Octocode ติดตามสิ่งที่ต้องอัปเดต นั่นคือ branch-aware delta indexing ใหม่ใน v0.13

### ผู้ให้บริการ embedding

คุณเลือกของคุณเอง:

**คลาวด์** (ต้องการ API key):

- **Voyage AI** — คุณภาพดีที่สุดสำหรับโค้ด 200M token ฟรี/เดือน (ค่าเริ่มต้นของเรา)
- **Jina AI** — code embedding ที่แข็งแกร่ง
- **Google AI** — gemini-embedding-001
- **OpenAI** — text-embedding-3-small/large
- **Together AI** — แบบกระจาย

**บนเครื่อง** (ไม่มี API ไม่มีเครือข่าย):

- **FastEmbed** — เร็วที่สุด 384-dim (macOS)
- **HuggingFace** — CodeBERT, sentence-transformers (macOS)

รายละเอียดหนึ่งที่สำคัญ: Octocode ใช้ **asymmetric retrieval** code embedding และ query embedding ถูกสร้างต่างกันเพราะ "auth ทำงานอย่างไร?" และ `fn authenticate(token: &str)` เกี่ยวข้องเชิงความหมายแต่แตกต่างเชิงโครงสร้าง นี่คือการปรับปรุงความแม่นยำที่สำคัญเมื่อเทียบกับเครื่องมือที่ embed ทุกอย่างแบบเดียวกัน

### RaBitQ quantization (ใหม่ใน v0.13)

vector มีขนาดใหญ่ embedding float32 มิติ 1024 คือ 4KB ต่อ chunk คูณด้วยหลายพัน chunk และพื้นที่จัดเก็บก็เพิ่ม

RaBitQ บีบอัด vector ~32 เท่า โดยสูญเสียคุณภาพน้อยที่สุด สำหรับ codebase ส่วนใหญ่ คุณจะไม่สังเกตเห็นความแตกต่างในคุณภาพการค้นหา แต่ index ของคุณจะลดจาก 100MB เป็น 3MB เรื่องนี้สำคัญเมื่อคุณ index monorepo

```bash
octocode config --quantization true
octocode index --force  # re-index พร้อมการบีบอัด
```

### Contextual retrieval: การปรับปรุง 49%

สิ่งนี้ขึ้นอยู่กับ [งานวิจัย Contextual Retrieval ของ Anthropic](https://www.anthropic.com/news/contextual-retrieval) — เทคนิคที่ลดความล้มเหลวในการ retrieve ลง 49% และ 67% เมื่อรวมกับ reranking เราใช้ทั้งสองอย่างใน Octocode

ปัญหาของ code embedding ดิบ: ฟังก์ชันชื่อ `process()` ไม่มีความหมายใน vector space มัน process การชำระเงิน? parse HTML? บีบอัดภาพ? โมเดล embedding ไม่สามารถบอกได้จากชื่อฟังก์ชันเพียงอย่างเดียว

Octocode แก้ปัญหานี้ในสองระดับ

**ระดับ 1: บริบทโครงสร้าง (เปิดตลอด)** ทุก chunk ได้รับการเพิ่ม path ไฟล์ ภาษา และชื่อ symbol นำหน้าก่อน embed ดังนั้นโมเดล embedding เห็น `# File: src/api/auth.rs / # Language: Rust / # Defines: validate_token, refresh_session` ก่อนโค้ดจริง สิ่งนี้เพียงอย่างเดียวก็เป็นการปรับปรุงที่ใหญ่ — embedding ตอนนี้รู้ว่าโค้ดอยู่ _ที่ไหน_ และกำหนด _อะไร_

**ระดับ 2: คำอธิบายที่ LLM สร้าง (ทางเลือก)** เมื่อเปิดใช้งาน LLM อ่านแต่ละ chunk และเขียนคำอธิบาย 1-2 ประโยคว่ามันทำอะไร prompt ของมันเฉพาะเจาะจง: "เขียนสิ่งที่โค้ดนี้ทำในเงื่อนไขที่นักพัฒนาจะค้นหา" ดังนั้น `process()` กลายเป็น "validate webhook payload ที่เข้ามาจาก Stripe และส่งไปยัง handler การชำระเงินที่ถูกต้อง"

คำอธิบายนี้ถูกเพิ่มก่อน chunk ก่อนการ embed โมเดล embedding ตอนนี้มีทั้งโค้ดและสะพานภาษาธรรมชาติไปยังมัน สะพานนั้นคือสิ่งที่ปิดช่องว่างระหว่างวิธีที่นักพัฒนาค้นหา ("webhook ทำงานอย่างไร?") และวิธีที่โค้ดถูกเขียน (`fn process(payload: &[u8])`)

```bash
octocode config --contextual-descriptions true
octocode config --contextual-model "openrouter:openai/gpt-4o-mini"
octocode index --force
```

มีค่าใช้จ่ายไม่กี่เซนต์ต่อพัน chunk ด้วย gpt-4o-mini สำหรับการก้าวกระโดดของคุณภาพการค้นหา มันเป็นเรื่องง่าย

### Reranking: ความแม่นยำหลังการ recall

การค้นหาแบบ vector ดีในเรื่อง recall — การหาเอกสารที่ถูกต้องในกองหญ้า แต่การจัดอันดับผลลัพธ์เหล่านั้นอย่างแม่นยำ? นั่นคือที่ที่มันเริ่มคลุมเครือ ผลลัพธ์สองรายการที่ความคล้ายคลึง 0.82 และ 0.79 อาจอยู่ในลำดับที่ผิด

Octocode ใช้ pipeline การ retrieve สองขั้นตอน อันดับแรก การค้นหา vector ดึงผู้สมัครอันดับต้น (ตาข่ายกว้าง recall สูง) จากนั้น cross-encoder reranker rescore แต่ละผลลัพธ์โดยดูที่คู่ query-document เต็มร่วมกัน ไม่ใช่ embedding แยก — แต่เป็นความสัมพันธ์จริงระหว่างคำถามของคุณและแต่ละ chunk ของโค้ด

[งานวิจัยแสดงให้เห็น](https://app.ailog.fr/en/blog/news/reranking-cross-encoders-study) cross-encoder reranking ปรับปรุงความแม่นยำ RAG ได้สูงสุด 40% ในการทดสอบของเรา มันผลักผลลัพธ์ที่เกี่ยวข้องที่สุดไปยังตำแหน่ง #1 แทนที่จะเป็นตำแหน่ง #3 หรือ #4 อย่างสม่ำเสมอ ความแตกต่างระหว่าง "มีประโยชน์" และ "ตรงกับสิ่งที่คุณต้องการ"

reranker ทำงานผ่าน [octolib](https://github.com/Muvon/octolib) และรองรับผู้ให้บริการหลายราย มันเพิ่มมิลลิวินาทีไม่กี่ตัวให้กับ latency การค้นหา มองไม่เห็นสำหรับมนุษย์ มองไม่เห็นสำหรับไคลเอนต์ MCP

```bash
# Reranking เปิดใช้งานโดยค่าเริ่มต้นเมื่อมีการกำหนดค่าผู้ให้บริการ
octocode config --show  # ตรวจสอบการตั้งค่า reranker
```

รวมกับคำอธิบายเชิงบริบท สิ่งนี้ทำให้ Octocode มี pipeline การ retrieve ที่ใกล้เคียงกับระบบ RAG ระดับ state-of-the-art มากกว่าเครื่องมือค้นหาโค้ดแบบดั้งเดิม

## GraphRAG: กราฟความรู้

นี่คือฟีเจอร์ที่แยก Octocode ออกจาก "semantic grep"

เมื่อคุณเปิดใช้ GraphRAG Octocode สร้างกราฟที่แต่ละไฟล์เป็น node และแต่ละความสัมพันธ์เป็น edge ความสัมพันธ์รวมถึง:

- **imports** — ไฟล์ A import จากไฟล์ B
- **sibling_module** — ไฟล์ใน directory เดียวกัน
- **parent/child_module** — ลำดับชั้น directory

แต่ละ node เก็บ: path ไฟล์ คำอธิบายที่ AI สร้าง symbol ที่แยก รายการ import/export และ vector embedding

คุณทำอะไรกับสิ่งนี้ได้บ้าง?

```bash
# หาไฟล์ทั้งหมดที่เกี่ยวข้องกับการตรวจสอบตัวตน
octocode graphrag search --query "authentication system"

# ติดตามว่าไฟล์สองไฟล์เชื่อมต่อกันอย่างไร
octocode graphrag find-path --source-id src/api/auth.rs --target-id src/db/users.rs

# รับรายละเอียดเต็มของบทบาทของไฟล์
octocode graphrag get-node --node-id src/api/auth.rs

# ดู dependencies ทั้งหมดของไฟล์
octocode graphrag get-relationships --node-id src/api/auth.rs

# ภาพรวมระดับสูงของ codebase
octocode graphrag overview
```

คำสั่ง `find-path` ได้รับการประเมินค่าต่ำเกินไป "module auth เชื่อมต่อกับฐานข้อมูลอย่างไร?" ในโปรเจกต์ใหญ่ path นั้นอาจไปผ่าน 4-5 module ตัวกลางที่คุณไม่รู้ว่ามีอยู่ GraphRAG หาเจอ

การ resolve import ทำงานข้ามภาษาด้วย — Rust `use`, Python `import`, TypeScript `import/require`, Go `package`, PHP `use` — ทั้งหมดถูกแมปไปยัง path ไฟล์จริง

## เครื่องมือ MCP: ให้ตา AI มองเข้าไปในโค้ดของคุณ

นี่คือที่ที่ Octocode เปลี่ยนวิธีการทำงานของคุณกับผู้ช่วย AI

Claude, Cursor และ Windsurf รองรับ MCP ทั้งหมด เมื่อคุณเชื่อมต่อ Octocode เป็นเซิร์ฟเวอร์ MCP ผู้ช่วย AI ของคุณได้รับเครื่องมือสามอย่าง:

| เครื่องมือ        | มันทำอะไร                                           |
| ----------------- | --------------------------------------------------- |
| `semantic_search` | ค้นหาโค้ด เอกสาร text หรือ commit ตามความหมาย       |
| `view_signatures` | แยกโครงสร้างจากไฟล์ที่ตรงกับ glob pattern           |
| `graphrag`        | query กราฟความรู้สำหรับความสัมพันธ์และ dependencies |

### การติดตั้ง

เพิ่มในการกำหนดค่า Claude Desktop หรือ Cursor ของคุณ:

```json
{
	"mcpServers": {
		"octocode": {
			"command": "octocode",
			"args": ["mcp", "--path", "/your/project"]
		}
	}
}
```

แค่นั้นเอง ตอนนี้เมื่อคุณถาม Claude ว่า "การชำระเงินทำงานอย่างไร?" — มันไม่ hallucinate มันเรียก `semantic_search` อ่านโค้ดจริง และให้คำตอบที่อิงตาม codebase ของคุณ

### ด้วยการรวม LSP

```bash
octocode mcp --with-lsp "rust-analyzer"
```

สิ่งนี้เพิ่มเครื่องมืออีก 6 อย่าง: `goto_definition`, `hover`, `find_references`, `completion`, `document_symbols`, `workspace_symbols` AI ของคุณสามารถเคลื่อนที่ผ่านโค้ดในแบบที่ IDE ของคุณทำ — แต่แบบโปรแกรม

### Multi-repo proxy

ทำงานข้าม repo หลายตัว? MCP proxy ค้นพบ git repository ใน directory โดยอัตโนมัติและให้บริการผ่าน HTTP endpoint เดียว:

```bash
octocode mcp-proxy --bind 127.0.0.1:8080 --path /workspace
```

## ประสิทธิภาพ

ตัวเลขสำคัญกว่าคำกล่าวอ้าง นี่คือสิ่งที่เราเห็นในโปรเจกต์จริง:

| Metric                  | เล็ก (<1K ไฟล์)  | กลาง (1-10K)   | ใหญ่ (10K+)    |
| ----------------------- | ---------------- | -------------- | -------------- |
| ความเร็วการ index       | 500+ ไฟล์/วินาที | 200-400/วินาที | 100-200/วินาที |
| latency การค้นหา        | <50ms            | <100ms         | <200ms         |
| หน่วยความจำ             | 50-100MB         | 100-500MB      | 500MB-2GB      |
| พื้นที่จัดเก็บ (RaBitQ) | ~300KB           | ~3MB           | ~30MB          |

latency การค้นหาคือสิ่งที่สำคัญสำหรับ MCP เมื่อ Claude เรียก `semantic_search` คุณไม่อยากรอ 5 วินาที ต่ำกว่า 100ms หมายความว่า AI รู้สึกทันที

การ index เป็นครั้งเดียว (บวกการอัปเดตแบบ incremental) แม้แต่โปรเจกต์ 10K ไฟล์ก็ index ในเวลาน้อยกว่าหนึ่งนาที

## 14 ภาษา หนึ่งเครื่องมือ

Octocode ใช้ Tree-sitter ในการ parse ซึ่งหมายถึงการวิเคราะห์ AST จริง — ไม่ใช่ regex hacks ปัจจุบันรองรับ:

Rust, Python, TypeScript, JavaScript, Go, PHP, C++, Ruby, Java, Bash, CSS/SCSS, Lua, Svelte, JSON, Markdown

แต่ละภาษาได้รับการ resolve import ที่เหมาะสม การแยก symbol และการแมปความสัมพันธ์ parser Go เข้าใจการ import package parser Rust รู้เกี่ยวกับ `use` และ `mod` parser TypeScript จัดการ `import` และ `require` นี่ไม่ใช่ขนาดเดียวสำหรับทุกอย่าง — parser ของแต่ละภาษาถูก tune

## มีอะไรเปลี่ยนใน v0.13

นี่คือการปล่อยรุ่นที่ใหญ่ที่สุดของเรา 35 commits นี่คือสิ่งใหม่:

- **การค้นหา commit** — ค้นหาประวัติ git ตามความหมาย พร้อมการ index แบบ lazy-load
- **คำสั่ง AI CLI** — `diff`, `explain`, `stats`, `review`, `commit`, `release`
- **การเสริมบริบทของ chunk** — เทคนิค Contextual Retrieval ของ Anthropic
- **RaBitQ quantization** — บีบอัด vector ~32 เท่า
- **ผู้ให้บริการ embedding OctoHub และ Together AI**
- **Delta indexing แบบ branch-aware** — การอัปเดต incremental ที่ฉลาดขึ้น
- **ย้ายไปยัง rmcp SDK** — การนำไปใช้ Rust MCP อย่างเป็นทางการเพื่อความเสถียร
- **GraphRAG ที่ปรับปรุง** — การ resolve node และการหา path ที่ดีขึ้น
- **แก้ไขบั๊ก 7 รายการ** — git root commit, embedding type, reranking, การนับความสัมพันธ์

เราใช้ Octocode เพื่อสร้าง Octocode ดังนั้นทุกขอบที่ขรุขระจะถูกจับได้อย่างรวดเร็ว

## เริ่มต้นใช้งาน

### macOS (Homebrew)

```bash
brew install muvon/tap/octocode
```

### Universal install script

```bash
curl -fsSL https://raw.githubusercontent.com/Muvon/octocode/master/install.sh | sh
```

ทำงานบน macOS (Intel + Apple Silicon), Linux (x86_64 + ARM64) และ Windows

### จาก source

```bash
cargo install octocode
```

### การรันครั้งแรก

ตั้งค่าผู้ให้บริการ embedding (Voyage AI ให้ 200M token ฟรี/เดือน):

```bash
export VOYAGE_API_KEY="your-key"
```

Index และค้นหา:

```bash
cd your-project
octocode index
octocode search "how does authentication work"
```

เปิดใช้ GraphRAG:

```bash
octocode config --graphrag-enabled true
octocode index --force
```

เชื่อมต่อกับผู้ช่วย AI ของคุณเป็นเซิร์ฟเวอร์ MCP — ดู [คู่มือการรวม MCP](https://github.com/Muvon/octocode#mcp-integration) สำหรับการกำหนดค่า Claude, Cursor และ Windsurf

## ประเด็นที่แท้จริง

เราสร้าง Octocode เพราะ grep ไม่เข้าใจโค้ด ไม่ใช่ว่ามีอะไรผิดกับ grep — มันทำสิ่งที่มันบอกไว้พอดี แต่ "หาสตริง `auth`" และ "แสดงให้ฉันดูว่าการตรวจสอบตัวตนทำงานอย่างไร" เป็นคำถามที่แตกต่างกันโดยพื้นฐาน

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

เราใช้มันสร้างทุกอย่างที่ Muvon มันคือเครื่องมือที่ทำให้ทีมสองคนเป็นไปได้ และมันฟรี โอเพนซอร์ส Apache 2.0

GitHub stars 260+ 14 ภาษา หนึ่ง Rust binary [ลองใช้ดู](https://github.com/Muvon/octocode)