Plugged.in MCP Server

ทางการ

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

GitHub

131

เอกสาร

plugged.in MCP Hub — พร็อกซี · ความรู้ · หน่วยความจำ · เครื่องมือ

จุดตัดสำหรับการแลกเปลี่ยนข้อมูล AI

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

📋 ภาพรวม

plugged.in MCP Proxy Server เป็นมิดเดิลแวร์ทรงพลังที่รวบรวมเซิร์ฟเวอร์ Model Context Protocol (MCP) หลายตัวเข้าเป็นอินเทอร์เฟซเดียวแบบรวมศูนย์ มันดึงการตั้งค่าเครื่องมือ พรอมต์ และทรัพยากรจาก plugged.in App และจัดเส้นทางคำขอไปยังเซิร์ฟเวอร์ MCP พื้นฐานที่เหมาะสมอย่างชาญฉลาด

พร็อกซีนี้ช่วยให้ผสานรวมกับไคลเอนต์ MCP ใดๆ (Claude, Cline, Cursor ฯลฯ) ได้อย่างราบรื่น พร้อมมอบความสามารถในการจัดการขั้นสูงผ่านระบบนิเวศของ plugged.in

เสาหลักของฮับ: ความรู้ · หน่วยความจำ · เครื่องมือ · พร็อกซี

ความรู้ (RAG v2 / การแลกเปลี่ยนเอกสาร AI)
ค้นหาและยึดเอาต์พุตของโมเดลด้วยการเรียกค้นเอกสารแบบรวมศูนย์ที่รับรู้การระบุแหล่งที่มา เซิร์ฟเวอร์ MCP สามารถสร้างและจัดการเอกสารในคลังของคุณด้วยการกำหนดเวอร์ชัน การควบคุมการมองเห็น และการระบุแหล่งที่มาของโมเดล ใช้ RAG ในตัวเพื่อค้นหาข้ามแหล่งที่เชื่อมต่อทั้งหมดและส่งคืนตัวอย่างและเมทาดาทาที่เกี่ยวข้อง

หน่วยความจำ (หน่วยความจำ AI แบบถาวร)
หน่วยความจำที่มีอายุยาวนานตามขอบเขตพื้นที่ทำงาน/โปรไฟล์ที่คงอยู่ข้ามเซสชัน ฮับผสานรวมกับหน่วยความจำถาวรของ plugged.in App เพื่อให้การกระทำและข้อมูลเชิงลึกของเอเจนต์สามารถจัดเก็บและเรียกคืนข้ามงานได้ เครื่องมือหน่วยความจำในตัวอยู่บนแผนงานเพื่อเปิดเผยรูปแบบ get/put/search ที่มีแรงเสียดทานต่ำภายใต้โมเดลการตรวจสอบสิทธิ์เดียวกัน

เครื่องมือ
รวมความสามารถในตัวเข้ากับเซิร์ฟเวอร์ MCP ปลายทาง (STDIO, SSE, Streamable HTTP) การค้นพบเครื่องมือถูกแคชและสามารถรีเฟรชได้ตามต้องการ การค้นพบระดับฮับจะส่งคืนแคตตาล็อกแบบรวมสำหรับไคลเอนต์ MCP ใดๆ ฮับรองรับเครื่องมือ ทรัพยากร เทมเพลตทรัพยากร และพรอมต์

พร็อกซี
หนึ่งการเชื่อมต่อสำหรับทุกไคลเอนต์ ทำงานเป็น STDIO (ค่าเริ่มต้น) หรือ Streamable HTTP พร้อมการตรวจสอบสิทธิ์ API และโหมดไร้สถานะที่เป็นตัวเลือก ทำงานร่วมกับ Claude Desktop, Cline, Cursor, MCP Inspector และอื่นๆ รักษาการตั้งค่าไคลเอนต์ที่มีอยู่ของคุณในขณะที่รวมศูนย์นโยบายและการวัดและส่งข้อมูลทางไกล

⭐ หากคุณพบว่าโปรเจกต์นี้มีประโยชน์ โปรดพิจารณาให้ดาวบน GitHub! มันช่วยให้เราเข้าถึงนักพัฒนาได้มากขึ้นและเป็นแรงจูงใจให้เราพัฒนาต่อไป

✨ คุณสมบัติหลัก

🚀 ความสามารถหลัก

สนามเด็กเล่น AI ในตัว: ทดสอบ MCP ของคุณทันทีกับ Claude, Gemini, OpenAI และ xAI โดยไม่ต้องตั้งค่าไคลเอนต์ใดๆ
ความเข้ากันได้กับ MCP สากล: ทำงานกับไคลเอนต์ MCP ใดๆ รวมถึง Claude Desktop, Cline และ Cursor
รองรับหลายเซิร์ฟเวอร์: เชื่อมต่อกับเซิร์ฟเวอร์ MCP แบบ STDIO, SSE และ Streamable HTTP
โหมดการขนส่งคู่: เรียกใช้พร็อกซีเป็น STDIO (ค่าเริ่มต้น) หรือเซิร์ฟเวอร์ Streamable HTTP
การค้นหาเอกสารแบบรวม: ค้นหาข้ามเซิร์ฟเวอร์ที่เชื่อมต่อทั้งหมดด้วยความสามารถ RAG ในตัว
การแลกเปลี่ยนเอกสาร AI (RAG v2): เซิร์ฟเวอร์ MCP สามารถสร้างและจัดการเอกสารในคลังของคุณพร้อมการระบุแหล่งที่มาแบบเต็ม
การแจ้งเตือนจากโมเดลใดๆ: รับการแจ้งเตือนแบบเรียลไทม์พร้อมการส่งอีเมลที่เป็นตัวเลือก
เลเยอร์หลายพื้นที่ทำงาน: สลับระหว่างชุดการตั้งค่า MCP ที่แตกต่างกันด้วยคลิกเดียว
พร็อกซีที่ขับเคลื่อนด้วย API: ดึงความสามารถจาก API ของ plugged.in App แทนการค้นพบโดยตรง
รองรับ MCP เต็มรูปแบบ: จัดการเครื่องมือ ทรัพยากร เทมเพลตทรัพยากร และพรอมต์
คำแนะนำที่กำหนดเอง: รองรับคำแนะนำเฉพาะเซิร์ฟเวอร์ที่จัดรูปแบบเป็นพรอมต์ MCP

