ZenML MCP Server

ทางการ

โต้ตอบกับไปป์ไลน์ MLOps และ LLMOps ของคุณผ่านเซิร์ฟเวอร์ ZenML MCP

เอกสาร

MCP Server สำหรับ ZenML

โปรเจกต์นี้ใช้งาน Model Context Protocol (MCP) server สำหรับการโต้ตอบกับ ZenML API

ZenML MCP Server

MCP คืออะไร?

Model Context Protocol (MCP) เป็นโปรโตคอลแบบเปิดที่กำหนดมาตรฐานวิธีที่ แอปพลิเคชันให้บริบทแก่ Large Language Models (LLMs) มันทำหน้าที่เหมือน "พอร์ต USB-C สำหรับแอปพลิเคชัน AI" - มอบวิธีที่เป็นมาตรฐานในการเชื่อมต่อโมเดล AI กับแหล่งข้อมูลและเครื่องมือต่างๆ

MCP ใช้สถาปัตยกรรมแบบ client-server โดยที่:

MCP Hosts: โปรแกรมอย่าง Claude Desktop หรือ IDE ที่ต้องการเข้าถึงข้อมูลผ่าน MCP
MCP Clients: โปรโตคอลไคลเอนต์ที่รักษาการเชื่อมต่อแบบ 1:1 กับเซิร์ฟเวอร์
MCP Servers: โปรแกรมน้ำหนักเบาที่เปิดเผยความสามารถเฉพาะผ่านโปรโตคอลมาตรฐาน
Local Data Sources: ไฟล์ ฐานข้อมูล และบริการในคอมพิวเตอร์ของคุณที่ MCP servers สามารถเข้าถึงได้อย่างปลอดภัย
Remote Services: ระบบภายนอกที่พร้อมใช้งานผ่านอินเทอร์เน็ตที่ MCP servers สามารถเชื่อมต่อได้

ZenML คืออะไร?

ZenML เป็นแพลตฟอร์มโอเพนซอร์สสำหรับการสร้างและจัดการไปป์ไลน์ ML และ AI มันมีอินเทอร์เฟซแบบรวมสำหรับการจัดการข้อมูล โมเดล และการทดลอง

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

คุณสมบัติ

เซิร์ฟเวอร์มีเครื่องมือ MCP เพื่อเข้าถึงฟังก์ชันการอ่านหลักจากเซิร์ฟเวอร์ ZenML ซึ่งเป็นวิธีในการรับข้อมูลสดเกี่ยวกับ:

เอนทิตีหลัก

Users - บัญชีผู้ใช้และสิทธิ์
Stacks - การกำหนดค่าโครงสร้างพื้นฐาน
Stack Components - บล็อกการสร้างสแต็กแต่ละรายการ
Flavors - ประเภทคอมโพเนนต์ที่พร้อมใช้งาน
Service Connectors - การตรวจสอบสิทธิ์คลาวด์

การดำเนินการไปป์ไลน์

Pipelines - คำจำกัดความของไปป์ไลน์
Pipeline Runs - ประวัติการดำเนินการและสถานะ
Pipeline Steps - รายละเอียดขั้นตอนแต่ละรายการ โค้ด และบันทึก
Schedules - ตารางการรันอัตโนมัติ
Artifacts - ข้อมูลเมตาเกี่ยวกับอาร์ติแฟกต์ข้อมูล (ไม่ใช่ตัวข้อมูลเอง)

การปรับใช้และการให้บริการ

Snapshots - การกำหนดค่าไปป์ไลน์ที่ถูกแช่แข็ง (อาร์ติแฟกต์ "สิ่งที่จะรัน/ให้บริการ")
Deployments - อินสแตนซ์การให้บริการรันไทม์พร้อมสถานะ URL และบันทึก
Services - ปลายทางการให้บริการโมเดล

การจัดระเบียบและการค้นพบ

Projects - คอนเทนเนอร์องค์กรสำหรับทรัพยากร ZenML
Tags - ป้ายกำกับข้อมูลเมตาข้ามส่วนเพื่อการค้นพบ
Builds - อาร์ติแฟกต์การสร้างไปป์ไลน์พร้อมข้อมูลอิมเมจและโค้ด

โมเดล

Models - รายการรีจิสทรีโมเดล ML
Model Versions - อาร์ติแฟกต์โมเดลที่มีเวอร์ชัน

เลิกใช้งานแล้ว (แนะนำให้ย้าย)

~~Pipeline run templates~~ → ใช้ Snapshots แทน (ดู คู่มือการย้าย)

เซิร์ฟเวอร์ยังอนุญาตให้คุณ ทริกเกอร์การรันไปป์ไลน์ใหม่ โดยใช้ snapshots (แนะนำ) หรือ run templates (เลิกใช้งานแล้ว)

