Archcore MCP Server

ทางการ

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

GitHub

เอกสาร

Archcore CLI

เอเจนต์ AI ของคุณจะหยุดเดาและเริ่มทำตามสถาปัตยกรรมของคุณ

Git จัดส่งโค้ดของคุณ CI/CD จัดส่งการส่งมอบของคุณ Archcore จัดส่งความเข้าใจของคุณ

Archcore จัดเก็บการตัดสินใจ กฎ และข้อตกลงร่วมของคุณไว้ใน Git — เพื่อให้เอเจนต์ AI ของคุณทำตามโดยอัตโนมัติ ทำงานร่วมกับ Claude Code, Cursor, Copilot, Gemini CLI, Codex, OpenCode, Roo Code และ Cline

Archcore มาในรูปแบบ CLI และ เซิร์ฟเวอร์ MCP แบบ stdio ภายในเครื่อง — เอเจนต์การเขียนโค้ดที่เข้ากันได้กับ MCP ทุกตัวสามารถอ่านและเขียนบริบทของ repo ของคุณผ่านเครื่องมือมาตรฐาน ในขณะที่ปลั๊กอิน Claude Code / Cursor จะเพิ่มชั้นเวิร์กโฟลว์ระดับสูงขึ้น

กำลังใช้ Claude Code หรือ Cursor อยู่หรือเปล่า? จับคู่ CLI กับ Archcore Plugin — เอนจินเดียวกัน พร้อมด้วยสกิล คำสั่งเจตนา และการ์ดเรลที่พร้อมใช้งานทันที การใช้ CLI เพียงอย่างเดียวก็ยอดเยี่ยมเช่นกัน — มันทำงานได้กับเอเจนต์อื่นๆ ทุกตัว

ใน 60 วินาที

curl -fsSL https://archcore.ai/install.sh | bash
cd your-project && archcore init

จากนั้นเปิดเอเจนต์ AI ของคุณแล้วพูดว่า:

"เรากำลังใช้ PostgreSQL สำหรับที่เก็บข้อมูลหลัก บันทึกการตัดสินใจนี้"

เสร็จแล้ว ตอนนี้จะมี ADR ที่มีโครงสร้างใน .archcore/ ที่ทุกเซสชันในอนาคต — ในเอเจนต์ใดๆ — สามารถอ่านได้

บน Windows? ใช้ PowerShell: irm https://archcore.ai/install.ps1 | iex สำหรับ WSL, go install และตัวเลือกอื่นๆ ดู วิธีการติดตั้ง หรือ คู่มือการติดตั้งฉบับเต็ม

ลองถาม AI ของคุณแบบนี้

เมื่อ repo ของคุณมีเอกสารไม่กี่ฉบับ เอเจนต์ของคุณก็สามารถใช้มันได้ ลองดู:

"ก่อนที่ฉันจะแตะโมดูล auth มี ADR และกฎอะไรบ้างที่ใช้กับตรงนี้?"

เอเจนต์จะโหลดการตัดสินใจและกฎที่เกี่ยวข้องซึ่งผูกกับพื้นที่นั้นก่อนที่จะแก้ไขโค้ดแม้แต่บรรทัดเดียว

"เพิ่ม API handler ใหม่และทำตามข้อตกลงร่วมของ repo นี้"

เอเจนต์จะแสดงกฎที่ตรงกัน (เช่น "handlers อยู่ใน src/api/handlers/") และวางโค้ดในตำแหน่งที่สถาปัตยกรรมของคุณระบุไว้

"กฎการจัดการข้อผิดพลาดของเราคืออะไร?"

เอเจนต์จะอ่าน error-wrapping.rule.md โดยตรงจาก .archcore/ แทนที่จะเดาจากตัวอย่างไม่กี่ตัวอย่างในโค้ดเบส

ลองสิ่งเหล่านี้ก่อน

พรอมต์เหล่านี้จะบันทึกบริบท ใหม่ — การตัดสินใจ กฎ แผน เหตุการณ์ แต่ละรายการจะสร้างเอกสารที่มีโครงสร้างซึ่งเอเจนต์ (หรือเพื่อนร่วมทีมคนใดก็ตาม) สามารถนำกลับมาใช้ใหม่ได้ในภายหลัง

