YepCode MCP Server

YepCode MCP Server คืออะไร?

เซิร์ฟเวอร์ MCP (Model Context Protocol) ที่ช่วยให้แพลตฟอร์ม AI สามารถโต้ตอบกับโครงสร้างพื้นฐานของ YepCode ได้ รันสคริปต์ที่สร้างโดย LLM และเปลี่ยนกระบวนการ YepCode ของคุณให้เป็นเครื่องมือทรงพลังที่ผู้ช่วย AI สามารถใช้งานได้โดยตรง YepCode คือสภาพแวดล้อมที่สมบูรณ์แบบสำหรับการสร้าง เซิร์ฟเวอร์เครื่องมือ MCP แบบไดนามิก: เปิดเผยแต่ละกระบวนการเป็นเครื่องมือ (ด้วย OAuth, API tokens หรือข้อมูลประจำตัวของคุณ), กำหนดพารามิเตอร์ของแต่ละเครื่องมือด้วย JSON Schema เพื่อความยืดหยุ่นสูงสุด และนำเครื่องมือไปใช้ใน Python หรือ Node.js — ทั้งหมดในเซิร์ฟเวอร์เดียวที่ผสมผสานหลายภาษา

ทำไมต้อง YepCode MCP Server?

• การผสานรวม AI อย่างไร้รอยต่อ: แปลงกระบวนการ YepCode เป็นเครื่องมือที่พร้อมใช้กับ AI โดยไม่ต้องตั้งค่าใดๆ
• การควบคุมกระบวนการแบบเรียลไทม์: เปิดใช้งานการโต้ตอบโดยตรงระหว่างระบบ AI และเวิร์กโฟลว์ของคุณ
• ความปลอดภัยระดับองค์กร: รันโค้ดในสภาพแวดล้อมที่แยกส่วนและพร้อมใช้งานจริงของ YepCode
• ความเข้ากันได้สากล: ผสานรวมกับแพลตฟอร์ม AI ใดๆ ที่รองรับ Model Context Protocol

YepCode: สภาพแวดล้อมที่สมบูรณ์แบบสำหรับเซิร์ฟเวอร์เครื่องมือ MCP แบบไดนามิก

YepCode ถูกสร้างขึ้นเพื่อเป็นแพลตฟอร์มในอุดมคติสำหรับการรัน เซิร์ฟเวอร์เครื่องมือ MCP แบบไดนามิก:

• หนึ่งกระบวนการ หนึ่งเครื่องมือ: แต่ละกระบวนการ YepCode สามารถเปิดเผยเป็นเครื่องมือ MCP ได้ แท็กกระบวนการของคุณ (เช่น mcp-tool, core, automation) แล้วมันจะกลายเป็นเครื่องมือที่ผู้ช่วย AI สามารถเรียกใช้ได้ คุณสามารถรักษาความปลอดภัยการเข้าถึงด้วย OAuth, API tokens หรือข้อมูลประจำตัว YepCode ที่มีอยู่ — แต่ละเครื่องมือทำงานในพื้นที่ทำงานของคุณด้วยโมเดลความปลอดภัยเดียวกัน

• ควบคุมพารามิเตอร์ของเครื่องมือได้อย่างเต็มที่: ทุกเครื่องมือสามารถกำหนด สคีมาพารามิเตอร์ของตัวเองเป็น JSON Schema คุณได้รับความยืดหยุ่นอย่างสมบูรณ์ในการอธิบายอินพุต (ประเภท, คำอธิบาย, ฟิลด์ที่จำเป็น, enums, ค่าเริ่มต้น ฯลฯ) เพื่อให้ AI ได้รับข้อมูลเมตาที่สมบูรณ์และสามารถเรียกใช้เครื่องมือของคุณได้อย่างถูกต้อง