หมายเหตุ: เรากำลังปรับปรุงการผสานรวมนี้อย่างต่อเนื่องตามความคิดเห็นของผู้ใช้ โปรดเข้าร่วม ชุมชน Slack ของเราเพื่อแบ่งปันประสบการณ์ของคุณ และช่วยเราทำให้ดียิ่งขึ้น!

เครื่องมือที่พร้อมใช้งาน

เซิร์ฟเวอร์ MCP มีเครื่องมือต่อไปนี้ จัดกลุ่มตามหมวดหมู่:

การดำเนินการไปป์ไลน์ (ใหม่ใน v1.2)

เครื่องมือ	คำอธิบาย
`get_snapshot`	รับการกำหนดค่าไปป์ไลน์ที่ถูกแช่แข็งตามชื่อ/ID
`list_snapshots`	แสดงรายการ snapshots พร้อมตัวกรอง (runnable, deployable, deployed, tag)
`get_deployment`	รับสถานะรันไทม์และ URL ของการปรับใช้
`list_deployments`	แสดงรายการ deployments พร้อมตัวกรอง (status, pipeline, tag)
`get_deployment_logs`	รับบันทึกที่มีขอบเขตจากการปรับใช้ (tail=100 ค่าเริ่มต้น, สูงสุด 1000)
`trigger_pipeline`	ทริกเกอร์การรันไปป์ไลน์ (แนะนำให้ใช้พารามิเตอร์ `snapshot_name_or_id`)

การจัดระเบียบ (ใหม่ใน v1.2)

เครื่องมือ	คำอธิบาย
`get_active_project`	รับโปรเจกต์ที่ใช้งานอยู่ในปัจจุบัน
`get_project`	รับรายละเอียดโปรเจกต์ตามชื่อ/ID
`list_projects`	แสดงรายการโปรเจกต์ทั้งหมด
`get_tag`	รับรายละเอียดแท็ก (exclusive, colors)
`list_tags`	แสดงรายการแท็กพร้อมตัวกรอง (resource_type)
`get_build`	รับรายละเอียดบิลด์ (image, code embedding)
`list_builds`	แสดงรายการบิลด์พร้อมตัวกรอง (is_local, contains_code)

เอนทิตีหลัก

เครื่องมือ	คำอธิบาย
`get_user`, `list_users`, `get_active_user`	การจัดการผู้ใช้
`get_stack`, `list_stacks`	การกำหนดค่าสแต็ก
`get_stack_component`, `list_stack_components`	คอมโพเนนต์สแต็ก
`get_flavor`, `list_flavors`	ฟลาวเวอร์คอมโพเนนต์
`get_service_connector`, `list_service_connectors`	ตัวเชื่อมต่อคลาวด์
`get_pipeline_run`, `list_pipeline_runs`	การรันไปป์ไลน์
`get_run_step`, `list_run_steps`	รายละเอียดขั้นตอน
`get_step_logs`, `get_step_code`	บันทึกขั้นตอนและซอร์สโค้ด
`list_pipelines`, `get_pipeline_details`	คำจำกัดความของไปป์ไลน์
`get_schedule`, `list_schedules`	ตารางเวลา
`list_artifacts`	ข้อมูลเมตาของอาร์ติแฟกต์
`list_secrets`	ชื่อซีเคร็ต (ไม่ใช่ค่า)
`get_service`, `list_services`	บริการโมเดล
`get_model`, `list_models`	รีจิสทรีโมเดล
`get_model_version`, `list_model_versions`	เวอร์ชันโมเดล

แอปแบบโต้ตอบ (ทดลอง)

เครื่องมือ	คำอธิบาย
`open_pipeline_run_dashboard`	เปิดแดชบอร์ดการรันไปป์ไลน์แบบโต้ตอบ (MCP App)
`open_run_activity_chart`	เปิดแผนภูมิแท่งกิจกรรมการรัน 30 วัน (MCP App)

เครื่องมือวิเคราะห์

เครื่องมือ	คำอธิบาย
`stack_components_analysis`	วิเคราะห์การใช้งานคอมโพเนนต์สแต็ก
`recent_runs_analysis`	วิเคราะห์การรันไปป์ไลน์ล่าสุด
`most_recent_runs`	รับการรันล่าสุด N รายการ

การวินิจฉัย

เครื่องมือ	คำอธิบาย
`diagnose_zenml_setup`	วินิจฉัยการตั้งค่าเซิร์ฟเวอร์ (env vars, SDK, การเชื่อมต่อ, การตรวจสอบสิทธิ์) ทำงานได้แม้กำหนดค่าไม่ถูกต้อง

เครื่องมือที่เลิกใช้งานแล้ว

เครื่องมือ	การแทนที่
`get_run_template`	ใช้ `get_snapshot` แทน
`list_run_templates`	ใช้ `list_snapshots` แทน
`trigger_pipeline(template_id=...)`	ใช้ `trigger_pipeline(snapshot_name_or_id=...)`