🎯 ใหม่ใน v1.5.0 (RAG v2 - การแลกเปลี่ยนเอกสาร AI)

การสร้างเอกสาร AI: เซิร์ฟเวอร์ MCP สามารถสร้างเอกสารโดยตรงในคลังของคุณได้แล้ว
- การติดตามการระบุแหล่งที่มาของโมเดลแบบเต็ม (AI ใดสร้าง/อัปเดตเอกสาร)
- ประวัติเวอร์ชันพร้อมการติดตามการเปลี่ยนแปลง
- การขจัดข้อมูลซ้ำซ้อนผ่านการแฮช SHA-256
- รองรับหลายรูปแบบ: MD, TXT, JSON, HTML, PDF และอื่นๆ
การค้นหาเอกสารขั้นสูง: การสืบค้น RAG ที่ปรับปรุงด้วยการกรอง AI
- กรองตามโมเดล AI, ผู้ให้บริการ, ช่วงวันที่, แท็ก และประเภทแหล่งที่มา
- การค้นหาเชิงความหมายพร้อมคะแนนความเกี่ยวข้อง
- การสร้างตัวอย่างอัตโนมัติพร้อมการเน้นคำสำคัญ
- รองรับการกรอง: แหล่ง ai_generated, upload หรือ api
การจัดการเอกสารผ่าน MCP:
- ตั้งค่าการมองเห็นเอกสาร: ส่วนตัว, พื้นที่ทำงาน หรือสาธารณะ
- ความสัมพันธ์แม่-ลูกสำหรับเวอร์ชันเอกสาร
- การจัดระเบียบตามโปรไฟล์ควบคู่กับการกำหนดขอบเขตตามโปรเจกต์
- การติดตามความคืบหน้าแบบเรียลไทม์สำหรับการประมวลผลเอกสาร

🎯 คุณสมบัติจาก v1.4.0 (รองรับ Registry v2)

การจัดการโทเค็น OAuth: การจัดการการตรวจสอบสิทธิ์ OAuth ที่ราบรื่นสำหรับเซิร์ฟเวอร์ MCP แบบ Streamable HTTP
- การเรียกค้นโทเค็นอัตโนมัติจาก plugged.in App
- การจัดเก็บโทเค็นที่ปลอดภัยและกลไกการรีเฟรช
- ไม่จำเป็นต้องตรวจสอบสิทธิ์ฝั่งไคลเอนต์
ระบบการแจ้งเตือนที่ปรับปรุง: รองรับการแจ้งเตือนแบบสองทิศทาง
- ส่งการแจ้งเตือนไปยัง plugged.in App
- รับการแจ้งเตือนจากเซิร์ฟเวอร์ MCP
- ทำเครื่องหมายการแจ้งเตือนว่าอ่านแล้ว/ยังไม่ได้อ่าน
- ลบการแจ้งเตือนโดยทางโปรแกรม
การวิเคราะห์แนวโน้ม: การติดตามกิจกรรมแบบเรียลไทม์
- ทุกการเรียกใช้เครื่องมือถูกบันทึกและติดตาม
- มีส่วนร่วมในการคำนวณเซิร์ฟเวอร์ที่กำลังมาแรง
- เมตริกการใช้งานและข้อมูลเชิงลึกด้านความนิยม
การผสานรวม Registry: รองรับคุณสมบัติ Registry v2 เต็มรูปแบบ
- การค้นพบเซิร์ฟเวอร์อัตโนมัติจาก registry
- การติดตามการติดตั้งและเมตริก
- รองรับเซิร์ฟเวอร์ชุมชน

📦 คุณสมบัติจาก v1.1.0

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

🎯 คุณสมบัติหลักจาก v1.0.0

การแจ้งเตือนแบบเรียลไทม์: ติดตามกิจกรรม MCP ทั้งหมดด้วยการรองรับการแจ้งเตือนที่ครอบคลุม
การผสานรวม RAG: รองรับการสืบค้นที่เสริมด้วยเอกสารผ่าน plugged.in App
สคริปต์ตรวจสอบ: เครื่องมือทดสอบอัตโนมัติสำหรับการดีบักและพัฒนา
การตรวจสอบสุขภาพ: ปลายทาง ping ในตัวสำหรับการตรวจสอบการเชื่อมต่อ

🔧 หมวดหมู่เครื่องมือ

พร็อกซีมีเครื่องมือสองหมวดหมู่ที่แตกต่างกัน:

🔧 เครื่องมือในตัวแบบคงที่ (พร้อมใช้งานเสมอ)

เครื่องมือเหล่านี้มีอยู่ในพร็อกซีและทำงานโดยไม่ต้องกำหนดค่าเซิร์ฟเวอร์ใดๆ:

pluggedin_discover_tools - การค้นพบอัจฉริยะพร้อมแคชเพื่อผลลัพธ์ทันที
pluggedin_ask_knowledge_base - การค้นหา RAG ข้ามเอกสารของคุณด้วยความสามารถในการกรอง AI
pluggedin_send_notification - ส่งการแจ้งเตือนพร้อมการส่งอีเมลที่เป็นตัวเลือก
pluggedin_create_document - สร้างเอกสารที่สร้างโดย AI ในคลังของคุณ
pluggedin_list_documents - แสดงรายการเอกสารพร้อมตัวเลือกการกรอง
pluggedin_search_documents - ค้นหาเอกสารเฉพาะตามการสืบค้น
pluggedin_get_document - เรียกค้นเนื้อหาทั้งหมดของเอกสารเฉพาะตาม ID
pluggedin_update_document - อัปเดตหรือผนวกเข้ากับเอกสารที่มีอยู่