• การนำเครื่องมือไปใช้แบบหลายภาษา: นำเครื่องมือไปใช้ใน Python หรือ Node.js (หรือทั้งสองอย่าง) เซิร์ฟเวอร์ MCP เดียวกันสามารถเปิดเผยเครื่องมือที่รองรับโดยรันไทม์ที่แตกต่างกัน — คิดว่ามันเป็นเซิร์ฟเวอร์ MCP หนึ่งที่ผสมผสานการนำไปใช้ข้ามหลายภาษา

สำหรับเอกสารฉบับสมบูรณ์ ดูที่ เอกสาร YepCode MCP Server

การติดตั้ง

แพ็คเกจนี้อนุญาตให้คุณรันเซิร์ฟเวอร์ YepCode MCP ภายในเครื่อง หรือในโครงสร้างพื้นฐานของคุณเอง (NPX, Docker หรือการปรับใช้แบบกำหนดเอง) ผสานรวมกับแพลตฟอร์ม AI เช่น Cursor หรือ Claude Desktop

เคล็ดลับ: จากบัญชี YepCode ของคุณ คุณยังสามารถเข้าถึงเซิร์ฟเวอร์ MCP แบบโฮสต์ที่ไม่ต้องติดตั้งภายในเครื่อง URL การเชื่อมต่อคือ: https://cloud.yepcode.io/mcp เสมอ

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

รับข้อมูลประจำตัว API ของ YepCode:

1. ลงทะเบียนที่ YepCode Cloud
2. ไปที่ Settings > API credentials เพื่อสร้าง API token ใหม่

การใช้ NPX

ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง Node.js (เวอร์ชัน 18 ขึ้นไป) และใช้การกำหนดค่าที่คล้ายกับต่อไปนี้:

{
  "mcpServers": {
    "yepcode-mcp-server": {
      "command": "npx",
      "args": ["-y", "@yepcode/mcp-server"],
      "env": {
        "YEPCODE_API_TOKEN": "your_api_token_here"
      }
    }
  }
}

การใช้ Docker

1. สร้างอิมเมจคอนเทนเนอร์:

docker build -t yepcode/mcp-server .

2. ใช้การกำหนดค่าที่คล้ายกับต่อไปนี้:

{
  "mcpServers": {
    "yepcode-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-d",
        "-e",
        "YEPCODE_API_TOKEN=your_api_token_here",
        "yepcode/mcp-server"
      ]
    }
  }
}

การดีบัก

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

npm run inspector

สิ่งนี้จะเริ่มเซิร์ฟเวอร์ที่คุณสามารถเข้าถึงเครื่องมือดีบักได้โดยตรงในเบราว์เซอร์ของคุณ

ข้อมูลอ้างอิงเครื่องมือ YepCode MCP

เซิร์ฟเวอร์ MCP มีเครื่องมือหลายอย่างเพื่อโต้ตอบกับโครงสร้างพื้นฐานของ YepCode:

การรันโค้ด

run_code

รันโค้ดในสภาพแวดล้อมที่ปลอดภัยของ YepCode

// Input
{
  code: string;                          // The code to execute
  options?: {
    language?: string;                   // Programming language (default: 'javascript')
    comment?: string;                    // Execution context
    settings?: Record<string, unknown>;  // Runtime settings
  }
}

// Response
{
  returnValue?: unknown;                 // Execution result
  logs?: string[];                       // Console output
  error?: string;                        // Error message if execution failed
}

ตัวเลือก MCP

เซิร์ฟเวอร์ YepCode MCP รองรับตัวเลือกต่อไปนี้:

• runCodeCleanup: ข้ามการล้างข้อมูล run_code ตามค่าเริ่มต้น ซอร์สโค้ดของกระบวนการ run_code จะถูกลบหลังจากการรัน หากคุณต้องการเก็บไว้เพื่อวัตถุประสงค์ในการตรวจสอบ คุณสามารถใช้ตัวเลือกนี้ได้
• skipCodingRules: ข้ามการรวมกฎการเขียนโค้ดในคำจำกัดความเครื่องมือ run_code ตามค่าเริ่มต้น กฎการเขียนโค้ด JavaScript และ Python จากเอกสาร YepCode จะรวมอยู่ในสคีมาเครื่องมือเพื่อแนะนำโค้ดที่สร้างโดย AI หากคุณต้องการข้ามสิ่งนี้เพื่อการเริ่มต้นเครื่องมือที่เร็วขึ้นหรือคำจำกัดความเครื่องมือที่เล็กลง คุณสามารถใช้ตัวเลือกนี้ได้