การย้าย: Run Templates → Snapshots

ทำไมต้องเปลี่ยน? ZenML พัฒนาแนวคิด "อาร์ติแฟกต์ไปป์ไลน์ที่รันได้" Run Templates ตอนนี้เป็น wrapper ที่เลิกใช้งานแล้วซึ่งภายในเพียงแค่ชี้ไปที่ Snapshots โค้ดใหม่ควรใช้ Snapshots โดยตรง

คู่มือการย้ายอย่างรวดเร็ว

รูปแบบเก่า (Templates)	รูปแบบใหม่ (Snapshots)
`list_run_templates()`	`list_snapshots(runnable=True, named_only=True)`
`get_run_template(name)`	`get_snapshot(name, include_config_schema=True)`
`trigger_pipeline(template_id=...)`	`trigger_pipeline(snapshot_name_or_id=...)`

ตัวอย่างเวิร์กโฟลว์ (Snapshot-First)

1. Discover project context:
   → get_active_project()

2. Find runnable snapshots:
   → list_snapshots(runnable=True, named_only=True)

3. Trigger a run:
   → trigger_pipeline(pipeline_name_or_id="my-pipeline", snapshot_name_or_id="my-snapshot")

4. Check deployments:
   → list_deployments(status="running")
   → get_deployment_logs(name_id_or_prefix="my-deployment", tail=100)

หมายเหตุ: get_deployment_logs ส่งคืนเอาต์พุตที่มีขอบเขต (ค่าเริ่มต้น 100 บรรทัด, สูงสุด 1000, จำกัดที่ 100KB) และต้องการการผสานรวมตัวปรับใช้ที่เหมาะสมที่จะติดตั้ง

การตั้งค่าด่วนผ่านแดชบอร์ด (แนะนำ)

วิธีที่ง่ายที่สุดในการตั้งค่า ZenML MCP Server คือผ่าน หน้า MCP Settings ในแดชบอร์ด ZenML ของคุณ

MCP Settings Page

ไปที่ Settings → MCP ในแดชบอร์ด ZenML ของคุณเพื่อรับ:

ตัวอย่างที่กำหนดค่าไว้ล่วงหน้า สำหรับ URL เซิร์ฟเวอร์และข้อมูลประจำตัวเฉพาะของคุณ
การติดตั้งในคลิกเดียว ผ่านลิงก์ลึกสำหรับ IDE ที่รองรับ
การกำหนดค่าแบบคัดลอกและวาง สำหรับ VS Code, Claude Desktop, Cursor, Claude Code, OpenAI Codex และอื่นๆ
ตัวเลือก Docker และ uv ตามความต้องการของคุณ

ผู้ใช้ ZenML Pro

หน้า MCP Settings ให้คุณสร้าง Personal Access Token (PAT) ได้ในคลิกเดียว โทเค็นจะถูกรวมโดยอัตโนมัติในตัวอย่างการกำหนดค่าทั้งหมดที่สร้างขึ้น

ผู้ใช้ ZenML OSS

ขั้นแรกสร้างโทเค็นบัญชีบริการผ่าน Settings → Service Accounts
วางโทเค็นลงในหน้า MCP Settings
คัดลอกการกำหนดค่าที่สร้างขึ้นสำหรับ IDE ของคุณ

ต้องการตั้งค่าด้วยตนเอง? ดูคำแนะนำโดยละเอียดด้านล่าง

MCP Apps (ทดลอง)

MCP Apps คืออะไร? MCP Apps คือ UI HTML แบบโต้ตอบที่ MCP servers สามารถ ให้บริการโดยตรงไปยังไคลเอนต์ AI พวกมันแสดงผลใน iframe แบบแซนด์บ็อกซ์และสามารถเรียก เครื่องมือเซิร์ฟเวอร์แบบสองทิศทาง ดู ประกาศอย่างเป็นทางการ สำหรับรายละเอียดทั้งหมด

Run Activity Chart

เซิร์ฟเวอร์นี้รวม MCP Apps ทดลองสองตัว:

แอป	เครื่องมือ	คำอธิบาย
Pipeline Runs Dashboard	`open_pipeline_run_dashboard`	ตารางแบบโต้ตอบของการรันไปป์ไลน์ล่าสุดพร้อมสถานะ รายละเอียดขั้นตอน และบันทึก
Run Activity Chart	`open_run_activity_chart`	แผนภูมิแท่งของกิจกรรมการรันไปป์ไลน์ในช่วง 30 วันที่ผ่านมาพร้อมการแจกแจงสถานะ

Pipeline Runs Dashboard

แอปเหล่านี้รวมเป็นตัวอย่างพิสูจน์แนวคิด เรายินดีรับข้อเสนอแนะและการมีส่วนร่วมสำหรับ MCP Apps เพิ่มเติม มันยังเป็นช่วงเริ่มต้นสำหรับฟีเจอร์ใหม่นี้ ดังนั้นเราจะต้องดูว่ามันพัฒนาอย่างไร เราคาดว่าจะรองรับมันอย่างเต็มที่มากขึ้นในอนาคต