repo ใหม่? archcore init สร้าง .archcore/ เซิร์ฟเวอร์ MCP ยังทำงานใน repo เปล่าและเปิดเผยเครื่องมือ init_project เพื่อให้เอเจนต์สามารถบูตสแตรปให้คุณได้

"เราตัดสินใจใช้ PostgreSQL แทน MongoDB สำหรับฐานข้อมูลหลักของเรา บันทึกการตัดสินใจนี้"

สร้าง infrastructure/use-postgres.adr.md พร้อมด้วยบริบท การตัดสินใจ ทางเลือกที่พิจารณา และผลที่ตามมา

"เรามีข้อตกลงร่วมของทีม: ห่อข้อผิดพลาดด้วยบริบทโดยใช้ fmt.Errorf และ %w เสมอ ทำให้เป็นกฎ"

สร้าง backend/error-wrapping.rule.md พร้อมด้วยคำแนะนำที่จำเป็น เหตุผล และตัวอย่างโค้ดที่ดี/ไม่ดี

"สัปดาห์ที่แล้วเรามีเหตุการณ์ connection pool exhaustion เนื่องจาก idle connections ไม่ได้ถูก recycle บันทึกสิ่งนี้เพื่อที่เราจะได้ไม่ทำซ้ำ"

สร้าง incidents/connection-pool-exhaustion.cpat.md พร้อมด้วยการวิเคราะห์สาเหตุหลักและขั้นตอนการป้องกัน

"ฉันต้องการ PRD สำหรับฟีเจอร์การแจ้งเตือนผู้ใช้ — push, email digests และการแจ้งเตือนในแอป"

สร้าง notifications/user-notifications.prd.md พร้อมด้วยเป้าหมาย เรื่องราวของผู้ใช้ ข้อกำหนด และเมตริกความสำเร็จ

"สร้างแผนการนำไปใช้สำหรับ PRD การแจ้งเตือนและเชื่อมโยงเข้าด้วยกัน"

สร้าง notifications/notifications-implementation.plan.md จากนั้นเชื่อมโยงกับ PRD ด้วยความสัมพันธ์ implements

หากสิ่งใดข้างต้นตรงใจคุณ ส่วนที่เหลือของ Archcore ก็เป็นแบบเดียวกันมากขึ้น — แค่มีโครงสร้าง

สิ่งที่เปลี่ยนแปลงหลังการติดตั้ง

หากไม่มี Archcore เอเจนต์จะ:

ละเลยสถาปัตยกรรมของคุณ
แหกข้อตกลงร่วมของคุณ
ทำซ้ำตรรกะที่มีอยู่แล้ว
ถกเถียงการตัดสินใจที่ทีมของคุณทำไปแล้วซ้ำอีก
ต้องการให้พูดข้อตกลงร่วมเดิมซ้ำในทุกแชท
สูญเสียความจริงของโปรเจกต์ทันทีที่เซสชันสิ้นสุดลง

ด้วย Archcore การถามแบบเดียวกันจะสร้างโค้ดที่:

อยู่ในตำแหน่งที่สถาปัตยกรรมของคุณระบุไว้
เคารพ ADR, สเปก และกฎที่มีอยู่แล้วใน Git
ทำตามข้อตกลงร่วมของทีมที่โหลดโดยอัตโนมัติเมื่อเริ่มเซสชัน
สะท้อนการตัดสินใจใหม่เป็นการ์ดเรลในอนาคต ไม่ใช่สุสาน markdown

AI ควรทำตามระบบของคุณ ไม่ใช่เดามัน

ใช้ Archcore เมื่อ

