---
url: https://docs.ogmabox.com/th/mcp-setup.md
description: >-
  เชื่อมต่อเอเจนต์ AI กับ Ogma ผ่าน Streamable HTTP หรือ stdio กำหนดสิทธิ์
  และใช้ปลายทางจัดการ MCP ในเครื่อง
---

# การตั้งค่าเซิร์ฟเวอร์ MCP ของ Ogma {#ogma-mcp-server-setup}

เซิร์ฟเวอร์ MCP ของ Ogma (`ogma-mcp`) ช่วยให้ผู้ช่วย AI ที่รองรับตรวจสอบบริบทโครงการได้ และเมื่อเปิดสิทธิ์แล้วสามารถควบคุมเบราว์เซอร์แบบฝัง ส่งคำขอ รันเวิร์กโฟลว์ และรวบรวมหลักฐาน เครื่องมือบันทึกย่อและรายการงานของเซิร์ฟเวอร์เป็นพื้นที่จดข้อมูลในหน่วยความจำของเซสชัน MCP ซึ่งแยกจากหน้า "บันทึกย่อ" ที่จัดเก็บข้อมูลถาวรในแอป

MCP ใช้กับเครื่องมือภายนอก เช่น Codex, Claude Code, Cursor และไคลเอนต์โปรโตคอลบริบทโมเดลอื่น ๆ ไม่ใช่ฟีเจอร์เดียวกับผู้ช่วย AI ในพื้นที่ทำงานภายในแอป

ดูรายการทรัพยากรและเครื่องมือทั้งหมดที่ [ทรัพยากรและเครื่องมือ MCP](./reference/mcp-tools.md)

## เริ่มต้นอย่างรวดเร็ว: แอปเดสก์ท็อป {#quick-start-desktop-app}

1. เริ่ม Ogma และเปิดโครงการที่เอเจนต์ควรตรวจสอบ
2. เปิด **การตั้งค่า > MCP** เลือกสิทธิ์ที่จำเป็น แล้วบันทึก การโต้ตอบกับเบราว์เซอร์ต้องใช้สิทธิ์ **ส่งซ้ำ**
3. คลิก **เริ่ม** และคัดลอกปลายทางที่แสดง ซึ่งโดยทั่วไปคือ `http://127.0.0.1:3000/mcp`
4. เพิ่มปลายทางนี้ในไคลเอนต์ MCP ของคุณเป็นเซิร์ฟเวอร์ **Streamable HTTP**
5. ให้เอเจนต์เรียก `ogma_explain_capabilities` และอ่าน `ogma://project/current` เพื่อตรวจสอบการเชื่อมต่อและโครงการที่ใช้งานอยู่

วิธีนี้ไม่ต้องบิลด์ไบนารีแยก สำหรับการนำทางหน้าเว็บ แบบฟอร์ม เส้นทางเข้าสู่ระบบ และการแก้ไขปัญหา ดู [การทำงานอัตโนมัติของเบราว์เซอร์ด้วย MCP](./guide/mcp-browser.md)

### ที่อยู่สำหรับเชื่อมต่อ {#connection-addresses}

| อินเทอร์เฟซ | ที่อยู่เริ่มต้น | จุดประสงค์ |
| --- | --- | --- |
| การรับส่ง MCP | `http://127.0.0.1:3000/mcp` | ไคลเอนต์ MCP แบบเนทีฟเชื่อมต่อที่นี่ |
| REST API ระบบหลังบ้าน | `http://127.0.0.1:8181` | ค่า `--api-url` ของ MCP แบบแยก และเส้นทางจัดการหรือบริดจ์ด้านล่าง |
| ตัวรับการเชื่อมต่อพร็อกซี | `127.0.0.1:8080` | บันทึกทราฟฟิกเบราว์เซอร์ ไม่ใช่ปลายทาง MCP |

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

ปลายทาง HTTP เก็บสถานะ ให้ไคลเอนต์จัดการการเริ่มต้นและส่วนหัวเซสชัน ไม่มีปลายทาง `/sse` แบบเดิมแยกต่างหาก ไคลเอนต์ที่พัฒนาขึ้นเองควรทำตาม [ข้อกำหนดการรับส่ง](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports) ของ MCP

## ควรใช้ MCP เมื่อใด {#when-to-use-mcp}

ใช้ MCP เมื่อต้องการให้ผู้ช่วยภายนอกช่วยคุณ:

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

ใช้ [AI ในพื้นที่ทำงาน](./guide/workspace-ai.md) หากต้องการหน้าต่างผู้ช่วยแบบฝังภายใน Ogma แทน

## ข้อกำหนดสำหรับการทำงานแบบแยก {#standalone-requirements}