📋 เครื่องมือคลิปบอร์ด (ระบบหน่วยความจำ)

pluggedin_clipboard_set - ตั้งค่ารายการคลิปบอร์ดตามชื่อ (คีย์เชิงความหมาย) หรือดัชนี
pluggedin_clipboard_get - รับรายการคลิปบอร์ดตามชื่อ ดัชนี หรือแสดงรายการทั้งหมด
pluggedin_clipboard_delete - ลบรายการคลิปบอร์ดตามชื่อ ดัชนี หรือล้างทั้งหมด
pluggedin_clipboard_list - แสดงรายการคลิปบอร์ดทั้งหมดพร้อมเมทาดาทา
pluggedin_clipboard_push - ผลักค่าด้วยดัชนีที่เพิ่มขึ้นอัตโนมัติ (การผลักสแต็ก)
pluggedin_clipboard_pop - ป๊อปรายการที่มีดัชนีสูงสุด (พฤติกรรม LIFO)

⚡ เครื่องมือ MCP แบบไดนามิก (จากเซิร์ฟเวอร์ที่เชื่อมต่อ)

เครื่องมือเหล่านี้มาจากเซิร์ฟเวอร์ MCP ที่คุณกำหนดค่าและสามารถเปิด/ปิดได้:

เครื่องมือฐานข้อมูล (PostgreSQL, SQLite ฯลฯ)
เครื่องมือระบบไฟล์
เครื่องมือผสานรวม API
เครื่องมือที่กำหนดเองจากเซิร์ฟเวอร์ MCP ใดๆ

เครื่องมือการค้นพบแสดงทั้งสองหมวดหมู่อย่างชาญฉลาด ทำให้โมเดล AI เข้าถึงความสามารถที่มีอยู่ทั้งหมดได้ทันที

🚀 การใช้งานเครื่องมือการค้นพบ

# Quick discovery - returns cached data instantly
pluggedin_discover_tools()

# Force refresh - shows current tools + runs background discovery  
pluggedin_discover_tools({"force_refresh": true})

# Discover specific server
pluggedin_discover_tools({"server_uuid": "uuid-here"})

ตัวอย่างการตอบสนอง:

## 🔧 Static Built-in Tools (Always Available):
1. **pluggedin_discover_tools** - Smart discovery with caching
2. **pluggedin_rag_query** - RAG v2 search across documents with AI filtering  
3. **pluggedin_send_notification** - Send notifications
4. **pluggedin_create_document** - (Coming Soon) Create AI-generated documents

## ⚡ Dynamic MCP Tools (8) - From Connected Servers:
1. **query** - Run read-only SQL queries
2. **generate_random_integer** - Generate secure random integers
...

📋 ตัวอย่างการใช้งานคลิปบอร์ด

ระบบคลิปบอร์ดให้หน่วยความจำถาวรสำหรับเวิร์กโฟลว์ AI:

# Store a named entry (upserts if exists)
pluggedin_clipboard_set({
  "name": "customer_context",
  "value": "{\"name\": \"John Doe\", \"account_id\": \"12345\"}",
  "contentType": "application/json"
})

# Store an indexed entry for ordered pipelines
pluggedin_clipboard_set({
  "idx": 0,
  "value": "First pipeline step result",
  "createdByTool": "data_processor"
})

# Push to stack (auto-incrementing index)
pluggedin_clipboard_push({
  "value": "Analysis result from step 1",
  "contentType": "text/plain"
})

# Get a specific entry by name
pluggedin_clipboard_get({"name": "customer_context"})

# Pop from stack (LIFO - returns and removes highest index)
pluggedin_clipboard_pop()

# List all entries with metadata
pluggedin_clipboard_list({"limit": 20})

# Delete specific entry
pluggedin_clipboard_delete({"name": "customer_context"})

# Clear all clipboard entries
pluggedin_clipboard_delete({"clearAll": true})

📚 ตัวอย่างการใช้งาน RAG v2

ระบบ RAG v2 ที่ปรับปรุงช่วยให้เซิร์ฟเวอร์ MCP สร้างและค้นหาเอกสารพร้อมการระบุแหล่งที่มาของ AI แบบเต็ม:

# Search for documents created by specific AI models
pluggedin_rag_query({
  "query": "system architecture",
  "filters": {
    "modelName": "Claude 3 Opus",
    "source": "ai_generated",
    "tags": ["technical"]
  }
})

# Search across all document sources
pluggedin_rag_query({
  "query": "deployment guide",
  "filters": {
    "dateFrom": "2024-01-01",
    "visibility": "workspace"
  }
})

# Future: Create AI-generated documents (Coming Soon)
pluggedin_create_document({
  "title": "Analysis Report",
  "content": "# Market Analysis\n\nDetailed findings...",
  "format": "md",
  "tags": ["analysis", "market"],
  "metadata": {
    "model": {
      "name": "Claude 3 Opus",
      "provider": "Anthropic"
    }
  }
})

🚀 เริ่มต้นอย่างรวดเร็ว

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

Node.js 18+ (แนะนำ v20+)
คีย์ API จาก plugged.in App (รับได้ที่ plugged.in/api-keys)

การติดตั้ง

# Install and run with npx (latest v1.0.0)
npx -y @pluggedin/pluggedin-mcp-proxy@latest --pluggedin-api-key YOUR_API_KEY

🔄 การอัปเกรดเป็น v1.0.0

สำหรับการติดตั้งที่มีอยู่ ดู คู่มือการย้าย ของเราสำหรับคำแนะนำการอัปเกรดโดยละเอียด