เอเจนต์ของคุณเขียนโค้ด แต่ไม่ใช่ในแบบที่ repo นี้คาดหวัง
CLAUDE.md / .cursorrules / AGENTS.md ของคุณขยายและเบี่ยงเบนไปเรื่อยๆ
คุณทำงานกับเอเจนต์ 2+ ตัวหรือเครื่องมือโฮสต์ 2+ ตัว (Claude Code + Cursor + Copilot)
คุณต้องการให้การตัดสินใจ กฎ และสเปกอยู่ใน Git — ไม่ใช่ในการเลื่อนดูแชท

ไม่เหมาะสำหรับ — หน่วยความจำแชท, ไลบรารีพรอมต์, หรือตัวสร้างสเปกเป็นโค้ดแบบครั้งเดียว Archcore เป็นชั้นความจริงของ repo สำหรับเอเจนต์การเขียนโค้ด ไม่ใช่ชุดเครื่องมือวิธีการ

ทำไมไม่ใช้แค่ไฟล์คำสั่ง?

CLAUDE.md, AGENTS.md และคำสั่งของ repository เป็นจุดเริ่มต้นที่มีประโยชน์ แต่มันพังเมื่อทีมของคุณต้องการ:

มากกว่าไฟล์หน่วยความจำแบบแบนหนึ่งไฟล์
ประเภทเอกสารที่มีโครงสร้าง — ADR, กฎ, แผน, เหตุการณ์
บริบทที่ใช้ซ้ำได้ในเครื่องมือ AI หลายตัว
ความรู้โปรเจกต์ที่มีเวอร์ชันที่เติบโตไปพร้อมกับโค้ดเบส
ความสัมพันธ์ระหว่างเอกสาร (แผนที่ นำไปใช้ PRD, RFC ที่ ขยาย ADR)
การเรียนรู้จากเหตุการณ์และเวิร์กโฟลว์ที่เกิดซ้ำซึ่งเอเจนต์สามารถหยิบมาใช้ในภายหลัง

ไฟล์คำสั่งบอกเอเจนต์ว่า คุณต้องการอะไร Archcore บอกเอเจนต์ว่า ระบบของคุณทำงานอย่างไร — เพื่อให้เอเจนต์สามารถทำตามระบบของคุณแทนที่จะเดามัน

เอเจนต์ที่รองรับ

Archcore CLI นั้นเป็นเซิร์ฟเวอร์ MCP แบบ stdio ภายในเครื่อง — นั่นคือพื้นผิวการรวมที่ใช้ร่วมกันสำหรับเอเจนต์ที่เข้ากันได้กับ MCP ทุกตัวในตารางด้านล่าง Hooks เพิ่มบริบทเริ่มต้นเซสชันเชิงรุกในจุดที่เอเจนต์รองรับ

เอเจนต์	Hooks	MCP
Claude Code	ใช่	ใช่
Cursor	ใช่	ใช่
Gemini CLI	ใช่	ใช่
GitHub Copilot	ใช่	ใช่
OpenCode	—	ใช่
Codex CLI	—	ใช่
Roo Code	—	ใช่
Cline	—	ด้วยตนเอง

วิธีการทำงาน

เริ่มต้น repo ของคุณ archcore init สร้าง .archcore/ และติดตั้งการรวมสำหรับเอเจนต์ที่รองรับ
บันทึกบริบทที่คงทน จัดเก็บการตัดสินใจทางสถาปัตยกรรม กฎ แผน เอกสารผลิตภัณฑ์ และการเรียนรู้จากเหตุการณ์เป็นไฟล์ Markdown ที่มีโครงสร้าง
ให้เอเจนต์นำกลับมาใช้ใหม่ Hooks และ MCP ช่วยให้เอเจนต์การเขียนโค้ดของคุณอ่านบริบทที่มีอยู่และสร้างหรืออัปเดตเอกสารระหว่างการทำงานจริง
เก็บไว้ใน Git ตรวจสอบการเปลี่ยนแปลงบริบทเหมือนโค้ด พัฒนามันไปตามกาลเวลา และทำให้พกพาไปใช้กับเครื่องมือต่างๆ ได้

โมเดลทางความคิด