ไคลเอนต์ที่รองรับ

MCP Apps ต้องการการขนส่ง Streamable HTTP (ไม่ใช่ stdio) ไคลเอนต์ต่อไปนี้ ปัจจุบันรองรับ MCP Apps:

✅ VS Code (Insiders Edition)
✅ Goose
✅ ChatGPT (เปิดตัวเร็วๆ นี้)
⚠️ Claude Desktop -- ณ ปลายเดือนมกราคม 2026 ยังไม่แสดงผล Apps
⚠️ Claude.ai (เว็บ) — ณ ปลายเดือนมกราคม 2026 ยังไม่แสดงผล Apps

หมายเหตุ: เราไม่สามารถทดสอบอย่างละเอียดกับ Claude Desktop หรือ Claude.ai ในขณะที่เขียน หากคุณพบปัญหา โปรด รายงานพวกมัน

การรัน MCP Apps ด้วย Docker

MCP Apps ต้องการการขนส่ง Streamable HTTP และ URL ที่เข้าถึงได้สาธารณะ (สำหรับ ไคลเอนต์ที่โฮสต์บนคลาวด์เช่น Claude.ai) การตั้งค่าที่ง่ายที่สุดใช้ Docker + Cloudflare tunnel:

1. สร้างและรันคอนเทนเนอร์ Docker:

docker build -t mcp-zenml:apps .

docker run --rm -d --name mcp-zenml-apps -p 8001:8001 \
  -e ZENML_STORE_URL="https://your-zenml-server.example.com" \
  -e ZENML_STORE_API_KEY="your-api-key" \
  -e ZENML_ACTIVE_PROJECT_ID="your-project-id" \
  mcp-zenml:apps --transport streamable-http --host 0.0.0.0 --port 8001 \
  --disable-dns-rebinding-protection

2. เริ่ม Cloudflare tunnel (สำหรับไคลเอนต์คลาวด์):

npx cloudflared tunnel --url http://localhost:8001

สิ่งนี้พิมพ์ URL สาธารณะเช่น https://random-words.trycloudflare.com

3. เชื่อมต่อไคลเอนต์ของคุณ:

ใน Claude Desktop หรือไคลเอนต์อื่นๆ เพิ่ม MCP server ด้วย URL: https://random-words.trycloudflare.com/mcp เช่น:

{
	"servers": {
		"ZenML": {
			"url": "https://USE-YOUR-OWN-URL.trycloudflare.com/mcp",
			"type": "http"
		}
	},
	"inputs": []
}

ขอให้ AI "เปิดแดชบอร์ดการรันไปป์ไลน์" หรือ "แสดงแผนภูมิกิจกรรมการรัน"

หมายเหตุสำคัญ:

ZENML_ACTIVE_PROJECT_ID จำเป็น — หากไม่มีมัน เครื่องมือการรันไปป์ไลน์จะ ล้มเหลวด้วย "No project is currently set as active"
แฟล็ก --disable-dns-rebinding-protection จำเป็นเมื่อรันหลัง reverse proxies (cloudflared, ngrok) — มันปลอดภัยเมื่อพร็อกซีจัดการความปลอดภัย
URL ของ tunnel เปลี่ยนแปลงทุกครั้งที่รีสตาร์ท — อัปเดตการผสานรวมไคลเอนต์ของคุณตามนั้น

การทดสอบและการประกันคุณภาพ

โปรเจกต์นี้รวมการทดสอบอัตโนมัติเพื่อให้แน่ใจว่า MCP server ยังคงทำงานได้:

🔄 การทดสอบควันอัตโนมัติ: การทดสอบควันที่ครอบคลุมรันทุก 3 วันผ่าน GitHub Actions
🚨 การสร้างปัญหา: การทดสอบที่ล้มเหลวสร้าง GitHub issues โดยอัตโนมัติพร้อมข้อมูลการดีบักโดยละเอียด
⚡ CI ที่รวดเร็ว: ใช้ UV พร้อมแคชสำหรับการติดตั้ง dependency และการทดสอบที่รวดเร็ว
🧪 การทดสอบด้วยตนเอง: คุณสามารถรันการทดสอบควันในเครื่องโดยใช้ uv run scripts/test_mcp_server.py server/zenml_server.py

การทดสอบอัตโนมัติตรวจสอบ:

การเชื่อมต่อโปรโตคอล MCP และการจับมือ
การเริ่มต้นเซิร์ฟเวอร์และการค้นพบเครื่องมือ
ฟังก์ชันการทำงานของเครื่องมือพื้นฐาน (เมื่อเซิร์ฟเวอร์ ZenML สามารถเข้าถึงได้)
การแจงนับทรัพยากรและพรอมต์
diagnose_zenml_setup ส่งคืนการวินิจฉัยที่มีโครงสร้างแม้ในสภาพแวดล้อมที่มีข้อจำกัด