สามารถส่งตัวเลือกเป็นรายการที่คั่นด้วยเครื่องหมายจุลภาคในตัวแปรสภาพแวดล้อม YEPCODE_MCP_OPTIONS

การเลือกเครื่องมือ

คุณสามารถควบคุมว่าเครื่องมือใดถูกเปิดใช้งานโดยการตั้งค่าตัวแปรสภาพแวดล้อม YEPCODE_MCP_TOOLS ด้วยรายการหมวดหมู่เครื่องมือและแท็กกระบวนการที่คั่นด้วยเครื่องหมายจุลภาค:

หมวดหมู่เครื่องมือในตัว:

• run_code: เปิดใช้งานเครื่องมือการรันโค้ด
• yc_api: เปิดใช้งานเครื่องมือการจัดการ API พื้นฐานทั้งหมด (กระบวนการ, ตารางเวลา, ตัวแปร, ที่เก็บข้อมูล, การรัน, โมดูล)
• yc_api_full: เปิดใช้งานเครื่องมือการจัดการ API ทั้งหมดรวมถึงเครื่องมือที่เกี่ยวข้องกับเวอร์ชัน (ขยาย yc_api ด้วยเครื่องมือการจัดการเวอร์ชันกระบวนการและโมดูลเพิ่มเติม)
• ชื่อเครื่องมือ API เฉพาะใดๆ (เช่น execute_process_sync, get_execution,...)

แท็กกระบวนการ:

• แท็กใดๆ ที่ใช้ในกระบวนการ YepCode ของคุณ (เช่น mcp-tool, core, automation ฯลฯ)
• เมื่อคุณระบุแท็กกระบวนการ กระบวนการทั้งหมดที่มีแท็กนั้นจะถูกเปิดเผยเป็นเครื่องมือ MCP แต่ละตัว
• เครื่องมือกระบวนการจะถูกตั้งชื่อโดยใช้ slug ของกระบวนการ (หรือขึ้นต้นด้วย yc_ และ ID กระบวนการหากชื่อยาวเกิน 60 ตัวอักษร)

หากไม่ได้ระบุ เครื่องมือในตัวทั้งหมดจะถูกเปิดใช้งานตามค่าเริ่มต้น แต่จะไม่มีเครื่องมือกระบวนการใดถูกเปิดเผย

// NPX configuration with options
{
  "mcpServers": {
    "yepcode-mcp-server": {
      "command": "npx",
      "args": ["-y", "@yepcode/mcp-server"],
      "env": {
        "YEPCODE_API_TOKEN": "your_api_token_here",
        "YEPCODE_MCP_OPTIONS": "runCodeCleanup,skipCodingRules",
        "YEPCODE_MCP_TOOLS": "run_code,yc_api,mcp-tool,core"
      }
    }
  }
}

สถานการณ์ตัวอย่าง:

• YEPCODE_MCP_TOOLS=run_code,yc_api - เปิดใช้งานการรันโค้ดในตัวและเครื่องมือการจัดการ API พื้นฐาน
• YEPCODE_MCP_TOOLS=run_code,yc_api_full - เปิดใช้งานการรันโค้ดในตัวและเครื่องมือการจัดการ API ทั้งหมด (รวมถึงการจัดการเวอร์ชัน)
• YEPCODE_MCP_TOOLS=core,automation - เปิดเผยเฉพาะกระบวนการที่แท็กด้วย "core" หรือ "automation" เป็นเครื่องมือ
• YEPCODE_MCP_TOOLS=run_code,yc_api,core - เปิดใช้งานเครื่องมือในตัวบวกกับกระบวนการทั้งหมดที่แท็กด้วย "core"