Archcore CLI คือ ตัวคอมไพล์บริบท — มันเปลี่ยนเอกสารที่กระจัดกระจายให้เป็นบริบทที่มีโครงสร้างและเครื่องอ่านได้ MCP และ hooks คือ รันไทม์ — พื้นผิวที่เอเจนต์ใช้เพื่อบริโภคบริบทนั้นระหว่างการทำงานจริง Archcore Plugin สำหรับ Claude Code และ Cursor เป็นรันไทม์ระดับสูงที่สร้างขึ้นบนพื้นฐานนี้

implicit repo knowledge  →  structured context  →  AI-readable system

สิ่งที่อยู่ใน `.archcore/`

.archcore/
├── settings.json
├── .sync-state.json
├── auth/
│   ├── jwt-strategy.adr.md
│   └── auth-redesign.prd.md
├── backend/
│   └── error-wrapping.rule.md
├── incidents/
│   └── connection-pool-exhaustion.cpat.md
└── notifications/
    └── notifications-implementation.plan.md

โครงสร้างเป็น รูปแบบอิสระ — จัดระเบียบเอกสารตามโดเมน ฟีเจอร์ ทีม หรืออะไรก็ตามที่เหมาะกับ repo ของคุณ หมวดหมู่เป็นเสมือนและอนุมานจากประเภทเอกสารในชื่อไฟล์ (slug.type.md)

ใช้ .archcore/ สำหรับ:

การตัดสินใจทางสถาปัตยกรรม
กฎและข้อตกลงร่วมในการเขียนโค้ด
แผนการนำไปใช้
ข้อกำหนดผลิตภัณฑ์
เหตุการณ์และการชันสูตรพลิกศพ
ความรู้เวิร์กโฟลว์ที่ใช้ซ้ำได้

ดูที่ repository ของ Archcore CLI เองสำหรับตัวอย่างการทำงาน: .archcore/ ใน repo นี้

สิ่งที่มาพร้อมในกล่อง

ประเภทเอกสาร 18 ประเภท ครอบคลุมวิสัยทัศน์ ความรู้ และประสบการณ์
ประเภทความสัมพันธ์ 4 ประเภท — related, implements, extends, depends_on
เครื่องมือ MCP 10 อย่าง — list_documents, get_document, create_document, update_document, remove_document, search_documents, init_project รวมถึงการจัดการความสัมพันธ์ (add_relation, remove_relation, list_relations)
พรอมต์หลายเอกสาร 5 รายการ — ติดตาม cascades ที่เรียกใช้เป็นคำสั่ง slash จากเอเจนต์ที่เข้ากันได้กับ MCP
การรวม Hook สำหรับ 4 เอเจนต์ (Claude Code, Cursor, Gemini CLI, GitHub Copilot) และ การรวม MCP สำหรับ 8 เอเจนต์

ประเภทเอกสาร

Archcore จัดระเบียบบริบทออกเป็น 3 ชั้นของความรู้: วิสัยทัศน์ ความรู้ และประสบการณ์

วิสัยทัศน์

ประเภท	ชื่อเต็ม	คำอธิบาย
`prd`	เอกสารข้อกำหนดผลิตภัณฑ์	เป้าหมาย เรื่องราวของผู้ใช้ เกณฑ์การยอมรับ และเมตริกความสำเร็จ
`idea`	ไอเดีย	การบันทึกไอเดียผลิตภัณฑ์หรือเทคนิคแบบเบาๆ สำหรับการสำรวจในอนาคต
`plan`	แผน	รายการงานแบบแบ่งเฟสพร้อมเกณฑ์การยอมรับและการพึ่งพา

Archcore ยังรองรับแทร็กข้อกำหนดเพิ่มเติมอีกสองแทร็กสำหรับทีมที่ต้องการการค้นพบที่มีโครงสร้างหรือการแยกย่อยอย่างเป็นทางการ:

แทร็ก Sources (MRD → BRD → URD) — บันทึกว่า ที่มา ของข้อกำหนดมาจากไหน:

ประเภท	ชื่อเต็ม	คำอธิบาย
`mrd`	เอกสารข้อกำหนดตลาด	ภูมิทัศน์ตลาด, TAM/SAM/SOM, การวิเคราะห์การแข่งขัน และความต้องการของตลาด
`brd`	เอกสารข้อกำหนดทางธุรกิจ	วัตถุประสงค์ทางธุรกิจ, ผู้มีส่วนได้ส่วนเสีย, ROI และกฎทางธุรกิจ
`urd`	เอกสารข้อกำหนดผู้ใช้	บุคลิกผู้ใช้, การเดินทาง, ข้อกำหนดการใช้งาน และเกณฑ์การยอมรับ

แทร็ก ISO/IEC/IEEE 29148:2018 (BRS → StRS → SyRS → SRS) — บันทึกว่า วิธีการ แยกย่อยข้อกำหนด:

ประเภท	ชื่อเต็ม	คำอธิบาย
`brs`	ข้อกำหนดคุณลักษณะทางธุรกิจ	พันธกิจ, เป้าหมาย, วัตถุประสงค์ และแนวคิดการดำเนินงานทางธุรกิจ
`strs`	ข้อกำหนดคุณลักษณะผู้มีส่วนได้ส่วนเสีย	ความต้องการของผู้มีส่วนได้ส่วนเสีย, แนวคิดการดำเนินงาน และข้อกำหนดผู้ใช้
`syrs`	ข้อกำหนดคุณลักษณะของระบบ	ฟังก์ชันของระบบ, อินเทอร์เฟซ, ประสิทธิภาพ และข้อจำกัดในการออกแบบ
`srs`	ข้อกำหนดคุณลักษณะของซอฟต์แวร์	ฟังก์ชันของซอฟต์แวร์, อินเทอร์เฟซภายนอก และสเปกพฤติกรรมโดยละเอียด

ใช้ PRD สำหรับโปรเจกต์ส่วนใหญ่ เพิ่มแทร็ก sources เมื่อคุณต้องการการค้นพบข้อกำหนดที่มีโครงสร้าง เพิ่ม ISO 29148 เมื่อคุณต้องการการตรวจสอบย้อนกลับอย่างเป็นทางการสำหรับระบบที่มีการควบคุมหรือซับซ้อนหลายทีม ผสมผสานได้อย่างอิสระ — บางฟีเจอร์สามารถใช้ PRD ในขณะที่ฟีเจอร์อื่นใช้ cascade เต็มรูปแบบ

ความรู้

ประเภท	ชื่อเต็ม	คำอธิบาย
`adr`	บันทึกการตัดสินใจทางสถาปัตยกรรม	บันทึกการตัดสินใจทางเทคนิคที่สรุปแล้วพร้อมบริบท ทางเลือก และผลที่ตามมา
`rfc`	คำขอความคิดเห็น	เสนอการเปลี่ยนแปลงที่สำคัญซึ่งเปิดให้ทีมตรวจสอบและแสดงความคิดเห็น
`rule`	กฎ	มาตรฐานการเขียนโค้ดหรือกระบวนการพร้อมคำแนะนำที่จำเป็นและตัวอย่าง
`guide`	คู่มือ	คำแนะนำทีละขั้นตอนสำหรับการทำงานเฉพาะให้สำเร็จ
`doc`	เอกสาร	เอกสารอ้างอิง, ทะเบียน และเนื้อหาเชิงพรรณนา
`spec`	ข้อกำหนดคุณลักษณะ	สัญญาเชิงบรรทัดฐานที่เป็นที่ยอมรับสำหรับระบบ, ส่วนประกอบ, อินเทอร์เฟซ หรือโปรโตคอล

ประสบการณ์

ประเภท	ชื่อเต็ม	คำอธิบาย
`task-type`	ประเภทงาน	รายการตรวจสอบและขั้นตอนการทำงานที่ใช้ซ้ำได้สำหรับงานที่เกิดซ้ำ
`cpat`	รูปแบบการเปลี่ยนแปลงโค้ด	การวิเคราะห์สาเหตุหลักของบั๊กหรือเหตุการณ์พร้อมขั้นตอนการป้องกัน