การดีบักด้วย MCP Inspector

สำหรับการดีบักแบบโต้ตอบ ใช้ MCP Inspector — เครื่องมือบนเว็บที่ให้คุณทดสอบเครื่องมือ MCP แบบเรียลไทม์:

# Using .env.local (recommended for development)
cp .env.local.example .env.local  # Then edit with your credentials
source .env.local && npx @modelcontextprotocol/inspector \
  -e ZENML_STORE_URL=$ZENML_STORE_URL \
  -e ZENML_STORE_API_KEY=$ZENML_STORE_API_KEY \
  -- uv run server/zenml_server.py

สิ่งนี้เปิด UI เว็บพร้อมข้อมูลประจำตัวของคุณที่กรอกไว้ล่วงหน้า — เพียงคลิก Connect และใช้แท็บ Tools เพื่อทดสอบเครื่องมือใดๆ แบบโต้ตอบ

ดู CLAUDE.md สำหรับคำแนะนำการดีบักโดยละเอียดเพิ่มเติม

ความเป็นส่วนตัวและการวิเคราะห์

ZenML MCP Server รวบรวมการวิเคราะห์การใช้งานแบบไม่ระบุตัวตนเพื่อช่วยเราปรับปรุงผลิตภัณฑ์

เราติดตาม:

เครื่องมือใดที่ใช้และบ่อยแค่ไหน
อัตราข้อผิดพลาดและประเภท (เฉพาะประเภทข้อผิดพลาด ไม่มีข้อความ)
ข้อมูลสภาพแวดล้อมพื้นฐาน (OS, เวอร์ชัน Python, และว่ารันใน Docker/CI หรือไม่)
ระยะเวลาเซสชันและรูปแบบการใช้เครื่องมือ

เราไม่รวบรวม:

URL เซิร์ฟเวอร์ ZenML หรือคีย์ API ของคุณ
ชื่อไปป์ไลน์ ชื่อโมเดล หรือข้อมูลธุรกิจใดๆ
ข้อความแสดงข้อผิดพลาดหรือ stack traces
ข้อมูลที่สามารถระบุตัวตนได้ใดๆ

เพื่อปิดใช้งานการวิเคราะห์:

# Option 1
export ZENML_MCP_ANALYTICS_ENABLED=false

# Option 2
export ZENML_MCP_DISABLE_ANALYTICS=true

สำหรับการดีบัก/ทดสอบ (บันทึกเหตุการณ์ไปยัง stderr แทนการส่ง):

export ZENML_MCP_ANALYTICS_DEV=true

สำหรับผู้ใช้ Docker: คุณสามารถตั้งค่า ZENML_MCP_ANALYTICS_ID (ต้องเป็น UUID ที่ถูกต้อง) เพื่อรักษา ID ที่ไม่ระบุตัวตนให้สอดคล้องกันตลอดการรีสตาร์ทคอนเทนเนอร์ หากคุณไม่ได้ตั้งค่าและระบบไฟล์ของคอนเทนเนอร์ไม่สามารถบันทึกไฟล์ ID การวิเคราะห์ได้ เซิร์ฟเวอร์จะถอยกลับไปใช้ UUID ที่ไม่ระบุตัวตนแบบกำหนดได้ซึ่งได้มาจากแฮชของ ZENML_STORE_URL (URL เองจะไม่ถูกส่งเป็นคุณสมบัติของเหตุการณ์)

ตัวเลือกการวิเคราะห์เพิ่มเติม:

ZENML_MCP_ANALYTICS_SHUTDOWN_TIMEOUT_S — เวลาสูงสุด (วินาที) ในการล้างข้อมูลการวิเคราะห์แบบซิงโครนัสระหว่างการปิดระบบ (ค่าเริ่มต้น: 1.0)

หมายเหตุเกี่ยวกับการติดตามการปิดระบบ: เหตุการณ์การปิดระบบจะถูกส่งแบบซิงโครนัสโดยมีการหมดเวลาที่จำกัดเพื่อความน่าเชื่อถือในการส่งที่ดีที่สุด อย่างไรก็ตาม หากคอนเทนเนอร์ถูกฆ่าด้วย SIGKILL (เช่น docker kill) ตัวจัดการการปิดระบบจะไม่สามารถทำงานได้ — นี่เป็นข้อจำกัดของ Docker/OS ไม่ใช่ข้อบกพร่อง

การตรวจสอบความถูกต้องเมื่อเริ่มต้น

คุณสามารถเปิดใช้งานการตรวจสอบวินิจฉัยเมื่อเริ่มต้นแบบเบาได้:

# Print warnings but start normally
uv run server/zenml_server.py --startup-validation warn

