YepCode

ทางการ

ดำเนินการโค้ดที่สร้างโดย LLM ในสภาพแวดล้อมแซนด์บ็อกซ์ที่ปลอดภัยและปรับขนาดได้ของ YepCode และสร้างเครื่องมือ MCP ของคุณเองโดยใช้ JavaScript หรือ Python พร้อมรองรับแพ็กเกจ NPM และ PyPI อย่างเต็มรูปแบบ

GitHub

คุณทำอะไรได้บ้างด้วย YepCode MCP?

Execute code in a secure sandbox — ให้ผู้ช่วยรันโค้ด JavaScript หรือ Python ผ่าน run_code และส่งคืนบันทึกและผลลัพธ์
Expose tagged YepCode processes as AI-callable tools — กำหนดค่า YEPCODE_MCP_TOOLS ด้วยแท็กกระบวนการ เพื่อให้ผู้ช่วยสามารถเรียกใช้กระบวนการที่กำหนดเองของคุณได้โดยตรง
Manage workspace environment variables — ใช้ set_env_var และ remove_env_var เพื่อสร้าง อัปเดต หรือลบตัวแปรที่กระบวนการของคุณต้องพึ่งพา
Operate YepCode storage files — แสดงรายการ อัปโหลด ดาวน์โหลด หรือลบไฟล์ในพื้นที่จัดเก็บของเวิร์กสเปซผ่าน list_files, upload_file, download_file และ delete_file
Control process executions and schedules — แสดงรายการ รัน กำหนดเวลา หยุดชั่วคราว ดำเนินการต่อ หรือหยุดกระบวนการโดยใช้เครื่องมือจัดการ API ภายใต้ yc_api
Administer modules and versions — สร้าง อัปเดต ลบ และกำหนดเวอร์ชันโมดูลไลบรารีสคริปต์ด้วยชุดเครื่องมือ yc_api_full ที่ขยายเพิ่ม

เอกสาร

YepCode MCP Server Preview

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:

ลงทะเบียนที่ YepCode Cloud
ไปที่ 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

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

docker build -t yepcode/mcp-server .

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

{
  "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

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

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