เอกสารแต่ละฉบับเป็นไฟล์ Markdown ที่มี YAML frontmatter:

---
title: "Use PostgreSQL for Primary Storage"
status: draft
tags: [database, infrastructure]
---

## Context

...

สถานะที่ใช้ได้: draft, accepted, และ rejected แท็กเป็นทางเลือกและรูปแบบอิสระ — ใช้เพื่อทำเครื่องหมายหัวข้อที่เกี่ยวข้องกัน (security, golang, frontend)

ความสัมพันธ์ของเอกสาร

เอกสารสามารถเชื่อมโยงกับเอกสารอื่นด้วยความสัมพันธ์แบบมีทิศทาง:

related — ความเกี่ยวข้องทั่วไป
implements — ต้นทางนำสิ่งที่เป้าหมายระบุไปปฏิบัติ
extends — ต้นทางต่อยอดจากเป้าหมาย
depends_on — ต้นทางต้องการเป้าหมายเพื่อดำเนินการต่อ

ความสัมพันธ์ถูกเก็บใน .sync-state.json และจัดการโดยอัตโนมัติโดยเอเจนต์ AI ผ่านเครื่องมือ MCP

การผสานรวมกับเอเจนต์ AI

Archcore ผสานรวมกับเอเจนต์เขียนโค้ด AI ในสามวิธี:

Hooks แทรกบริบทเมื่อเริ่มเซสชัน เพื่อให้เอเจนต์รับรู้เอกสาร .archcore/ ของคุณตั้งแต่ข้อความแรก
เครื่องมือ MCP ให้ความสามารถแก่เอเจนต์ในการแสดงรายการ ค้นหา อ่าน สร้าง อัปเดต และเชื่อมโยงเอกสารแบบเรียลไทม์ เซิร์ฟเวอร์ MCP ยังทำงานในรีโพที่ว่างเปล่าและมีเครื่องมือ init_project เพื่อให้เอเจนต์สามารถบูตสแตรป .archcore/ ได้ด้วยตัวเอง
MCP prompts เป็นขั้นตอนการทำงานหลายเอกสารสำเร็จรูปที่คุณเรียกใช้จากเอเจนต์ของคุณเป็นคำสั่งสแลช

Prompts

Prompts จัดการลำดับเอกสารทั้งหมดในการเรียกครั้งเดียว — เอเจนต์สร้างและเชื่อมโยงทุกเอกสารในแทร็กให้คุณ เอเจนต์ที่เข้ากันได้กับ MCP ส่วนใหญ่แสดงเป็นคำสั่งสแลช (เช่น /architecture_track); คำนำหน้าที่แน่นอนขึ้นอยู่กับไคลเอนต์

Prompt	สิ่งที่ทำ
`product_track`	ไอเดีย → PRD → แผน (ขั้นตอนฟีเจอร์แบบเบา)
`architecture_track`	ADR → สเปค → แผน (การออกแบบทางเทคนิค + การนำไปใช้)
`standard_track`	ADR → กฎ → คู่มือ (กำหนดมาตรฐานทีม)
`sources_track`	MRD → BRD → URD (การค้นพบตลาด / ธุรกิจ / ผู้ใช้)
`iso_track`	BRS → StRS → SyRS → SRS (ลำดับ ISO 29148 อย่างเป็นทางการ)

ตัวอย่าง. ในเอเจนต์ของคุณ รัน /product_track feature="user notifications" เอเจนต์จะร่างไอเดีย สร้าง PRD สร้างแผนการนำไปใช้ และเชื่อมโยงโดยอัตโนมัติ

เซิร์ฟเวอร์ MCP ภายใน

Archcore ไม่ต้องการบริการโฮสต์ CLI รันเซิร์ฟเวอร์ MCP แบบ stdio ภายใน:

archcore mcp

โดยค่าเริ่มต้น archcore mcp ให้บริการเอกสารจากไดเรกทอรีปัจจุบัน ส่ง --project /path/to/repo (หรือตั้งค่า ARCHCORE_PROJECT_ROOT) เพื่อชี้ไปที่อื่น — มีประโยชน์เมื่อเซิร์ฟเวอร์ถูกเปิดจากไดเรกทอรีที่ไม่ใช่พื้นที่ทำงานของคุณ (ตัวอย่างเช่น โดยการผสานรวมของเอดิเตอร์)