# Exit non-zero if required setup is missing (useful in Docker/CI)
uv run server/zenml_server.py --startup-validation strict

คุณยังสามารถตั้งค่านี้ผ่านตัวแปรสภาพแวดล้อม: ZENML_MCP_STARTUP_VALIDATION=warn

เครื่องมือ diagnose_zenml_setup ยังพร้อมใช้งานเป็นเครื่องมือ MCP สำหรับการแก้ไขปัญหารันไทม์ — มันทำงานได้แม้ในขณะที่ไม่ได้ติดตั้ง ZenML SDK หรือตัวแปรสภาพแวดล้อมหายไป

การตั้งค่าด้วยตนเอง

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

คุณจะต้องสามารถเข้าถึงเซิร์ฟเวอร์ ZenML ที่ปรับใช้แล้ว หากคุณยังไม่มี คุณสามารถสมัครทดลองใช้ฟรีได้ที่ ZenML Pro และเราจะจัดการการปรับใช้ให้คุณ

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

ความเข้ากันได้: เซิร์ฟเวอร์ MCP นี้ได้รับการทดสอบและแนะนำสำหรับ ZenML >= 0.93.0 หากคุณใช้ ZenML เวอร์ชันเก่ากว่า โปรดใช้ รุ่นก่อนหน้า ของเซิร์ฟเวอร์ MCP นี้

คุณอาจจะต้องติดตั้ง uv ในเครื่องด้วย สำหรับข้อมูลเพิ่มเติม โปรดดู เอกสารประกอบ uv เราแนะนำให้ติดตั้งผ่านสคริปต์ตัวติดตั้งหรือผ่าน brew หากใช้ Mac (ในทางเทคนิคคุณไม่จำเป็นต้องใช้มัน แต่จะทำให้การติดตั้งและตั้งค่าง่ายขึ้น)

คุณจะต้องโคลนที่เก็บนี้ไปยังที่ใดที่หนึ่งในเครื่อง:

git clone https://github.com/zenml-io/mcp-zenml.git

ไฟล์การกำหนดค่า MCP ของคุณ

ไฟล์การกำหนดค่า MCP เป็นไฟล์ JSON ที่บอกไคลเอนต์ MCP ถึงวิธีการเชื่อมต่อกับ เซิร์ฟเวอร์ MCP ของคุณ ไคลเอนต์ MCP ที่แตกต่างกันจะใช้หรือระบุสิ่งนี้แตกต่างกันไป สอง ไคลเอนต์ MCP ที่ใช้กันทั่วไปคือ Claude Desktop และ Cursor ซึ่งเรามีคำแนะนำในการติดตั้ง ด้านล่าง

คุณจะต้องระบุเซิร์ฟเวอร์ ZenML MCP ของคุณในรูปแบบต่อไปนี้:

{
    "mcpServers": {
        "zenml": {
            "command": "/usr/local/bin/uv",
            "args": ["run", "path/to/server/zenml_server.py"],
            "env": {
                "LOGLEVEL": "WARNING",
                "NO_COLOR": "1",
                "ZENML_LOGGING_COLORS_DISABLED": "true",
                "ZENML_LOGGING_VERBOSITY": "WARN",
                "ZENML_ENABLE_RICH_TRACEBACK": "false",
                "PYTHONUNBUFFERED": "1",
                "PYTHONIOENCODING": "UTF-8",
                "ZENML_STORE_URL": "https://your-zenml-server-goes-here.com",
                "ZENML_STORE_API_KEY": "your-api-key-here"
            }
        }
    }
}

มีค่าจำลองสี่ค่าที่คุณจะต้องแทนที่:

พาธไปยัง uv ที่ติดตั้งในเครื่องของคุณ (พาธที่แสดงด้านบนคือตำแหน่งที่ จะอยู่บน Mac หากคุณติดตั้งผ่าน brew)
พาธไปยังไฟล์ zenml_server.py (นี่คือไฟล์ที่จะถูกรันเมื่อ คุณเชื่อมต่อกับเซิร์ฟเวอร์ MCP) ไฟล์นี้อยู่ภายในที่เก็บนี้ที่ รูท คุณจะต้องระบุพาธแบบเต็มที่แน่นอนไปยังไฟล์นี้
URL เซิร์ฟเวอร์ ZenML (นี่คือ URL ของเซิร์ฟเวอร์ ZenML ของคุณ คุณสามารถค้นหาได้ ใน ZenML Cloud UI) มันจะมีลักษณะคล้าย https://d534d987a-zenml.cloudinfra.zenml.io
คีย์ API เซิร์ฟเวอร์ ZenML (นี่คือคีย์ API สำหรับเซิร์ฟเวอร์ ZenML ของคุณ คุณสามารถ ค้นหาได้ใน ZenML Cloud UI หรือ อ่านเอกสาร เหล่านี้ เกี่ยวกับวิธีการสร้าง สำหรับวัตถุประสงค์ของเซิร์ฟเวอร์ ZenML MCP เราแนะนำ ให้ใช้บัญชีบริการ)