# Quick upgrade
npx -y @pluggedin/[email protected] --pluggedin-api-key YOUR_API_KEY

การกำหนดค่าสำหรับไคลเอนต์ MCP

Claude Desktop

เพิ่มสิ่งต่อไปนี้ในการกำหนดค่า Claude Desktop ของคุณ:

{
  "mcpServers": {
    "pluggedin": {
      "command": "npx",
      "args": ["-y", "@pluggedin/pluggedin-mcp-proxy@latest"],
      "env": {
        "PLUGGEDIN_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Cline

เพิ่มสิ่งต่อไปนี้ในการกำหนดค่า Cline ของคุณ:

{
  "mcpServers": {
    "pluggedin": {
      "command": "npx",
      "args": ["-y", "@pluggedin/pluggedin-mcp-proxy@latest"],
      "env": {
        "PLUGGEDIN_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Cursor

สำหรับ Cursor คุณสามารถใช้อาร์กิวเมนต์บรรทัดคำสั่งแทนตัวแปรสภาพแวดล้อม:

npx -y @pluggedin/pluggedin-mcp-proxy@latest --pluggedin-api-key YOUR_API_KEY

⚙️ ตัวเลือกการกำหนดค่า

ตัวแปรสภาพแวดล้อม

ตัวแปร	คำอธิบาย	จำเป็น	ค่าเริ่มต้น
`PLUGGEDIN_API_KEY`	คีย์ API จาก plugged.in App	ใช่	-
`PLUGGEDIN_API_BASE_URL`	URL ฐานสำหรับ plugged.in App	ไม่	`https://plugged.in`

อาร์กิวเมนต์บรรทัดคำสั่ง

อาร์กิวเมนต์บรรทัดคำสั่งมีความสำคัญเหนือกว่าตัวแปรสภาพแวดล้อม:

npx -y @pluggedin/pluggedin-mcp-proxy@latest --pluggedin-api-key YOUR_API_KEY --pluggedin-api-base-url https://your-custom-url.com

ตัวเลือกการขนส่ง

ตัวเลือก	คำอธิบาย	ค่าเริ่มต้น
`--transport <type>`	ประเภทการขนส่ง: `stdio` หรือ `streamable-http`	`stdio`
`--port <number>`	พอร์ตสำหรับเซิร์ฟเวอร์ Streamable HTTP	`12006`
`--stateless`	เปิดใช้งานโหมดไร้สถานะสำหรับ Streamable HTTP	`false`
`--require-api-auth`	ต้องการคีย์ API สำหรับคำขอ Streamable HTTP	`false`

สำหรับรายการตัวเลือกทั้งหมด:

npx -y @pluggedin/pluggedin-mcp-proxy@latest --help

🌐 โหมด Streamable HTTP

พร็อกซีสามารถทำงานเป็นเซิร์ฟเวอร์ HTTP แทน STDIO ทำให้สามารถเข้าถึงผ่านเว็บและการเชื่อมต่อระยะไกล

การใช้งานพื้นฐาน

# Run as HTTP server on default port (12006)
npx -y @pluggedin/pluggedin-mcp-proxy@latest --transport streamable-http --pluggedin-api-key YOUR_API_KEY

# Custom port
npx -y @pluggedin/pluggedin-mcp-proxy@latest --transport streamable-http --port 8080 --pluggedin-api-key YOUR_API_KEY

# With authentication required
npx -y @pluggedin/pluggedin-mcp-proxy@latest --transport streamable-http --require-api-auth --pluggedin-api-key YOUR_API_KEY

# Stateless mode (new session per request)
npx -y @pluggedin/pluggedin-mcp-proxy@latest --transport streamable-http --stateless --pluggedin-api-key YOUR_API_KEY

ปลายทาง HTTP

POST /mcp - ส่งข้อความ MCP
GET /mcp - สตรีมเหตุการณ์ที่เซิร์ฟเวอร์ส่ง (ตัวเลือก)
DELETE /mcp - ยุติเซสชัน
GET /health - ปลายทางตรวจสอบสุขภาพ

การจัดการเซสชัน

ในโหมดมีสถานะ (ค่าเริ่มต้น) ใช้ส่วนหัว mcp-session-id เพื่อรักษาเซสชัน:

# First request creates a session
curl -X POST http://localhost:12006/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","method":"tools/list","id":1}'

# Subsequent requests use the same session
curl -X POST http://localhost:12006/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "mcp-session-id: YOUR_SESSION_ID" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"tool_name"},"id":2}'

การตรวจสอบสิทธิ์

เมื่อใช้ --require-api-auth ให้รวมคีย์ API ของคุณเป็นโทเค็น Bearer:

curl -X POST http://localhost:12006/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","method":"ping","id":1}'

🐳 การใช้งาน Docker

คุณยังสามารถสร้างและเรียกใช้พร็อกซีเซิร์ฟเวอร์โดยใช้ Docker

การสร้างอิมเมจ

ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้งและเรียกใช้ Docker แล้ว นำทางไปยังไดเรกทอรี pluggedin-mcp และเรียกใช้:

docker build -t pluggedin-mcp-proxy:latest .

ไฟล์ .dockerignore ถูกรวมไว้เพื่อเพิ่มประสิทธิภาพบริบทการสร้าง

การเรียกใช้คอนเทนเนอร์

โหมด STDIO (ค่าเริ่มต้น)

เรียกใช้คอนเทนเนอร์ในโหมด STDIO สำหรับการทดสอบ MCP Inspector:

docker run -it --rm \
  -e PLUGGEDIN_API_KEY="YOUR_API_KEY" \
  -e PLUGGEDIN_API_BASE_URL="YOUR_API_BASE_URL" \
  --name pluggedin-mcp-container \
  pluggedin-mcp-proxy:latest

โหมด Streamable HTTP

เรียกใช้คอนเทนเนอร์เป็นเซิร์ฟเวอร์ HTTP:

docker run -d --rm \
  -e PLUGGEDIN_API_KEY="YOUR_API_KEY" \
  -e PLUGGEDIN_API_BASE_URL="YOUR_API_BASE_URL" \
  -p 12006:12006 \
  --name pluggedin-mcp-http \
  pluggedin-mcp-proxy:latest \
  --transport streamable-http --port 12006

แทนที่ YOUR_API_KEY และ YOUR_API_BASE_URL (หากไม่ได้ใช้ค่าเริ่มต้น https://plugged.in)

การทดสอบด้วย MCP Inspector

ในขณะที่คอนเทนเนอร์กำลังทำงาน คุณสามารถเชื่อมต่อกับมันโดยใช้ MCP Inspector:

npx @modelcontextprotocol/inspector docker://pluggedin-mcp-container

สิ่งนี้จะเชื่อมต่อกับอินพุต/เอาต์พุตมาตรฐานของคอนเทนเนอร์ที่กำลังทำงาน

การหยุดคอนเทนเนอร์

กด Ctrl+C ในเทอร์มินัลที่ docker run กำลังทำงาน แฟล็ก --rm รับประกันว่าคอนเทนเนอร์จะถูกลบโดยอัตโนมัติเมื่อหยุด

☁️ การปรับใช้ Smithery Cloud

ปรับใช้ plugged.in MCP Proxy ไปยัง Smithery Cloud เพื่อการเข้าถึงเซิร์ฟเวอร์ MCP ของคุณแบบโฮสต์และพร้อมใช้งานตลอดเวลา

เริ่มต้นอย่างรวดเร็ว

ไปที่ smithery.ai และลงชื่อเข้าใช้
เชื่อมต่อบัญชี GitHub ของคุณและเลือกที่เก็บ pluggedin-mcp
กำหนดค่า API key ของ Plugged.in ใน UI ของ Smithery
ปรับใช้และรับ HTTPS endpoint ของคุณ

ประโยชน์

พร้อมใช้งาน 24/7: พร็อกซีของคุณทำงานตลอดเวลา
ไม่ต้องกำหนดค่า: Smithery ตรวจจับการตั้งค่าจาก smithery.yaml โดยอัตโนมัติ
ปรับขนาดอัตโนมัติ: รองรับการเชื่อมต่อพร้อมกันหลายรายการ
การเข้าถึงผ่านเว็บ: เหมาะสำหรับเว็บแอปพลิเคชันและไคลเอนต์ระยะไกล

เอกสารประกอบ

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

📖 คู่มือการปรับใช้ Smithery

เอเจนต์อัตโนมัติ (ตัวอย่าง)

ฮับถูกออกแบบมาเพื่อรองรับวงจรเอเจนต์แบบครบวงจร:

MCP Client  →  plugged.in MCP Hub  →  (Plan → Act → Reflect)
                                ↘  Knowledge  ↘  Memory  ↘  Tools

วางแผน — กำหนดเป้าหมายและข้อจำกัด สร้างกราฟงาน
ลงมือทำ — เรียกใช้เครื่องมือจากแค็ตตาล็อกแบบรวม; กำหนดเส้นทางอย่างปลอดภัยผ่านเซิร์ฟเวอร์ STDIO/SSE/HTTP
ทบทวน — บันทึกผลลัพธ์ลงในหน่วยความจำและความรู้ (เอกสาร บันทึก อาร์ติแฟกต์) เพื่อปรับปรุงขั้นตอนต่อไป

ความปลอดภัยและการดำเนินงาน
เปิดใช้งาน --require-api-auth ในโหมด Streamable HTTP; ใช้รายการอนุญาตสำหรับคำสั่ง อาร์กิวเมนต์ และ env รวมการตรวจสอบระดับเซิร์ฟเวอร์กับพรอมต์ฝั่งไคลเอนต์ที่ป้องกันการแทรกพรอมต์ ใช้ประโยชน์จากการบันทึก/การวัดและส่งข้อมูลทางไกลที่มีอยู่เพื่อติดตามการใช้เครื่องมือและการเปลี่ยนแปลงเอกสาร

🏗️ สถาปัตยกรรมระบบ

MCP Proxy Server ของ plugged.in ทำหน้าที่เป็นสะพานเชื่อมระหว่างไคลเอนต์ MCP และเซิร์ฟเวอร์ MCP พื้นฐานหลายตัว:

sequenceDiagram
    participant MCPClient as MCP Client (e.g. Claude Desktop)
    participant PluggedinMCP as plugged.in MCP Proxy
    participant PluggedinApp as plugged.in App
    participant MCPServers as Underlying MCP Servers

    MCPClient ->> PluggedinMCP: Request list tools/resources/prompts
    PluggedinMCP ->> PluggedinApp: Get capabilities via API
    PluggedinApp ->> PluggedinMCP: Return capabilities (prefixed)

    MCPClient ->> PluggedinMCP: Call tool/read resource/get prompt
    alt Standard capability
        PluggedinMCP ->> PluggedinApp: Resolve capability to server
        PluggedinApp ->> PluggedinMCP: Return server details
        PluggedinMCP ->> MCPServers: Forward request to target server
        MCPServers ->> PluggedinMCP: Return response
    else Custom instruction
        PluggedinMCP ->> PluggedinApp: Get custom instruction
        PluggedinApp ->> PluggedinMCP: Return formatted messages
    end
    PluggedinMCP ->> MCPClient: Return response

    alt Discovery tool (Smart Caching)
        MCPClient ->> PluggedinMCP: Call pluggedin_discover_tools
        alt Cached data available
            PluggedinMCP ->> PluggedinApp: Check cached capabilities
            PluggedinApp ->> PluggedinMCP: Return cached tools/resources/prompts
            PluggedinMCP ->> MCPClient: Return instant results (static + dynamic)
        else Force refresh or no cache
            PluggedinMCP ->> PluggedinApp: Trigger background discovery
            PluggedinMCP ->> MCPClient: Return current tools + "discovery running"
            PluggedinApp ->> MCPServers: Connect and discover capabilities (background)
            MCPServers ->> PluggedinApp: Return fresh capabilities
        end
    end

🔄 ขั้นตอนการทำงาน

การกำหนดค่า: พร็อกซีดึงการกำหนดค่าเซิร์ฟเวอร์จากแอป plugged.in
การค้นพบอัจฉริยะ (pluggedin_discover_tools):
- ตรวจสอบแคช: ตรวจสอบข้อมูลที่แคชไว้ก่อน (< 1 วินาที)
- ตอบสนองทันที: ส่งคืนเครื่องมือแบบคงที่ + เครื่องมือไดนามิกที่แคชไว้ทันที
- รีเฟรชพื้นหลัง: สำหรับ force_refresh=true รันการค้นพบในพื้นหลังขณะแสดงเครื่องมือปัจจุบัน
- การค้นพบใหม่: รันการค้นพบเต็มรูปแบบเฉพาะเมื่อไม่มีข้อมูลที่แคชไว้
การแสดงรายการความสามารถ: พร็อกซีดึงความสามารถที่ค้นพบจาก API ของแอป plugged.in
- tools/list: ดึงจาก /api/tools (รวมเครื่องมือแบบคงที่ + ไดนามิก)
- resources/list: ดึงจาก /api/resources
- resource-templates/list: ดึงจาก /api/resource-templates
- prompts/list: ดึงจาก /api/prompts และ /api/custom-instructions รวมผลลัพธ์
การแก้ไขความสามารถ: พร็อกซีแก้ไขความสามารถไปยังเซิร์ฟเวอร์เป้าหมาย
- tools/call: แยกคำนำหน้าจากชื่อเครื่องมือ ค้นหาเซิร์ฟเวอร์ในแผนที่ภายใน
- resources/read: เรียก /api/resolve/resource?uri=... เพื่อรับรายละเอียดเซิร์ฟเวอร์
- prompts/get: ตรวจสอบคำนำหน้าคำสั่งที่กำหนดเองหรือเรียก /api/resolve/prompt?name=...
การกำหนดเส้นทางคำขอ: คำขอถูกกำหนดเส้นทางไปยังเซิร์ฟเวอร์ MCP พื้นฐานที่เหมาะสม
การจัดการการตอบสนอง: การตอบสนองจากเซิร์ฟเวอร์พื้นฐานจะถูกส่งกลับไปยังไคลเอนต์

🔒 คุณสมบัติด้านความปลอดภัย

MCP Proxy ของ plugged.in ใช้มาตรการรักษาความปลอดภัยที่ครอบคลุมเพื่อปกป้องระบบและข้อมูลของคุณ:

การตรวจสอบและทำความสะอาดอินพุต

การป้องกันการแทรกคำสั่ง: คำสั่งและอาร์กิวเมนต์ทั้งหมดถูกตรวจสอบกับรายการอนุญาตก่อนดำเนินการ
ความปลอดภัยของตัวแปรสภาพแวดล้อม: การแยกวิเคราะห์ไฟล์ .env อย่างปลอดภัยด้วยการจัดการเครื่องหมายคำพูดและค่าหลายบรรทัดอย่างเหมาะสม
การตรวจสอบโทเค็น: รูปแบบ regex ที่แข็งแกร่งสำหรับ API keys และโทเค็นการตรวจสอบสิทธิ์ (อักขระฐานสิบหก 32-64 ตัว)

ความปลอดภัยของเครือข่าย

การป้องกัน SSRF: การตรวจสอบ URL บล็อกการเข้าถึง:
- ที่อยู่ localhost และ loopback (127.0.0.1, ::1)
- ช่วง IP ส่วนตัว (10.x, 172.16-31.x, 192.168.x)
- ที่อยู่ link-local (169.254.x)
- ช่วง multicast และสงวน
- พอร์ตบริการภายในทั่วไป (SSH, ฐานข้อมูล ฯลฯ)
การตรวจสอบส่วนหัว: การป้องกันการแทรกส่วนหัวด้วย:
- การบล็อกส่วนหัวที่เป็นอันตราย
- การตรวจสอบชื่อส่วนหัวที่สอดคล้องกับ RFC 7230
- การตรวจจับอักขระควบคุม
- การจำกัดขนาดส่วนหัว (สูงสุด 8KB)
การจำกัดอัตรา:
- การเรียกใช้เครื่องมือ: 60 คำขอต่อนาที
- การเรียก API: 100 คำขอต่อนาที
การทำความสะอาดข้อผิดพลาด: ป้องกันการเปิดเผยข้อมูลโดยการทำความสะอาดข้อความแสดงข้อผิดพลาด

ความปลอดภัยของกระบวนการ

การดำเนินการคำสั่งที่ปลอดภัย: ใช้ execFile() แทน exec() เพื่อป้องกันการแทรกเชลล์
รายการอนุญาตคำสั่ง: อนุญาตให้ดำเนินการเฉพาะ:
- node, npx - คำสั่ง Node.js
- python, python3 - คำสั่ง Python
- uv, uvx, uvenv - เครื่องมือ UV Python
การทำความสะอาดอาร์กิวเมนต์: ลบอักขระพิเศษของเชลล์และอักขระควบคุมออกจากอาร์กิวเมนต์ทั้งหมด
การตรวจสอบตัวแปรสภาพแวดล้อม: อนุญาตเฉพาะคีย์ตัวอักษรและตัวเลขที่มีขีดล่าง

ความปลอดภัย HTTP แบบสตรีมได้

การตรวจสอบสิทธิ์แบบ Lazy: การค้นพบเครื่องมือไม่จำเป็นต้องมีการตรวจสอบสิทธิ์ ปรับปรุงความเข้ากันได้
ความปลอดภัยของเซสชัน: การสร้าง ID เซสชันที่ปลอดภัยด้วยการเข้ารหัส
การป้องกัน CORS: ส่วนหัว CORS ที่กำหนดค่าได้สำหรับการเข้าถึงเว็บ
การจำกัดขนาดคำขอ: ป้องกัน DoS ผ่านเพย์โหลดขนาดใหญ่

ยูทิลิตี้ด้านความปลอดภัย

โมดูล security-utils.ts เฉพาะให้บริการ:

การตรวจสอบโทเค็น Bearer
การตรวจสอบ URL พร้อมการป้องกัน SSRF
การทำความสะอาดอาร์กิวเมนต์คำสั่ง
การตรวจสอบตัวแปรสภาพแวดล้อม
การนำการจำกัดอัตราไปใช้
การทำความสะอาดข้อความแสดงข้อผิดพลาด

สำหรับการนำความปลอดภัยไปใช้โดยละเอียด ดู SECURITY.md

🧩 การรวมเข้ากับแอป plugged.in

MCP Proxy Server ของ plugged.in ถูกออกแบบมาให้ทำงานร่วมกับ แอป plugged.in ได้อย่างราบรื่น ซึ่งให้บริการ:

อินเทอร์เฟซบนเว็บสำหรับจัดการการกำหนดค่าเซิร์ฟเวอร์ MCP
การค้นพบความสามารถแบบรวมศูนย์ (เครื่องมือ ทรัพยากร เทมเพลต พรอมต์)
RAG v2 Document Library: อัปโหลดเอกสารและเปิดใช้งานเนื้อหาที่สร้างโดย AI พร้อมการระบุแหล่งที่มาอย่างครบถ้วน
การจัดการคำสั่งที่กำหนดเอง
การสนับสนุนหลายพื้นที่ทำงานสำหรับชุดการกำหนดค่าที่แตกต่างกัน
สนามเด็กเล่นแบบโต้ตอบสำหรับทดสอบเครื่องมือ MCP กับโมเดล AI ใดๆ
การตรวจสอบสิทธิ์ผู้ใช้และการจัดการ API key
AI Document Exchange: สร้าง ค้นหา และจัดการเอกสารด้วยการติดตามการระบุแหล่งที่มาของโมเดล

📚 แหล่งข้อมูลที่เกี่ยวข้อง

🤝 การมีส่วนร่วม

ยินดีต้อนรับการมีส่วนร่วม! โปรดส่ง Pull Request ได้ตามสบาย

📝 การอัปเดตล่าสุด

เวอร์ชัน 1.9.0 (กันยายน 2025) - การปรับปรุงความปลอดภัย

🔒 การทำความสะอาด HTML ที่ปรับปรุงแล้ว

การทำความสะอาดมาตรฐานอุตสาหกรรม: แทนที่การทำความสะอาด HTML แบบ regex ที่กำหนดเองด้วยไลบรารี sanitize-html
การป้องกัน XSS: การป้องกันที่ครอบคลุมต่อการโจมตี cross-site scripting
ความปลอดภัยของแอตทริบิวต์ HTML: การทำความสะอาดที่ปรับปรุงแล้วสำหรับบริบทแอตทริบิวต์ HTML (เครื่องหมายคำพูด, แอมเพอร์แซนด์)
การแทรกสตริงรูปแบบ: แก้ไขช่องโหว่การแทรกสตริงรูปแบบในการบันทึก
การทดสอบความปลอดภัย: ความครอบคลุมการทดสอบที่ครอบคลุมสำหรับฟังก์ชันการทำความสะอาดทั้งหมด

🛡️ การปรับปรุงความปลอดภัย

การปฏิบัติตาม CodeQL: แก้ไขช่องโหว่ด้านความปลอดภัยทั้งหมดที่ระบุโดยการวิเคราะห์ GitHub CodeQL
การตรวจสอบอินพุต: เสริมสร้างการตรวจสอบและทำความสะอาดอินพุตในทุกฟังก์ชัน
การอัปเดตการพึ่งพา: เพิ่ม sanitize-html สำหรับการกรองเนื้อหา HTML ที่แข็งแกร่ง
ความครอบคลุมการทดสอบ: ปรับปรุงชุดทดสอบความปลอดภัยด้วยการตรวจสอบการป้องกันการโจมตี XSS

เวอร์ชัน 1.5.0 (มกราคม 2025) - RAG v2

🤖 AI Document Exchange

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

🔍 ความสามารถ RAG ที่ปรับปรุงแล้ว

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

เวอร์ชัน 1.2.0 (มกราคม 2025)

🔒 การปรับปรุงความปลอดภัย

การตรวจสอบ URL: การป้องกัน SSRF ที่ครอบคลุม บล็อก IP ส่วนตัว, localhost และพอร์ตที่เป็นอันตราย
รายการอนุญาตคำสั่ง: เฉพาะคำสั่งที่ได้รับอนุมัติ (node, npx, python ฯลฯ) เท่านั้นที่สามารถดำเนินการได้
การทำความสะอาดส่วนหัว: การป้องกันการโจมตีการแทรกส่วนหัว
การตรวจสอบสิทธิ์แบบ Lazy: ปรับปรุงความเข้ากันได้กับ Smithery ด้วยการค้นพบเครื่องมือที่ไม่ต้องตรวจสอบสิทธิ์

🚀 การปรับปรุงประสิทธิภาพ

การสร้าง Docker ที่เหมาะสมที่สุด: การสร้างแบบหลายขั้นตอนเพื่อขนาดคอนเทนเนอร์ที่น้อยที่สุด
เฉพาะการพึ่งพาการผลิต: ไฟล์ทดสอบและการพึ่งพาการพัฒนาถูกแยกออกจากอิมเมจ Docker
ประสิทธิภาพของทรัพยากร: ออกแบบมาสำหรับการปรับใช้ในสภาพแวดล้อมที่มีทรัพยากรจำกัด

🔧 การปรับปรุงทางเทคนิค

การจัดการข้อผิดพลาดที่ปรับปรุงแล้วในการขนส่ง HTTP แบบสตรีมได้
การล้างเซสชันและการจัดการหน่วยความจำที่ดีขึ้น
ประเภท TypeScript และการจัดระเบียบโค้ดที่ปรับปรุงแล้ว

เวอร์ชัน 1.1.0 (ธันวาคม 2024)

🚀 คุณสมบัติใหม่

การสนับสนุน HTTP แบบสตรีมได้: เชื่อมต่อกับเซิร์ฟเวอร์ MCP ปลายทางโดยใช้การขนส่ง HTTP แบบสตรีมได้ที่ทันสมัย
โหมดเซิร์ฟเวอร์ HTTP: รันพร็อกซีเป็นเซิร์ฟเวอร์ HTTP สำหรับการเข้าถึงผ่านเว็บ
การจัดการเซสชันที่ยืดหยุ่น: เลือกระหว่างโหมดไร้สถานะหรือมีสถานะ
ตัวเลือกการตรวจสอบสิทธิ์: การตรวจสอบสิทธิ์โทเค็น Bearer เสริมสำหรับ HTTP endpoints
การตรวจสอบสถานะ: /health endpoint สำหรับการตรวจสอบบริการ

🔧 การปรับปรุงทางเทคนิค

อัปเดต MCP SDK เป็น v1.13.1 สำหรับการสนับสนุนโปรโตคอลล่าสุด
เพิ่มการรวม Express.js สำหรับฟังก์ชันเซิร์ฟเวอร์ HTTP
ประเภท TypeScript ที่ปรับปรุงแล้วเพื่อประสบการณ์นักพัฒนาที่ดีขึ้น

เวอร์ชัน 1.0.0 (มิถุนายน 2025)

🎯 คุณสมบัติหลัก

ระบบการแจ้งเตือนแบบเรียลไทม์: ติดตามกิจกรรม MCP ทั้งหมดด้วยการสนับสนุนการแจ้งเตือนที่ครอบคลุม
การรวม RAG: การสนับสนุนการสืบค้นที่ปรับปรุงด้วยเอกสารผ่านแอป plugged.in
สคริปต์ตรวจสอบ: เครื่องมือทดสอบอัตโนมัติใหม่สำหรับการดีบักและการพัฒนา
การตรวจสอบสถานะ: ping endpoint ในตัวสำหรับการตรวจสอบการเชื่อมต่อ

🔒 การปรับปรุงความปลอดภัย

การตรวจสอบอินพุต: การตรวจสอบและทำความสะอาดมาตรฐานอุตสาหกรรมสำหรับอินพุตทั้งหมด
ความปลอดภัยของ URL: การตรวจสอบ URL ที่ปรับปรุงแล้วพร้อมการป้องกัน SSRF
ความปลอดภัยของสภาพแวดล้อม: การแยกวิเคราะห์ตัวแปรสภาพแวดล้อมอย่างปลอดภัยด้วย dotenv
การทำความสะอาดข้อผิดพลาด: ป้องกันการเปิดเผยข้อมูลในการตอบสนองข้อผิดพลาด

🐛 การแก้ไขข้อบกพร่อง

แก้ไขการรบกวนโปรโตคอล JSON-RPC (การแยก stdout กับ stderr)
แก้ไขการตรวจสอบ URL localhost สำหรับสภาพแวดล้อมการพัฒนา
แก้ไขการจัดการ API key ในสคริปต์ตรวจสอบ
ปรับปรุงเสถียรภาพการเชื่อมต่อและการจัดการหน่วยความจำ

🔧 เครื่องมือสำหรับนักพัฒนา

สคริปต์ตรวจสอบใหม่สำหรับการทดสอบอัตโนมัติ
ข้อความแสดงข้อผิดพลาดและความสามารถในการดีบักที่ปรับปรุงแล้ว
การบันทึกที่มีโครงสร้างด้วยการใช้ stderr อย่างเหมาะสม
ความปลอดภัยของประเภท TypeScript ที่ปรับปรุงแล้ว

ดู บันทึกประจำรุ่น สำหรับรายละเอียดทั้งหมด

🧪 การทดสอบและการพัฒนา

การพัฒนาในเครื่อง

การทดสอบรวมอยู่เพื่อวัตถุประสงค์ในการพัฒนา แต่ถูกแยกออกจากการสร้าง Docker เพื่อลดขนาดคอนเทนเนอร์

# Run tests locally
npm test
# or
./scripts/test-local.sh

# Run tests in watch mode
npm run test:watch

# Run tests with UI
npm run test:ui

การสร้าง Docker แบบเบา

อิมเมจ Docker ถูกปรับให้เหมาะสมเพื่อขนาดที่น้อยที่สุด:

กระบวนการสร้างแบบหลายขั้นตอน
เฉพาะการพึ่งพาการผลิตในอิมเมจสุดท้าย
ไฟล์ทดสอบและการพึ่งพาการพัฒนาถูกแยกออก
ปรับให้เหมาะสมสำหรับสภาพแวดล้อมที่มีทรัพยากรจำกัด

# Build optimized Docker image
docker build -t pluggedin-mcp .

# Check image size
docker images pluggedin-mcp

📄 ใบอนุญาต

โครงการนี้ได้รับอนุญาตภายใต้ MIT License - ดูไฟล์ LICENSE สำหรับรายละเอียด

🙏 กิตติกรรมประกาศ

ได้รับแรงบันดาลใจจาก MCP Proxy Server
สร้างขึ้นบน Model Context Protocol