เชื่อมต่อเข้ากับ Claude Code:

claude mcp add --transport stdio archcore -- archcore mcp

หรือติดตั้งอัตโนมัติสำหรับเอเจนต์ที่รองรับ:

archcore mcp install --agent cursor

ติดตั้งการผสานรวม

# Auto-detect agents in your project and install everything
archcore hooks install

# Or target a specific agent
archcore mcp install --agent opencode
archcore hooks install --agent cursor

คำสั่ง

คำสั่ง	คำอธิบาย
`archcore init`	เริ่มต้นไดเรกทอรี `.archcore/` แบบโต้ตอบ
`archcore doctor`	ตรวจสอบการตั้งค่า archcore และแก้ไขปัญหา
`archcore status`	ตรวจสอบโครงสร้าง .archcore/ และความสมบูรณ์ของเอกสาร
`archcore config`	ดูหรือแก้ไขการตั้งค่า
`archcore hooks install`	ติดตั้ง hooks สำหรับเอเจนต์ AI ที่ตรวจพบ
`archcore update`	อัปเดต Archcore เป็นเวอร์ชันล่าสุด
`archcore mcp`	รันเซิร์ฟเวอร์ MCP stdio
`archcore mcp install`	ติดตั้งการตั้งค่า MCP สำหรับเอเจนต์ที่ตรวจพบ

อัปเดต

archcore update

คำสั่งตรวจสอบ GitHub Releases สำหรับเวอร์ชันที่ใหม่กว่า ดาวน์โหลด ตรวจสอบ checksum SHA-256 และแทนที่ไบนารีปัจจุบันแบบอะตอมมิก

วิธีการติดตั้ง

macOS / Linux

curl -fsSL https://archcore.ai/install.sh | bash

Windows

irm https://archcore.ai/install.ps1 | iex

ติดตั้ง archcore.exe ภายใต้ %LOCALAPPDATA%\Programs\archcore และเพิ่มลงใน PATH ผู้ใช้ของคุณ เปิดหน้าต่าง PowerShell ใหม่หลังการติดตั้งเพื่อให้การเปลี่ยนแปลง PATH มีผล

Windows (WSL)

ติดตั้ง WSL จากนั้นรันภายใน:

curl -fsSL https://archcore.ai/install.sh | bash

Go install

go install github.com/archcore-ai/cli@latest

จากซอร์ส

git clone https://github.com/archcore-ai/cli.git
cd cli
go build -o archcore .

แพลตฟอร์มที่รองรับ: macOS, Linux, Windows — amd64 และ arm64

สำหรับตัวแปรสภาพแวดล้อม (ARCHCORE_VERSION, ARCHCORE_INSTALL_DIR, GITHUB_TOKEN) และการแก้ไขปัญหา PATH ดู คู่มือการติดตั้งฉบับเต็มบน docs.archcore.ai

การตั้งค่า

การตั้งค่าถูกเก็บใน .archcore/settings.json และสร้างระหว่าง archcore init

ฟิลด์	คำอธิบาย	ค่า
`sync`	โหมดซิงค์ Cloud และ on-prem กำลังจะมาเร็วๆ นี้	`none` (เฉพาะภายใน), `cloud`, `on-prem`
`language`	ภาษาเอกสาร ช่วยให้เอเจนต์สร้างเอกสารในภาษาที่ถูกต้อง	สตริง, ค่าเริ่มต้น `en`

archcore config                              # show all settings
archcore config get <key>                    # get a specific value
archcore config set <key> <value>            # set a value

การพัฒนา

ข้อกำหนดเบื้องต้น

Go 1.24+

บิวด์ & ทดสอบ

# Build
go build -o archcore .

# Run all tests
go test ./...

# Run a specific package
go test ./cmd/