ใช้ stdio เมื่อไคลเอนต์ต้องเริ่มไฟล์ปฏิบัติการในเครื่อง แทนการเชื่อมต่อกับปลายทาง HTTP แบบฝัง

* ระบบหลังบ้านของ Ogma ทำงานที่ที่อยู่ API จริงของตนเอง (ค่าเริ่มต้น CLI: `http://127.0.0.1:8181`)
* ไบนารี `ogma-mcp` (บิลด์จากซอร์ส)

## บิลด์ {#build}

```bash
cargo build --locked --bin ogma-mcp --release
```

ผลลัพธ์เริ่มต้นคือ `target/release/ogma-mcp` (`ogma-mcp.exe` บน Windows) เว้นแต่คุณจะกำหนดไดเรกทอรีเป้าหมายของ Cargo เอง

## เรียกใช้ {#run}

```bash
# Connect to Ogma running on the default port
./ogma-mcp

# Connect to a custom address
./ogma-mcp --api-url http://127.0.0.1:9090

# Use a larger body preview
./ogma-mcp --body-preview-bytes 2048
```

เซิร์ฟเวอร์จะออกจากการทำงานหากเข้าถึง API ของ Ogma ไม่ได้ กำหนดให้ไคลเอนต์ MCP เริ่มคำสั่งนี้ โดย stdout ใช้ส่งข้อความ MCP และ stderr ใช้ส่งข้อมูลวินิจฉัย สิทธิ์ของ stdio มาจากแฟล็กของตนเอง ไม่ใช่การตั้งค่า MCP แบบฝัง

## การค้นหาเครื่องมือ {#tool-discovery}

เซิร์ฟเวอร์ปัจจุบันประกาศรายการเครื่องมือทั้งหมดเสมอ ไม่มีตัวเลือกโปรไฟล์เครื่องมือในการตั้งค่า ค่าเดิม `--tool-profile`, `--mcp-tool-profile` และ `OGMA_MCP_TOOL_PROFILE` ยังรับได้เพื่อความเข้ากันได้ แต่ไม่ซ่อนเครื่องมือหรือให้สิทธิ์