คุณมีอิสระที่จะเปลี่ยนวิธีที่คุณรันไฟล์ Python ของเซิร์ฟเวอร์ MCP แต่การใช้ uv น่าจะเป็นตัวเลือกที่ง่ายที่สุดเนื่องจากมันจัดการสภาพแวดล้อมและ การติดตั้งการพึ่งพาให้คุณ

การติดตั้งเพื่อใช้กับ Claude Desktop

ทางเลือกด่วน: ใช้หน้าการตั้งค่า MCP ในแดชบอร์ด ZenML ของคุณ (การตั้งค่า → MCP) เพื่อรับคำแนะนำการติดตั้งที่กำหนดค่าไว้ล่วงหน้าและลิงก์ลึกสำหรับ Claude Desktop

คุณจะต้องติดตั้ง Claude Desktop เวอร์ชันล่าสุด

คุณสามารถเปิดเมนูการตั้งค่าและลากไฟล์ mcp-zenml.mcpb จาก รูทของที่เก็บนี้ไปยังเมนู และมันจะแนะนำคุณตลอด กระบวนการติดตั้งและตั้งค่า คุณจะต้องเพิ่ม URL เซิร์ฟเวอร์ ZenML และคีย์ API ของคุณ

หมายเหตุ: MCP bundles (.mcpb) แทนที่รูปแบบ Desktop Extensions (.dxt) แบบเก่า; ไฟล์ .dxt ที่มีอยู่ยังคงทำงานใน Claude Desktop

ตัวเลือก: การปรับปรุงการแสดงผลลัพธ์เครื่องมือ ZenML

เพื่อประสบการณ์ที่ดีขึ้นกับผลลัพธ์เครื่องมือ ZenML คุณสามารถกำหนดค่า Claude ให้ แสดงการตอบสนอง JSON ในรูปแบบที่อ่านง่ายขึ้น ใน Claude Desktop ไปที่ การตั้งค่า → โปรไฟล์ และในส่วน "ความชอบส่วนบุคคลใดที่ Claude ควรพิจารณา ในการตอบสนอง" ให้เพิ่มบางอย่างเช่นต่อไปนี้ (หรือใช้คำเหล่านี้ ตรงๆ!):

When using zenml tools which return JSON strings and you're asked a question, you might want to consider using markdown tables to summarize the results or make them easier to view!

สิ่งนี้จะกระตุ้นให้ Claude จัดรูปแบบผลลัพธ์เครื่องมือ ZenML เป็นตาราง markdown ทำให้ข้อมูลอ่านและเข้าใจง่ายขึ้นมาก

การติดตั้งเพื่อใช้กับ Cursor

ทางเลือกด่วน: หน้าการตั้งค่า MCP ในแดชบอร์ด ZenML ของคุณ (การตั้งค่า → MCP) สามารถสร้างเนื้อหา mcp.json ที่แน่นอนพร้อมข้อมูลประจำตัวของคุณที่กรอกไว้ล่วงหน้า

คุณจะต้องติดตั้ง Cursor

Cursor ทำงานแตกต่างจาก Claude Desktop เล็กน้อยตรงที่คุณระบุ ไฟล์การกำหนดค่าตามแต่ละที่เก็บ ซึ่งหมายความว่าหากคุณต้องการใช้ เซิร์ฟเวอร์ ZenML MCP ในหลายที่เก็บ คุณจะต้องระบุไฟล์การกำหนดค่าใน แต่ละที่เก็บ

ในการตั้งค่าสำหรับที่เก็บเดียว คุณจะต้อง:

สร้างโฟลเดอร์ .cursor ในรูทของที่เก็บของคุณ
ภายในนั้น สร้างไฟล์ mcp.json ด้วยเนื้อหาด้านบน
ไปที่การตั้งค่า Cursor ของคุณและคลิกที่เซิร์ฟเวอร์ ZenML เพื่อ 'เปิดใช้งาน'

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

อิมเมจ Docker

คุณสามารถรันเซิร์ฟเวอร์เป็นคอนเทนเนอร์ Docker ได้ กระบวนการสื่อสารผ่าน stdio ดังนั้นมันจะรอการเชื่อมต่อไคลเอนต์ MCP ส่งข้อมูลประจำตัว ZenML ของคุณผ่านตัวแปรสภาพแวดล้อม

อิมเมจที่สร้างไว้ล่วงหน้า (Docker Hub)

ดึงอิมเมจ multi-arch ล่าสุด:

docker pull zenmldocker/mcp-zenml:latest

รุ่นที่มีเวอร์ชันถูกแท็กเป็น X.Y.Z:

docker pull zenmldocker/mcp-zenml:1.0.8

รันด้วยข้อมูลประจำตัว ZenML ของคุณ (โหมด stdio):