การจัดการสภาพแวดล้อม

set_env_var

ตั้งค่าตัวแปรสภาพแวดล้อมในพื้นที่ทำงาน YepCode

// Input
{
  key: string;                           // Variable name
  value: string;                         // Variable value
  isSensitive?: boolean;                 // Whether to mask the value in logs (default: true)
}

remove_env_var

ลบตัวแปรสภาพแวดล้อมออกจากพื้นที่ทำงาน YepCode

// Input
{
  key: string;                           // Name of the variable to remove
}

การจัดการที่เก็บข้อมูล

YepCode มีระบบที่เก็บข้อมูลในตัวที่อนุญาตให้คุณอัปโหลด แสดงรายการ ดาวน์โหลด และลบไฟล์ ไฟล์เหล่านี้สามารถเข้าถึงได้จากการรันโค้ดของคุณโดยใช้เมธอดตัวช่วย yepcode.storage

list_files

แสดงรายการไฟล์ทั้งหมดในที่เก็บข้อมูล YepCode ของคุณ

// Input
{
  prefix?: string;                       // Optional prefix to filter files
}

// Response
{
  files: Array<{
    filename: string;                    // File name or path
    size: number;                        // File size in bytes
    lastModified: string;                // Last modification date
  }>;
}

upload_file

อัปโหลดไฟล์ไปยังที่เก็บข้อมูล YepCode

// Input
{
  filename: string;                      // File path (e.g., 'file.txt' or 'folder/file.txt')
  content: string | {                   // File content
    data: string;                        // Base64 encoded content for binary files
    encoding: "base64";
  };
}

// Response
{
  success: boolean;                      // Upload success status
  filename: string;                      // Uploaded file path
}

download_file

ดาวน์โหลดไฟล์จากที่เก็บข้อมูล YepCode

// Input
{
  filename: string;                      // File path to download
}

// Response
{
  filename: string;                      // File path
  content: string;                       // File content (base64 for binary files)
  encoding?: string;                     // Encoding type if binary
}

delete_file

ลบไฟล์ออกจากที่เก็บข้อมูล YepCode

// Input
{
  filename: string;                      // File path to delete
}

// Response
{
  success: boolean;                      // Deletion success status
  filename: string;                      // Deleted file path
}

การรันกระบวนการ

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

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

1. แท็กกระบวนการ YepCode ของคุณด้วยแท็กใดๆ (เช่น core, api, automation, mcp-tool ฯลฯ)
2. เพิ่มแท็กเหล่านั้นลงในตัวแปรสภาพแวดล้อม YEPCODE_MCP_TOOLS
3. กระบวนการทั้งหมดที่มีแท็กที่ระบุจะถูกเปิดเผยเป็นเครื่องมือ MCP แต่ละตัว

จะมีเครื่องมือสำหรับแต่ละกระบวนการที่เปิดเผยโดยตั้งชื่อโดยใช้ slug ของกระบวนการ (หรือขึ้นต้นด้วย yc_ และ ID กระบวนการหากชื่อเครื่องมือยาวเกิน 60 ตัวอักษร)

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับแท็กกระบวนการ ดูที่ เอกสารแท็กกระบวนการ ของเรา

<process_slug>

// Input
{
  parameters?: any;                      // This should match the input parameters specified in the process
  options?: {
    tag?: string;                        // Process version to execute
    comment?: string;                    // Execution context
  };
  synchronousExecution?: boolean;        // Whether to wait for completion (default: true)
}

// Response (synchronous execution)
{
  executionId: string;                   // Unique execution identifier
  logs: string[];                        // Process execution logs
  returnValue?: unknown;                 // Process output
  error?: string;                        // Error message if execution failed
}

// Response (asynchronous execution)
{
  executionId: string;                   // Unique execution identifier
}