สำหรับรายการขนาดใหญ่ ให้เริ่มด้วย `ogma_explain_capabilities` และ `ogma_find_tools` แทนการเดาอินพุต ค้นหาคำสำคัญของงานเพื่อคัดเครื่องมือ แล้วค้นชื่อเครื่องมือที่ตรงทั้งหมดเพื่อดูข้อกำหนดการใช้งาน ตัวกระจายงานเบราว์เซอร์และการค้นหามีจุดเริ่มต้นที่สะดวก เครื่องมือเฉพาะยังเรียกโดยตรงได้ ดู [การค้นหาเครื่องมือและการกระจายงาน](./reference/mcp-tools.md#tool-discovery-and-dispatch)

## การตั้งค่า MCP ภายในแอป {#in-app-mcp-settings}

Ogma รุ่นที่จัดแพ็กเกจแล้วจัดการ MCP ได้จาก **การตั้งค่า > MCP** ใช้หน้าการตั้งค่าเมื่อต้องการให้ Ogma เริ่มหรือหยุดกระบวนการ MCP แบบฝังสำหรับอินสแตนซ์ที่ใช้งาน

ใช้ไบนารี `ogma-mcp` แบบแยกเมื่อไคลเอนต์ AI ต้องการเริ่มเซิร์ฟเวอร์ MCP โดยตรง

การบันทึกการตั้งค่าจะเริ่มกระบวนการ MCP แบบฝังที่กำลังทำงานใหม่โดยอัตโนมัติ เชื่อมต่อไคลเอนต์ใหม่หลังจากนั้น เพราะ ID เซสชันและโทเค็นยืนยันเดิมใช้ซ้ำไม่ได้ **ข้อมูลวินิจฉัยขณะทำงาน** แสดงผลลัพธ์ล่าสุดจากกระบวนการ

Ogma ยังให้จัดการ MCP ผ่าน REST API ในเครื่อง เส้นทางเหล่านี้อยู่บน **พอร์ต API ระบบหลังบ้าน** ไม่ใช่พอร์ต MCP โดยเฉพาะ หน้าการตั้งค่าและบริดจ์ AI ภายในแอปใช้เส้นทางเหล่านี้:

| ปลายทาง | จุดประสงค์ |
| --- | --- |
| `GET /mcp/status` | คืนค่า `{ running, pid, endpoint, config, diagnostics }` เมื่อหยุดทำงาน `endpoint` เป็น null ข้อมูลวินิจฉัยมีรายการ `{ stream, message }` ล่าสุด |
| `POST /mcp/start` | เริ่ม MCP แบบฝังด้วยการตั้งค่าที่บันทึกไว้และคืนสถานะ ไม่มีเนื้อหาคำขอ คืนข้อผิดพลาดความขัดแย้งหากทำงานอยู่แล้ว |
| `POST /mcp/stop` | หยุดกระบวนการลูกของ MCP แบบฝัง |
| `GET /settings/mcp` | คืนค่าการตั้งค่า MCP ที่บันทึกไว้ |
| `PUT /settings/mcp` | รับออบเจ็กต์การตั้งค่าครบชุด บันทึก และเริ่ม MCP ใหม่หากกำลังทำงาน คืนค่าการตั้งค่าที่รับหรือข้อผิดพลาด อนุญาตให้ผูกเซิร์ฟเวอร์กับโฮสต์ loopback ในเครื่องเท่านั้น |
| `GET /mcp/tools` | คืนค่า `{ tools, config }` รวม `inputSchema` ของแต่ละเครื่องมือ รายการ REST นี้ไม่มีการแบ่งหน้า |
| `POST /mcp/tools/call` | เรียกเครื่องมือหนึ่งตัวด้วย `{ "name": "ogma_explain_capabilities", "arguments": {} }` คืนค่า `{ "result": "..." }` ให้แยกวิเคราะห์ข้อความนั้นเป็นโครงสร้าง JSON ที่ห่อผลลัพธ์ของเครื่องมือ ไม่ใช่ผลลัพธ์ MCP แบบเนทีฟที่มีบล็อกรูปภาพ |

บริดจ์ REST ใช้สิทธิ์ที่บันทึกไว้ แต่ไม่ต้องเริ่มกระบวนการลูก HTTP MCP ที่แยกต่างหาก ใช้เซสชันบริดจ์ร่วมกันหนึ่งเซสชันสำหรับระบบหลังบ้านและการตั้งค่า ควรใช้ MCP แบบเนทีฟหากต้องการแยกเซสชันไคลเอนต์และส่งผลลัพธ์รูปภาพ

เมื่อบริดจ์ล้มเหลว การแยกวิเคราะห์ `result` จะได้ `{ "error": "..." }` ซึ่งมีโครงสร้างข้อผิดพลาดที่แปลงเป็นข้อความแล้ว ตรวจสอบค่านี้แทนการถือว่าสถานะ HTTP สำเร็จหมายถึงเครื่องมือสำเร็จ

การตั้งค่า MCP เริ่มต้นที่บันทึกไว้:

```json
{
  "bind_host": "127.0.0.1",
  "port": 3000,
  "allow_write_findings": false,
  "allow_export_data": false,
  "allow_read_secrets": false,
  "allow_send_requests": false,
  "allow_run_workflows": false,
  "allow_intercept_control": false,
  "tool_profile": "full"
}
```

โฮสต์ที่อนุญาตให้ผูกคือ `127.0.0.1`, `localhost` และ `::1` พอร์ตต้องอยู่ระหว่าง `1024` ถึง `65535` บิลด์นี้ไม่ได้กำหนดการยืนยันตัวตนสำหรับ MCP ที่เปิดให้เข้าถึงผ่านเครือข่าย จึงปฏิเสธที่อยู่ผูกสาธารณะ ฟิลด์เดิม `allow_public_bind` และ `acknowledge_write_tool_risk` ไม่สามารถข้ามข้อจำกัดนี้ได้

## Claude Code {#claude-code}

สำหรับปลายทางเดสก์ท็อปที่กำลังทำงาน:

```bash
claude mcp add --transport http ogma http://127.0.0.1:3000/mcp
```

ใช้ปลายทางที่ Ogma แสดงหากต่างจากตัวอย่าง ดู [การตั้งค่า MCP ของ Claude Code](https://code.claude.com/docs/en/mcp) สำหรับขอบเขตการตั้งค่าและตัวเลือก stdio ตรวจสอบด้วยคำถาม: "Ogma มีโครงการอะไรบ้าง?"

## Cursor {#cursor}

รวมรายการนี้เข้ากับ `.cursor/mcp.json` ของโครงการ หรือ `~/.cursor/mcp.json` ระดับผู้ใช้:

```json
{
  "mcpServers": {
    "ogma": {
      "url": "http://127.0.0.1:3000/mcp"
    }
  }
}
```

เปิดการเชื่อมต่อในการตั้งค่า MCP ของ Cursor ดู [เอกสาร MCP ของ Cursor](https://cursor.com/docs/mcp)

### การตั้งค่าไคลเอนต์ stdio {#stdio-client-configuration}

ไคลเอนต์ที่เริ่มไฟล์ปฏิบัติการใช้รายการเซิร์ฟเวอร์นี้ได้ โดยปรับตำแหน่งไฟล์การตั้งค่าของตนตามความจำเป็น:

```json
{
  "mcpServers": {
    "ogma": {
      "command": "/absolute/path/to/ogma-mcp",
      "args": ["--api-url", "http://127.0.0.1:8181"]
    }
  }
}
```

บน Windows ให้ใช้พาธเต็มของไฟล์ปฏิบัติการและใส่อักขระหลีกให้แบ็กสแลชใน JSON บางไคลเอนต์ต้องมี `"type": "stdio"` ด้วย เพิ่มแฟล็กสิทธิ์ใน `args` ตามความจำเป็น

## สิทธิ์ {#permissions}

ความสามารถที่มีสิทธิ์พิเศษทั้งหกปิดอยู่โดยค่าเริ่มต้น อ่านค่าปัจจุบันได้จาก `ogma://mcp/permissions` เครื่องมือที่อยู่ในรายการยังอาจปฏิเสธการทำงานจนกว่าจะเปิดความสามารถนั้น ตารางแฟล็กและตัวแปรสภาพแวดล้อมทั้งหมดอยู่ใน [เอกสารอ้างอิง CLI](./reference/cli.md#standalone-ogma-mcp-flags)

การโต้ตอบกับเบราว์เซอร์ การจัดการบริบท การสลับโครงการ และการเรียกเส้นทางยืนยันตัวตนทั้งหมดต้องใช้ `--allow-send-requests` การสังเกตเบราว์เซอร์ตรวจสอบเบราว์เซอร์ที่ทำงานอยู่แล้วได้โดยไม่ต้องเปิดเครื่องมือควบคุม `--allow-read-secrets` (หรือ `OGMA_MCP_ALLOW_READ_SECRETS=true`) อนุญาตค่าตัวแปรสภาพแวดล้อมที่ไม่ปิดบังแยกต่างหาก

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

## โหมดอ่านอย่างเดียว {#read-only-mode}

เซิร์ฟเวอร์ MCP เป็นแบบอ่านอย่างเดียวโดยค่าเริ่มต้น การดำเนินการเหล่านี้ใช้ไม่ได้เว้นแต่เปิดอย่างชัดเจน:

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

ตัวอย่างเนื้อหาเริ่มต้นมีขนาด 512 ไบต์ `--body-preview-bytes` ปรับขนาดตัวอย่างและต้องมีค่าอย่างน้อย 1 แต่ไม่ได้จำกัดผลลัพธ์ของทุกเครื่องมือ ใช้ `ogma_get_http_entry_body` สำหรับเนื้อหา HTTP ทั้งหมดหรือการค้นหาเฉพาะในเนื้อหา และ `ogma_get_ws_message` สำหรับข้อความ WebSocket ทั้งหมด

## เครื่องมือเขียนประเด็นที่ตรวจพบ {#finding-write-tools}

หากต้องการเปิดให้ AI ช่วยสร้างประเด็นที่ตรวจพบ ให้เริ่ม ogma-mcp ใหม่พร้อมสิทธิ์เขียน:

```bash
./ogma-mcp --allow-write-findings
```

หรือกำหนดตัวแปรสภาพแวดล้อม:

```bash
OGMA_MCP_ALLOW_WRITE_FINDINGS=true ./ogma-mcp
```

### เครื่องมือเขียนที่ใช้งานได้ {#write-tools-available}

| เครื่องมือ | คำอธิบาย |
|------|-------------|
| `ogma_preview_finding_from_evidence` | ดูตัวอย่างร่างประเด็นที่ตรวจพบจากรายการ HTTP (อ่านอย่างเดียว ใช้งานได้เสมอ) |
| `ogma_create_finding` | สร้างประเด็นที่ตรวจพบพร้อมระดับความรุนแรง สถานะ แท็ก และลิงก์หลักฐาน |
| `ogma_update_finding` | อัปเดตประเด็นที่ตรวจพบที่มีอยู่ |
| `ogma_add_finding_tag` | เพิ่มแท็กให้ประเด็นที่ตรวจพบโดยไม่แทนที่แท็กเดิม |
| `ogma_link_finding_evidence` | เชื่อมรายการ HTTP การลองส่งซ้ำ ผลลัพธ์ระบบอัตโนมัติ หรือข้อความ WS เข้ากับประเด็นที่ตรวจพบ |
| `ogma_delete_finding` | ลบประเด็นที่ตรวจพบหนึ่งรายการ |
| `ogma_export_findings_report` | สร้างรายงาน HTML, Markdown หรือ PDF |

การทำงานปัจจุบันยังใช้สิทธิ์เขียนประเด็นที่ตรวจพบสำหรับเครื่องมือเขียนร่วมกัน เช่น อัปเดตตัวแปรสภาพแวดล้อม เพิ่มคำอธิบายประกอบประวัติ เลือกขอบเขต และเปลี่ยนกฎจับคู่และแทนที่ ดูการดำเนินการเหล่านี้ใน [รายการเครื่องมือ](./reference/mcp-tools.md)

### ตัวอย่าง: ให้ AI ช่วยสร้างประเด็นที่ตรวจพบ {#example-ai-assisted-finding-creation}

เมื่อใช้ `--allow-write-findings`:

1. "วิเคราะห์รายการ HTTP {id} เพื่อหาปัญหาความปลอดภัย หากพบปัญหาจริง ให้ใช้ ogma\_create\_finding เพื่อบันทึกไว้"
2. AI จะเรียก `ogma_get_http_entry` เพื่อตรวจสอบคำขอ
3. หากหลักฐานสนับสนุนประเด็นที่ตรวจพบ จะเรียก `ogma_create_finding` พร้อมเชื่อมหลักฐาน

### สิ่งที่ยังใช้ไม่ได้เมื่อมีเฉพาะสิทธิ์เขียนประเด็นที่ตรวจพบ {#still-not-available-with-finding-writes-only}

* ส่งคำขอซ้ำ
* รันเวิร์กโฟลว์
* สร้างงานส่งออก
* ควบคุมคิวดักรับ
* สลับโครงการ

## เครื่องมือส่งออก {#export-tools}

หากต้องการเปิดให้ AI ช่วยสร้างงานส่งออก ให้เริ่ม ogma-mcp ใหม่พร้อมสิทธิ์ส่งออก:

```bash
./ogma-mcp --allow-export-data
```

หรือกำหนดตัวแปรสภาพแวดล้อม:

```bash
OGMA_MCP_ALLOW_EXPORT_DATA=true ./ogma-mcp
```

### เครื่องมือส่งออกที่ใช้งานได้ {#export-tools-available}

| เครื่องมือ | สิทธิ์ที่ต้องใช้ | คำอธิบาย |
|------|--------------------|-------------|
| `ogma_preview_export_plan` | ไม่มี (อ่านอย่างเดียว) | ดูตัวอย่างสิ่งที่จะรวมไว้ในการส่งออก |
| `ogma_list_export_jobs` | ไม่มี (อ่านอย่างเดียว) | แสดงงานส่งออกล่าสุด |
| `ogma_get_export_job` | ไม่มี (อ่านอย่างเดียว) | ตรวจสอบสถานะงานส่งออก |
| `ogma_get_export_download_info` | ไม่มี (อ่านอย่างเดียว) | รับ URL ดาวน์โหลดสำหรับการส่งออกที่เสร็จแล้ว |
| `ogma_create_export_job` | export\_data | สร้างงานส่งออก |

### ประเภทและรูปแบบส่งออกที่รองรับ {#supported-export-kinds-and-formats}

| ประเภท | คำอธิบาย | รูปแบบ |
|------|-------------|---------|
| `http_history` | คำขอ HTTP ทั้งหมดที่ผ่านพร็อกซี | json, csv, raw\_http |
| `search` | คำขอ HTTP ที่กรองแล้ว | json, csv, raw\_http |
| `findings` | ประเด็นด้านความปลอดภัยที่ตรวจพบ | json, csv |
| `automate_results` | ผลลัพธ์เซสชันระบบอัตโนมัติ | json, csv |

หมายเหตุ: รูปแบบ `raw_http` ใช้ได้เฉพาะประเภท `http_history` และ `search`

### คำเตือนด้านความปลอดภัย {#security-warning}

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

### สิ่งที่ยังใช้ไม่ได้เมื่อมีเฉพาะสิทธิ์ส่งออก {#still-not-available-with-export-permissions-only}

* ลบไฟล์ส่งออก
* เปลี่ยนชื่อไฟล์ส่งออก
* สตรีมเนื้อหาไฟล์ส่งออกผ่าน MCP
* ส่งคำขอซ้ำ
* รันเวิร์กโฟลว์

## การส่งคำขอซ้ำ {#replay-request-sending}

คำเตือน: สิทธิ์นี้เปิดให้ส่งทราฟฟิก HTTP ขาออกจริงผ่านเครื่องมือส่งซ้ำของ Ogma

หากต้องการเปิด:

```bash
./ogma-mcp --allow-send-requests
```

หรือใช้ตัวแปรสภาพแวดล้อม:

```bash
OGMA_MCP_ALLOW_SEND_REQUESTS=true ./ogma-mcp
```

### สิ่งที่ต้องเตรียม {#prerequisites}

1. พร็อกซี Ogma ต้องกำลังทำงาน
2. ต้องกำหนดขอบเขตที่ใช้งานใน **ขอบเขต** สำหรับการส่งซ้ำที่มีการตรวจสอบป้องกัน
3. โฮสต์เป้าหมายต้องอยู่ในขอบเขตที่ใช้งาน

### เครื่องมือส่ง {#send-tools}

| เครื่องมือ | สิทธิ์ | คำอธิบาย |
|------|-----------|-------------|
| `ogma_preview_replay_send` | send\_requests | เตรียมการส่งและรับโทเค็นยืนยัน |
| `ogma_send_replay_request` | send\_requests | ส่งด้วยโทเค็นยืนยัน |
| `ogma_create_replay_session_from_history` | send\_requests | สร้างเซสชันส่งซ้ำ |
| `ogma_create_replay_session_raw` | send\_requests | สร้างเซสชันส่งซ้ำจากนิยามคำขอดิบ |
| `ogma_browser_form_to_replay` | send\_requests | สร้างเซสชันส่งซ้ำจากแบบฟอร์มบนหน้าที่เปิดอยู่ |
| `ogma_create_scope_preset` | send\_requests | จัดเก็บขอบเขตที่ตั้งไว้ล่วงหน้า เปิดใช้งานแยกด้วย `ogma_set_active_scope` |
| `ogma_repeat_request` | send\_requests | ส่งคำขอที่บันทึกไว้ซ้ำพร้อมการเปลี่ยนแปลงที่เลือกได้ |
| `ogma_replay_with_modifications` | send\_requests | ส่งคำขอที่บันทึกไว้ซ้ำพร้อมแทนค่าระดับฟิลด์ |
| `ogma_http_request` | send\_requests | ส่งคำขอ HTTP โดยตรง |
| `ogma_fetch_url` | send\_requests | ดึง URL แล้วคืนสถานะ ส่วนหัว และตัวอย่าง |
| `ogma_follow_redirect` | send\_requests | ติดตามลำดับการเปลี่ยนเส้นทางและรายงานแต่ละขั้น |
| `ogma_bulk_send_requests` | send\_requests | ส่งชุดคำขอภายในขีดจำกัด |
| `ogma_fuzz_parameter` | send\_requests | แทนตัวแทนค่า `{{FUZZ}}` ด้วยค่าจากรายการคำ |
| `ogma_multipart_upload` | send\_requests | ส่งคำขอ multipart form-data สำหรับทดสอบการอัปโหลด |
| `ogma_websocket_connect` | send\_requests | เชื่อมต่อ URL ของ WebSocket และแลกเปลี่ยนข้อความ |
| `ogma_login_replay_auto` | send\_requests | ส่งแบบฟอร์มเข้าสู่ระบบในเบราว์เซอร์และบันทึกโปรไฟล์ยืนยันตัวตน |
| `ogma_auth_capture_profile` | send\_requests | บันทึกคุกกี้ ที่เก็บข้อมูล โทเค็นยืนยันตัวตน และค่าที่อาจเป็น CSRF จากเบราว์เซอร์ |
| `ogma_auth_apply_profile` | send\_requests | ใช้โปรไฟล์ยืนยันตัวตนที่บันทึกไว้กับเบราว์เซอร์ |
| `ogma_auth_refresh_csrf` | send\_requests | รีเฟรชค่าที่อาจเป็น CSRF จากสถานะเบราว์เซอร์ |
| `ogma_authz_matrix_test` | send\_requests | ส่งคำขอหนึ่งรายการซ้ำด้วยโปรไฟล์ยืนยันตัวตนหลายโปรไฟล์ |
| `ogma_run_active_probe_workflow` | send\_requests | รันการทดสอบเชิงรุกเฉพาะช่องโหว่ภายในขีดจำกัด |
| `ogma_test_race` | send\_requests | ส่งคำขอเดียวพร้อมกันและรายงานการตอบกลับที่ต่างจากรหัสสถานะที่พบบ่อยที่สุด |
| `ogma_test_smuggling` | send\_requests | ส่งการทดสอบคำขอที่ไม่สอดคล้องกันแบบ CL.TE และ TE.CL ผ่าน TCP ดิบ |
| `ogma_test_hpp` | send\_requests | ส่งรูปแบบต่าง ๆ ของการปนเปื้อนพารามิเตอร์ HTTP |
| `ogma_run_nuclei` | send\_requests | รันเทมเพลตเครื่องมือสแกนหนึ่งรายการที่มีมาให้หรือที่จัดหา บน URL เป้าหมาย |
| `ogma_browser_navigate` และเครื่องมือโต้ตอบกับเบราว์เซอร์ | send\_requests | ควบคุมเบราว์เซอร์แบบฝังและบันทึกทราฟฟิกที่เกิดขึ้น |
| `ogma_crawl_site` | send\_requests | รวบรวมข้อมูลเป้าหมายภายในขอบเขตผ่านเบราว์เซอร์แบบฝัง |
| `ogma_get_replay_session` | ไม่มี | ดูเมทาดาทาเซสชันส่งซ้ำ |
| `ogma_get_replay_attempt` | ไม่มี | ดูเมทาดาทาการลองส่งซ้ำ |
| `ogma_list_replay_sessions` | ไม่มี | แสดงเซสชันส่งซ้ำ |

### เวิร์กโฟลว์สองขั้นตอน {#two-step-workflow}

เครื่องมือส่งซ้ำคู่ที่ใช้การยืนยันต้องเรียกสองครั้ง:

1. `ogma_preview_replay_send` - ตรวจสอบคำขอและรับโทเค็นยืนยัน
2. `ogma_send_replay_request` - ยืนยันและส่งด้วยโทเค็น

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

### ตัวอย่างเซสชัน {#example-session}

```
User: Resend HTTP entry abc123 and check the response
AI: (calls ogma_preview_replay_send with http_entry_id="abc123")
    - shows request preview, confirmation token, scope status --
AI: (calls ogma_send_replay_request with confirmation_token and request_hash)
    - shows response status, timing, response preview --
```

### สิ่งที่ยังใช้ไม่ได้เมื่อมีเฉพาะสิทธิ์ส่งคำขอ {#still-not-available-with-request-sending-permissions-only}

* รันเวิร์กโฟลว์
* สร้างหรืออัปเดตประเด็นที่ตรวจพบ
* ลบข้อมูล

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

## การควบคุมการดักรับ {#intercept-control}

คำเตือน: การควบคุมการดักรับทำให้ไคลเอนต์ MCP ส่งต่อ ทิ้ง หรือแก้ไขทราฟฟิกสดที่กำลังรออยู่ในคิวดักรับของ Ogma ได้

หากต้องการเปิด:

```bash
./ogma-mcp --allow-intercept-control
```

หรือใช้ตัวแปรสภาพแวดล้อม:

```bash
OGMA_MCP_ALLOW_INTERCEPT_CONTROL=true ./ogma-mcp
```

### เครื่องมือดักรับ {#intercept-tools}

| เครื่องมือ | สิทธิ์ | คำอธิบาย |
|------|-----------|-------------|
| `ogma_get_intercept_status` | intercept\_control | อ่านสถานะการดักรับคำขอ การตอบกลับ และ WebSocket |
| `ogma_set_intercept_enabled` | intercept\_control | เปิดหรือปิดโหมดดักรับ |
| `ogma_list_intercept_queue` | intercept\_control | แสดงรายการที่กำลังรออยู่ |
| `ogma_get_intercept_item` | intercept\_control | ตรวจสอบหนึ่งรายการในคิว |
| `ogma_forward_intercept_item` | intercept\_control | ส่งต่อรายการในคิว พร้อมการแก้ไขที่เลือกได้ |
| `ogma_drop_intercept_item` | intercept\_control | ทิ้งรายการในคิว |
| `ogma_intercept_and_modify` | intercept\_control | รอรายการที่ตรงเงื่อนไข แก้ไข แล้วส่งต่อ |

## การรันเวิร์กโฟลว์ {#workflow-execution}

คำเตือน: การรันเวิร์กโฟลว์เรียกใช้ตรรกะของเวิร์กโฟลว์ บางเวิร์กโฟลว์ส่งทราฟฟิก HTTP หรือสร้างประเด็นที่ตรวจพบ

หากต้องการเปิด:

```bash
./ogma-mcp --allow-run-workflows
```

### เครื่องมือรันเวิร์กโฟลว์ {#workflow-execution-tools}

| เครื่องมือ | สิทธิ์ | คำอธิบาย |
|------|-----------|-------------|
| `ogma_get_workflow_safety` | ไม่มี (อ่านอย่างเดียว) | จัดประเภทผลกระทบข้างเคียงของเวิร์กโฟลว์ |
| `ogma_preview_workflow_run` | run\_workflows | ดูตัวอย่างและรับโทเค็นยืนยัน |
| `ogma_run_workflow` | run\_workflows | รันด้วยโทเค็นยืนยัน |
| `ogma_cancel_workflow_run` | run\_workflows | ยกเลิกเวิร์กโฟลว์แอกทีฟที่กำลังรัน |

ดูตัวอย่างด้วย `workflow_id` พร้อม `input` สำหรับเวิร์กโฟลว์แปลงข้อมูล หรือ `trigger_entry_id` สำหรับอินพุตที่บันทึกไว้ของเวิร์กโฟลว์แอกทีฟ รันด้วย `confirmation_token` และ `definition_hash` ที่ได้รับ เวิร์กโฟลว์แปลงข้อมูลต้องใช้ `input_hash` และ `input` เดิมด้วย โทเค็นหมดอายุหลังห้านาทีและใช้ได้ครั้งเดียว อ่านผลการรันด้วย `ogma_get_workflow_run`

การรันระบบอัตโนมัติใช้เครื่องมือเซสชันและการรันของฟีเจอร์นี้พร้อม **สิทธิ์ส่งคำขอ** ไม่ใช่สิทธิ์รันเวิร์กโฟลว์ การแสดงรายการและตรวจสอบการรันที่มีอยู่ไม่ต้องมีสิทธิ์ส่ง

### ข้อกำหนดสิทธิ์ร่วมกัน {#cross-permission-requirements}

เวิร์กโฟลว์ที่ใช้ `sdk.requests.send` ต้องมี `--allow-send-requests` ด้วย
เวิร์กโฟลว์ที่ใช้ `sdk.findings.create` ต้องมี `--allow-write-findings` ด้วย

การตรวจจับใช้การวิเคราะห์ข้อความแบบสถิต ดูข้อควรระวังด้านล่าง

### ข้อควรระวังในการจัดประเภทความปลอดภัย {#safety-classification-advisory-note}

การจัดประเภทความปลอดภัยของเวิร์กโฟลว์ตรวจข้อความซอร์สโค้ด JavaScript เพื่อหาแพตเทิร์น เช่น `sdk.requests.send` การตรวจจับนี้ไม่ครอบคลุมทั้งหมด การเรียกเมธอด SDK ที่ทำให้เข้าใจยากหรือสร้างแบบไดนามิกอาจตรวจไม่พบ ตรวจซอร์สโค้ด JavaScript ของเวิร์กโฟลว์เสมอก่อนรันเวิร์กโฟลว์ที่ไม่น่าเชื่อถือ

### สิ่งที่ยังใช้ไม่ได้เมื่อมีเฉพาะสิทธิ์เวิร์กโฟลว์ {#still-not-available-with-workflow-permissions-only}

* เรียกเวิร์กโฟลว์พาสซีฟด้วยตนเอง
* ลบข้อมูล
* เปลี่ยนตัวแปรสภาพแวดล้อม

## ตัวอย่างคำสั่งให้ผู้ช่วย {#example-prompts}

เมื่อเชื่อมต่อแล้ว:

* "แสดงคำขอ HTTP ล่าสุด 20 รายการที่ส่งไปยัง example.com"
* "โครงการนี้มีประเด็นที่ตรวจพบระดับสูงหรือวิกฤตหรือไม่?"
* "ขณะนี้เปิดเวิร์กโฟลว์ใดอยู่บ้าง?"
* "ตรวจสอบว่าคิวรี HTTPQL `req.method.eq:\"POST\"` ถูกต้องหรือไม่"
* "สรุปสถานะความปลอดภัยของโครงการปัจจุบัน"
* "วิเคราะห์รายการ HTTP {id} เพื่อหาปัญหาความปลอดภัย"

## การแก้ไขปัญหา {#troubleshooting}

**การเชื่อมต่อถูกปฏิเสธ:** เริ่ม Ogma ก่อน (`ogma --data-dir ./ogma-data`)

**ไคลเอนต์ MCP ไม่แสดงเครื่องมือ:** ตรวจ URL การรับส่งหรือพาธไฟล์ปฏิบัติการ ไคลเอนต์ต้องติดตามเคอร์เซอร์ทั้งหมดของ `tools/list` แต่ละหน้ามีเครื่องมือได้สูงสุด 40 ตัว ตรวจตัวกรองฝั่งไคลเอนต์และตรวจว่ารุ่นที่ติดตั้งมีเครื่องมือที่หายไปหรือไม่

**เซสชันหรือโทเค็นยืนยันไม่ถูกต้อง:** เชื่อมต่อใหม่หลังเริ่มทำงานใหม่ และสร้างโทเค็นตัวอย่างใหม่

**เบราว์เซอร์ใช้ไม่ได้หรือการดำเนินการล้มเหลว:** ให้แอปเดสก์ท็อปทำงานต่อ ตรวจ `ogma_browser_health` กล่องโต้ตอบ และ [การกู้คืนเบราว์เซอร์](./guide/mcp-browser.md#recover-from-errors) ระบบหลังบ้านแบบไม่มีส่วนติดต่อผู้ใช้เพียงอย่างเดียวไม่ได้ให้บริดจ์เบราว์เซอร์เดสก์ท็อป

**ภาพหน้าจอไม่มีข้อความที่อ่านได้:** ใช้ไคลเอนต์ที่รองรับเนื้อหารูปภาพ MCP แบบเนทีฟ หรือดูสแนปช็อตเชิงความหมาย

**ผลลัพธ์ว่าง:** Ogma ต้องบันทึกทราฟฟิกก่อน ท่องเว็บโดยกำหนดพร็อกซีให้ส่งทราฟฟิกผ่าน Ogma