docker run -i --rm \
  -e ZENML_STORE_URL="https://your-zenml-server.example.com" \
  -e ZENML_STORE_API_KEY="your-api-key" \
  zenmldocker/mcp-zenml:latest

การกำหนดค่า MCP มาตรฐานโดยใช้ Docker

{
  "mcpServers": {
    "zenml": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ZENML_STORE_URL=https://...",
        "-e", "ZENML_STORE_API_KEY=ZENKEY_...",
        "-e", "ZENML_ACTIVE_PROJECT_ID=...",
        "-e", "LOGLEVEL=WARNING",
        "-e", "NO_COLOR=1",
        "-e", "ZENML_LOGGING_COLORS_DISABLED=true",
        "-e", "ZENML_LOGGING_VERBOSITY=WARN",
        "-e", "ZENML_ENABLE_RICH_TRACEBACK=false",
        "-e", "PYTHONUNBUFFERED=1",
        "-e", "PYTHONIOENCODING=UTF-8",
        "zenmldocker/mcp-zenml:latest"
      ]
    }
  }
}

สร้างในเครื่อง

จากรูทของที่เก็บ:

docker build -t zenmldocker/mcp-zenml:local .

รันอิมเมจที่สร้างในเครื่อง:

docker run -i --rm \
  -e ZENML_STORE_URL="https://your-zenml-server.example.com" \
  -e ZENML_STORE_API_KEY="your-api-key" \
  zenmldocker/mcp-zenml:local

MCP Bundles (.mcpb)

โปรเจกต์นี้ใช้ MCP Bundles (.mcpb) — ตัวตายตัวแทนของ Desktop Extensions (DXT) ของ Anthropic MCP Bundles แพ็คเกจเซิร์ฟเวอร์ MCP ทั้งหมด (รวมถึงการพึ่งพา) ลงในไฟล์เดียวพร้อมการกำหนดค่าที่เป็นมิตรต่อผู้ใช้

หมายเหตุเกี่ยวกับการเปลี่ยนชื่อ: MCP Bundles แทนที่รูปแบบ .dxt แบบเก่า Claude Desktop ยังคงเข้ากันได้ย้อนหลังกับไฟล์ .dxt ที่มีอยู่ แต่ตอนนี้เราจัดส่ง mcp-zenml.mcpb และแนะนำให้ใช้ต่อไป

ไฟล์ mcp-zenml.mcpb ในรูทของที่เก็บมีทุกอย่างที่จำเป็นในการรันเซิร์ฟเวอร์ ZenML MCP ซึ่งช่วยลดความจำเป็นในขั้นตอนการติดตั้งด้วยตนเองที่ซับซ้อน สิ่งนี้ทำให้การผสานรวม ZenML ที่ทรงพลังสามารถเข้าถึงได้สำหรับผู้ใช้โดยไม่ต้องใช้ความเชี่ยวชาญด้านเทคนิคในการตั้งค่า

เมื่อคุณลากและวางไฟล์ .mcpb ลงในการตั้งค่าของ Claude Desktop มันจะจัดการโดยอัตโนมัติ:

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

สำหรับข้อมูลเพิ่มเติม โปรดดูประกาศของ Anthropic เกี่ยวกับ Desktop Extensions (DXT) และคำแนะนำในการแพ็คเกจ MCP bundle ที่เกี่ยวข้องในเอกสารประกอบของพวกเขา: https://www.anthropic.com/engineering/desktop-extensions

เผยแพร่บน Anthropic MCP Registry

เซิร์ฟเวอร์ MCP นี้ถูกเผยแพร่ไปยัง Anthropic MCP Registry อย่างเป็นทางการและสามารถค้นพบได้โดยโฮสต์ที่เข้ากันได้ ในแต่ละ รุ่นที่แท็ก CI ของเราจะอัปเดตรายการรีจิสทรีผ่าน mcp-publisher CLI ของรีจิสทรีโดยใช้ GitHub OIDC ดังนั้นคุณสามารถติดตั้งหรือค้นพบ ZenML MCP Server ได้โดยตรงทุกที่ที่รองรับรีจิสทรี (เช่น แคตตาล็อกส่วนขยายของ Claude Desktop)

อัปเดตอยู่เสมอ: รายการรีจิสทรีจะถูกรีเฟรชทุกครั้งที่มีการเผยแพร่จาก manifest.json และ server.json ของคอมมิตที่แท็ก
เส้นทางการติดตั้งทางเลือก: คุณยังสามารถติดตั้งในเครื่องผ่าน .mcpb bundle ที่แพ็คเกจไว้ (ดูด้านบน) หรือรันอิมเมจ Docker

เรียนรู้เพิ่มเติมเกี่ยวกับรีจิสทรีได้ที่นี่:

Anthropic MCP Registry (ที่เก็บชุมชน): https://github.com/modelcontextprotocol/registry