เครื่องมือการจัดการ API

หมวดหมู่เครื่องมือการจัดการ API (yc_api และ yc_api_full) ให้การเข้าถึง API ที่ครอบคลุมเพื่อจัดการทุกด้านของพื้นที่ทำงาน YepCode ของคุณ:

เครื่องมือ API พื้นฐาน (yc_api): แท็ก yc_api เปิดใช้งานเครื่องมือการจัดการ API มาตรฐานสำหรับการดำเนินการหลักทั่วทั้งพื้นที่ทำงานของคุณ

เครื่องมือ API แบบขยาย (yc_api_full): แท็ก yc_api_full รวมทุกอย่างจาก yc_api บวกกับเครื่องมือเพิ่มเติมสำหรับการจัดการเวอร์ชันกระบวนการและโมดูล

การจัดการกระบวนการ:

• get_processes - แสดงรายการกระบวนการพร้อมการกรองที่เป็นตัวเลือก
• create_process - สร้างกระบวนการใหม่ด้วยซอร์สโค้ด
• get_process - รับรายละเอียดกระบวนการ
• update_process - อัปเดตกระบวนการที่มีอยู่
• delete_process - ลบกระบวนการ
• get_process_versions - รับเวอร์ชันกระบวนการ (ต้องการ yc_api_full)
• execute_process_async - รันกระบวนการแบบอะซิงโครนัส
• execute_process_sync - รันกระบวนการแบบซิงโครนัส
• schedule_process - กำหนดเวลากระบวนการให้รันโดยอัตโนมัติ

การจัดการตารางเวลา:

• get_schedules - แสดงรายการกระบวนการที่กำหนดเวลาไว้
• get_schedule - รับรายละเอียดตารางเวลา
• pause_schedule - หยุดกระบวนการที่กำหนดเวลาไว้ชั่วคราว
• resume_schedule - ดำเนินการต่อตารางเวลาที่หยุดไว้
• delete_schedule - ลบตารางเวลา
• update_schedule - อัปเดตกระบวนการที่กำหนดเวลาไว้

การจัดการตัวแปร:

• get_variables - แสดงรายการตัวแปรทีม
• create_variable - สร้างตัวแปรใหม่
• update_variable - อัปเดตตัวแปรที่มีอยู่
• delete_variable - ลบตัวแปร

การจัดการที่เก็บข้อมูล:

• get_storage_objects - แสดงรายการออบเจกต์ที่เก็บข้อมูล
• upload_storage_object - อัปโหลดไฟล์ไปยังที่เก็บข้อมูล
• download_storage_object - ดาวน์โหลดไฟล์จากที่เก็บข้อมูล
• delete_storage_object - ลบไฟล์ออกจากที่เก็บข้อมูล

การจัดการการรัน:

• get_executions - แสดงรายการการรันพร้อมการกรองที่เป็นตัวเลือก
• get_execution - รับรายละเอียดการรันจาก API
• kill_execution - ฆ่าการรันที่กำลังทำงานอยู่
• rerun_execution - รันการรันก่อนหน้าอีกครั้ง
• get_execution_logs - รับบันทึกการรัน

การจัดการโมดูล:

• get_modules - แสดงรายการโมดูลไลบรารีสคริปต์
• create_module - สร้างโมดูลใหม่
• get_module - รับรายละเอียดโมดูล
• delete_module - ลบโมดูล
• get_module_versions - รับเวอร์ชันโมดูล (ต้องการ yc_api_full)
• get_module_version - รับเวอร์ชันโมดูลเฉพาะ (ต้องการ yc_api_full)
• delete_module_version - ลบเวอร์ชันโมดูล (ต้องการ yc_api_full)
• get_module_aliases - รับนามแฝงเวอร์ชันโมดูล (ต้องการ yc_api_full)

ใบอนุญาต

โปรเจกต์นี้ได้รับอนุญาตภายใต้ MIT License - ดูรายละเอียดได้ที่ไฟล์ LICENSE