# Run a single test
go test ./cmd/ -run TestConfigCmd

โครงสร้างโปรเจกต์

├── cmd/              # Cobra commands (init, doctor, config, status, hooks, mcp, ...)
├── internal/
│   ├── agents/       # Supported AI agents with hooks/MCP capabilities
│   ├── api/          # HTTP client for archcore server
│   ├── config/       # Settings management and directory init
│   ├── display/      # Terminal output formatting (lipgloss)
│   ├── update/       # Self-update logic (version check, download, verify, replace)
│   ├── mcp/          # MCP stdio server, tools, and prompts
│   └── sync/         # Sync logic
├── templates/        # Document type templates
├── install.sh        # Install script
└── .goreleaser.yaml  # Release configuration

Archcore เหมือนกับ BMAD / Spec Kit / Memory Bank หรือไม่?

ไม่ — สิ่งเหล่านี้แก้ปัญหาที่แตกต่างกัน แผนที่โดยย่อ:

เครื่องมือ	หมวดหมู่	คืออะไร	Archcore แตกต่างอย่างไร
BMAD	วิธีการ	วิธีการ SDLC แบบเอเจนต์ — 12+ บทบาท, 34+ ขั้นตอนการทำงาน	Archcore เก็บ อาร์ติแฟกต์; BMAD กำหนด กระบวนการ
Spec Kit	วิธีการ	ขั้นตอนการทำงานที่ขับเคลื่อนด้วยสเปค: `specify → plan → tasks → implement`, ครั้งเดียว	Spec Kit เป็นการส่งมอบครั้งเดียว; Archcore รักษากราฟที่มีชีวิตซึ่งพัฒนาไปพร้อมกับโค้ดเบส
Agent OS	วิธีการ	การแยกมาตรฐานโค้ดเบส + การพัฒนาที่ขับเคลื่อนด้วยสเปค	ตำแหน่งใกล้เคียงที่สุด Archcore เพิ่มเอกสารที่มีประเภท, ความสัมพันธ์ที่ตรวจสอบแล้ว, และลำดับ ISO ที่เป็นทางเลือก
claude-mem / Mem0	หน่วยความจำ	บันทึกหน่วยความจำเซสชันอัตโนมัติ, การเรียกคืนข้ามเอเจนต์	เครื่องมือหน่วยความจำจำ สิ่งที่คุณทำ; Archcore เก็บ วิธีการสร้างระบบและสิ่งที่ตัดสินใจ
Cline Memory Bank	เอกสาร	ไฟล์ markdown แบบสคีมาคงที่ (`projectbrief`, `activeContext`, `systemPatterns`…)	จิตวิญญาณเดียวกัน, พิธีการน้อยกว่า Archcore เพิ่มความสัมพันธ์ที่มีประเภท, การตรวจสอบ MCP, และลำดับหลายขั้นตอน
CLAUDE.md / .cursorrules	คำสั่ง	ไฟล์แบนเดียวที่เอเจนต์อ่านเมื่อเริ่มเซสชัน	Archcore แทนที่ไฟล์คำสั่งที่เพิ่มขึ้นด้วยเอกสารที่มีประเภท, เกี่ยวข้องกัน, และสอบถามได้

เลือกเครื่องมือวิธีการสำหรับขั้นตอนการพัฒนาที่มีความเห็น เลือกเครื่องมือหน่วยความจำสำหรับความต่อเนื่องของเซสชัน เลือก Archcore เมื่อคุณต้องการ ความจริงของโปรเจกต์ ที่มีประเภทและสอบถามได้ — การตัดสินใจ, กฎ, และสถาปัตยกรรมของ รีโพนี้ — ที่เอเจนต์เขียนโค้ดของคุณเคารพในทุกคำขอ

ลิงก์ & ใบอนุญาต

เอกสาร: docs.archcore.ai
เว็บไซต์: archcore.ai
ปลั๊กอิน (Claude Code, Cursor): github.com/archcore-ai/archcore-plugin
ปัญหา: github.com/archcore-ai/cli/issues
ใบอนุญาต: Apache 2.0