วิธีสร้าง Local MCP Server สำหรับ Claude: จัดการไฟล์, คำสั่ง, ภาพหน้าจอ และควบคุมแอปพลิเคชัน

Claude จะมีประโยชน์มากขึ้นเมื่อมันไม่ได้เป็นเพียงแค่อินเทอร์เฟซแชทอีกต่อไป

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

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

ข้อสังเกตสั้น ๆ ก่อนที่เราจะเริ่มสร้างอะไรเลย

บทความนี้หลีกเลี่ยงเวอร์ชันที่ไร้ความรับผิดชอบของ "การควบคุมคอมพิวเตอร์" โดยเจตนา

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

รูปแบบที่ดีกว่าคือ:

• ไดเรกทอรีที่อยู่ในรายการอนุญาต
• คำสั่งที่อยู่ในรายการอนุญาต
• ค่าเริ่มต้นที่ปลอดภัย
• บันทึกที่มนุษย์อ่านได้
• การตอบสนองที่ชัดเจน
• การแยกเครื่องมือแบบอ่านอย่างเดียวกับเครื่องมือที่ดำเนินการอย่างชัดเจน

ถ้า Claude ทำทุกอย่างได้ แสดงว่าคุณสร้างเดโมเท่านั้น

ถ้า Claude ทำสิ่งที่ถูกต้องได้อย่างปลอดภัย แสดงว่าคุณสร้างสิ่งที่ใช้งานได้จริง

เหตุใดสถาปัตยกรรมนี้จึงควรค่าแก่การเรียนรู้

คุณค่าของเซิร์ฟเวอร์ MCP ในเครื่องไม่ใช่ความแปลกใหม่ แต่คือการลดแรงเสียดทาน

หากไม่มีเลเยอร์เครื่องมือในเครื่อง เวิร์กโฟลว์ของคุณจะเป็นแบบนี้:

1. ถาม Claude ว่าต้องทำอะไร
2. คัดลอกคำตอบ
3. เปิดโฟลเดอร์ด้วยตัวเอง
4. รันคำสั่งด้วยตัวเอง
5. จับภาพหน้าจอด้วยตัวเอง
6. วางผลลัพธ์กลับเข้าไปในแชท

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

สิ่งนี้มีประโยชน์สำหรับ:

• เวิร์กโฟลว์การพัฒนา
• การตรวจสอบล็อก
• การดำเนินการด้านเนื้อหา
• ไปป์ไลน์งานวิจัย
• ระบบอัตโนมัติบนเดสก์ท็อป
• งานธุรการที่ทำซ้ำได้

และเนื่องจากเลเยอร์เครื่องมือเป็นของคุณ คุณจึงเป็นผู้เลือกว่าโมเดลหยุดตรงไหน

อยากเรียนรู้ AI และก้าวหน้าในอาชีพการงานของคุณหรือไม่?

ฉันแบ่งปัน:

1,000+ พรอมต์ AI

เครื่องมือ AI และระบบอัตโนมัติ

เคล็ดลับความก้าวหน้าในอาชีพและ LinkedIn

ทรัพยากรด้านเทคโนโลยีและประสิทธิภาพที่คัดสรร

สมัครสมาชิกที่นี่:

https://bytebuilders.beehiiv.com/subscribe

ติดตามฉันเพื่อรับเคล็ดลับ AI เพิ่มเติม

👇

การออกแบบที่เรากำลังสร้าง

เราจะสร้างเซิร์ฟเวอร์ในเครื่องที่มีเครื่องมือ 5 อย่าง:

1. list_files — ดูว่ามีอะไรอยู่ในโฟลเดอร์ที่อนุมัติ
2. read_file — เปิดไฟล์ข้อความที่ปลอดภัย
3. run_command — ดำเนินการคำสั่งในเครื่องที่ได้รับอนุมัติชุดเล็ก
4. take_screenshot — บันทึกภาพหน้าจอไปยังตำแหน่งที่ทราบ
5. open_target — เปิดแอป ไฟล์ โฟลเดอร์ หรือ URL

ขอบเขตนี้ตั้งใจไว้

เพียงพอที่จะทำให้ Claude มีประโยชน์อย่างมีความหมายบนเครื่องในเครื่อง โดยไม่พังทลายไปสู่ระบบอัตโนมัติทั่วไปที่ไม่ปลอดภัย

โมเดลทางความคิดควรเป็นแบบนี้:

Claude → ไคลเอ็นต์ MCP → เซิร์ฟเวอร์ MCP ในเครื่อง → เครื่องมือที่มีขอบเขตจำกัด → ระบบปฏิบัติการ

Claude ไม่ควรพูดคุยกับระบบปฏิบัติการของคุณโดยตรง เซิร์ฟเวอร์ MCP ของคุณคือระนาบควบคุมที่อยู่ตรงกลาง

สแต็ก

สำหรับการสร้างในเครื่อง Python เป็นตัวเลือกที่สะอาดเพราะ SDK MCP อย่างเป็นทางการมีความสมบูรณ์ การแยกส่วน FastMCP นั้นกระชับ และ Python ยังคงเป็นภาษาที่ง่ายที่สุดสำหรับงานสคริปต์ไฟล์ระบบ ซับโปรเซส และเดสก์ท็อป 4 2

เราจะใช้:

• Python 3.11+
• mcp[cli] สำหรับรันไทม์เซิร์ฟเวอร์ MCP
• mss สำหรับภาพหน้าจอข้ามแพลตฟอร์ม
• โมดูลไลบรารีมาตรฐานสำหรับการเข้าถึงไฟล์ การเรียกซับโปรเซส และการจัดการ OS

ตั้งค่าโปรเจกต์ใหม่:

1mkdir local-mcp-server
2cd local-mcp-server
3uv init --python 3.11
4uv add "mcp[cli]>=1.0,<2.0" "mss>=9.0,<10.0"

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

โครงร่างโปรเจกต์แบบง่าย ๆ ก็ใช้ได้ดี:

1mkdir local-mcp-server
2cd local-mcp-server
3uv init --python 3.11
4uv add "mcp[cli]>=1.0,<2.0" "mss>=9.0,<10.0"

คุณไม่จำเป็นต้องมีสถาปัตยกรรมที่ซับซ้อนสำหรับ v1 สิ่งที่คุณต้องการคือความชัดเจน

เซิร์ฟเวอร์จริง

สร้าง server.py และเริ่มต้นด้วยการใช้งานที่ขับเคลื่อนด้วยนโยบาย

1from __future__ import annotations
2
3import json
4import os
5import platform
6import shlex
7import subprocess
8from pathlib import Path
9from typing import Any
10
11import mss
12from mcp.server.fastmcp import FastMCP
13
14app = FastMCP("local-computer-control", json_response=True)
15
16HOME = Path.home()
17PROJECT_ROOT = Path(__file__).parent.resolve()
18CAPTURE_DIR = PROJECT_ROOT / "captures"
19CAPTURE_DIR.mkdir(exist_ok=True)
20
21ALLOWED_ROOTS = [
22    HOME / "Documents",
23    HOME / "Desktop",
24    PROJECT_ROOT,
25]
26
27ALLOWED_COMMANDS = {
28    "pwd",
29    "ls",
30    "git status",
31    "git diff --stat",
32    "python --version",
33    "node --version",
34    "npm --version",
35}
36
37READABLE_EXTENSIONS = {
38    ".txt",
39    ".md",
40    ".json",
41    ".py",
42    ".js",
43    ".ts",
44    ".tsx",
45    ".jsx",
46    ".yaml",
47    ".yml",
48    ".toml",
49    ".csv",
50    ".log",
51}
52
53def _resolve_path(raw_path: str) -> Path:
54    path = Path(raw_path).expanduser().resolve()
55    for root in ALLOWED_ROOTS:
56        root = root.resolve()
57        if path == root or root in path.parents:
58            return path
59    raise ValueError(f"Path not allowed: {path}")
60
61def _ensure_safe_command(command: str) -> str:
62    normalized = " ".join(shlex.split(command))
63    if normalized not in ALLOWED_COMMANDS:
64        raise ValueError(
65            "Command not allowed. Add it explicitly to ALLOWED_COMMANDS if you really need it."
66        )
67    return normalized
68
69@app.tool()
70def list_files(path: str = "~") -> dict[str, Any]:
71    """List files and folders inside an approved directory."""
72    target = _resolve_path(path)
73    if not target.is_dir():
74        raise ValueError(f"Not a directory: {target}")
75
76    items = []
77    for child in sorted(target.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower())):
78        items.append(
79            {
80                "name": child.name,
81                "path": str(child),
82                "type": "directory" if child.is_dir() else "file",
83            }
84        )
85
86    return {
87        "path": str(target),
88        "count": len(items),
89        "items": items,
90    }
91
92@app.tool()
93def read_file(path: str, max_chars: int = 12000) -> dict[str, Any]:
94    """Read a safe text file from an approved location."""
95    target = _resolve_path(path)
96    if not target.is_file():
97        raise ValueError(f"Not a file: {target}")
98    if target.suffix.lower() not in READABLE_EXTENSIONS:
99        raise ValueError(f"Unsupported file type: {target.suffix}")
100
101    content = target.read_text(encoding="utf-8", errors="replace")
102    truncated = len(content) > max_chars
103    content = content[:max_chars]
104
105    return {
106        "path": str(target),
107        "truncated": truncated,
108        "content": content,
109    }
110
111@app.tool()
112def run_command(command: str, cwd: str | None = None, timeout: int = 15) -> dict[str, Any]:
113    """Run one allowlisted local command."""
114    safe_command = _ensure_safe_command(command)
115    working_dir = _resolve_path(cwd) if cwd else PROJECT_ROOT
116
117    completed = subprocess.run(
118        safe_command,
119        shell=True,
120        cwd=str(working_dir),
121        capture_output=True,
122        text=True,
123        timeout=timeout,
124    )
125
126    return {
127        "command": safe_command,
128        "cwd": str(working_dir),
129        "returncode": completed.returncode,
130        "stdout": completed.stdout.strip(),
131        "stderr": completed.stderr.strip(),
132    }
133
134@app.tool()
135def take_screenshot(name: str = "latest") -> dict[str, Any]:
136    """Capture a screenshot and save it locally."""
137    output_path = CAPTURE_DIR / f"{name}.png"
138
139    with mss.mss() as sct:
140        sct.shot(output=str(output_path))
141
142    return {
143        "saved": True,
144        "path": str(output_path),
145    }
146
147@app.tool()
148def open_target(target: str) -> dict[str, Any]:
149    """Open an approved file, folder, app, or URL using the local OS."""
150    system = platform.system().lower()
151
152    if target.startswith("http://") or target.startswith("https://"):
153        resolved = target
154    else:
155        resolved = str(_resolve_path(target))
156
157    if system == "darwin":
158        subprocess.run(["open", resolved], check=True)
159    elif system == "windows":
160        os.startfile(resolved)  # type: ignore[attr-defined]
161    else:
162        subprocess.run(["xdg-open", resolved], check=True)
163
164    return {
165        "opened": True,
166        "target": resolved,
167    }
168
169if __name__ == "__main__":
170    app.run(transport="stdio")

นี่คือเซิร์ฟเวอร์ขนาดเล็ก แต่ส่วนสำคัญไม่ใช่ความยาวของมัน ส่วนสำคัญคือรูปร่างของอินเทอร์เฟซ:

• ทุกเครื่องมือมีหน้าที่ชัดเจนมาก
• ทุกเครื่องมือส่งคืนข้อมูลที่มีโครงสร้าง
• การดำเนินการคำสั่งถูกควบคุม
• การเข้าถึงไฟล์ถูกจำกัดราก
• ภาพหน้าจอไปยังโฟลเดอร์ที่ทราบ

นั่นคือสิ่งที่คุณต้องการในเซิร์ฟเวอร์ MCP ในเครื่อง

เหตุใดเครื่องมือเหล่านี้จึงถูกออกแบบมาแบบนี้

เนื้อหาสำหรับผู้มีประสบการณ์เกี่ยวกับเครื่องมือตัวแทนไม่ควรหยุดอยู่แค่ "นี่คือโค้ด" รูปร่างของเครื่องมือคือบทเรียนที่แท้จริง

list_files

เครื่องมือนี้ทำให้ Claude มีพื้นผิวการค้นพบที่ปลอดภัย ควรตอบคำถามเช่น:

• มีอะไรในโฟลเดอร์โปรเจกต์นี้?
• มีบันทึกอะไรบ้างใน Documents?
• มีไฟล์ล็อกที่ฉันสามารถตรวจสอบอยู่แล้วหรือไม่?

แต่ไม่ควรกลายเป็นโปรแกรมรวบรวมข้อมูลทั้งดิสก์แบบวนซ้ำ

read_file

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

ขีดจำกัด max_chars มีความสำคัญ ไฟล์ขนาดใหญ่เป็นปัญหาด้านบริบทและเวลาแฝง การส่งคืนเนื้อหาทั้งหมดของไฟล์ล็อกขนาดใหญ่มักไม่ค่อยมีประโยชน์

run_command

นี่คือจุดที่คนส่วนใหญ่ทำแบบเลอะเทอะ

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

take_screenshot

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

open_target

การควบคุมแอปไม่จำเป็นต้องเริ่มต้นด้วยระบบอัตโนมัติ GUI สำหรับหลาย ๆ เวิร์กโฟลว์ "เปิดโฟลเดอร์ ไฟล์ หรือ URL ที่ถูกต้อง" ก็เพียงพอแล้ว

นั่นคือ v1 ที่คงทนกว่าการแสร้งทำเป็นว่าคุณต้องการระบบอัตโนมัติเคอร์เซอร์เต็มรูปแบบตั้งแต่วันแรก

การเชื่อมต่อเซิร์ฟเวอร์กับ Claude

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

Claude Desktop รองรับเซิร์ฟเวอร์ MCP ในเครื่องผ่านการกำหนดค่า ซึ่งจะเปิดกระบวนการเซิร์ฟเวอร์ให้คุณ ในทางปฏิบัติ การใช้พาธแบบสัมบูรณ์สำหรับอินเทอร์พรีเตอร์และสคริปต์เป็นการตั้งค่าที่เปราะบางน้อยที่สุด เพราะสภาพแวดล้อมแอป GUI ในเครื่องมักจะเข้มงวดกว่าเทอร์มินัลของคุณ 2

การกำหนดค่าขั้นต่ำมีลักษณะดังนี้:

1{
2  "mcpServers": {
3    "local-computer-control": {
4      "command": "/absolute/path/to/python",
5      "args": [
6        "/absolute/path/to/local-mcp-server/server.py"
7      ]
8    }
9  }
10}

หากคุณชอบ uv ก็ไม่เป็นไร:

1{
2  "mcpServers": {
3    "local-computer-control": {
4      "command": "/absolute/path/to/uv",
5      "args": [
6        "--directory",
7        "/absolute/path/to/local-mcp-server",
8        "run",
9        "python",
10        "server.py"
11      ]
12    }
13  }
14}

หลังจากที่คุณบันทึกการกำหนดค่าและรีสตาร์ท Claude เครื่องมือเซิร์ฟเวอร์ควรปรากฏในรายการเครื่องมือ MCP ในเครื่อง การตั้งค่า MCP ในเครื่องของ Claude Desktop สร้างขึ้นรอบ ๆ โมเดลนี้โดยเฉพาะ: เปิดกระบวนการในเครื่อง, เชื่อมต่อผ่าน stdio, และเปิดเผยเครื่องมือให้กับโมเดล 2 3

พรอมต์ที่มีประโยชน์จริง ๆ สำหรับการทดสอบ

เมื่อเชื่อมต่อเซิร์ฟเวอร์แล้ว อย่าเริ่มต้นด้วยการประสานงานที่ซับซ้อน เริ่มต้นด้วยการตรวจสอบโดยตรงแบบง่าย ๆ

ลองพรอมต์เช่น:

• "แสดงรายการไฟล์ในโฟลเดอร์ Desktop ของฉัน"
• "อ่าน ~/Documents/todo.md และสรุปสามลำดับความสำคัญสูงสุด"
• "รัน git status ในโฟลเดอร์โปรเจกต์ในเครื่องของฉันและอธิบายว่ามีอะไรเปลี่ยนแปลง"
• "ถ่ายภาพหน้าจอชื่อ workspace-check"
• "เปิด README โปรเจกต์ของฉัน"

ถ้าโฟลว์ง่าย ๆ เหล่านี้ทำงานได้สม่ำเสมอ แสดงว่าคุณมีเซิร์ฟเวอร์ที่คุ้มค่าต่อการขยาย

ถ้าไม่ได้ผล การเพิ่มเครื่องมือมากขึ้นจะซ่อนปัญหาที่แท้จริงเท่านั้น

จุดที่เซิร์ฟเวอร์ MCP ในเครื่องมีคุณค่าอย่างแท้จริง

กรณีการใช้งานที่ชัดเจนคือการพัฒนา แต่นั่นเป็นเพียงช่องทางเดียวเท่านั้น

เวิร์กโฟลว์นักพัฒนา

Claude สามารถ:

• ตรวจสอบโฟลเดอร์ repo
• อ่านไฟล์กำหนดค่า
• รัน git status
• จับภาพหน้าจอสถานะบั๊ก
• เปิดไดเรกทอรีโปรเจกต์

นั่นช่วยลดการสลับบริบทได้มากแล้ว

เวิร์กโฟลว์วิจัย

Claude สามารถ:

• แสดงรายการโฟลเดอร์วิจัย
• เปิดและสรุปบันทึก Markdown
• อ่าน CSV ที่มีโครงสร้าง
• บันทึกภาพหน้าจอจากเครื่องมือหรือแดชบอร์ด
• เปิดไฟล์ต้นฉบับหรือลิงก์เบราว์เซอร์

เวิร์กโฟลว์เนื้อหา

Claude สามารถ:

• สแกนโฟลเดอร์ร่าง
• อ่านไอเดียโพสต์ที่มีอยู่
• จับภาพหน้าจอของดีไซน์อ้างอิง
• เปิดไฟล์เขียนหรือ URL ที่ถูกต้อง
• รันคำสั่งที่จำกัดซึ่งสร้างอาร์ติแฟกต์บิวด์หรือส่งออกแบบร่าง

เวิร์กโฟลว์ปฏิบัติการ

Claude สามารถ:

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

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

เลเยอร์ความปลอดภัยคือผลิตภัณฑ์

นี่คือส่วนที่บทความเทคนิคจำนวนมากดูถูก

ส่วนที่อันตรายของ MCP ในเครื่องไม่ใช่โปรโตคอล มันคือการออกแบบสิทธิ์ที่ไม่ดี

หากคุณต้องการให้เซิร์ฟเวอร์นี้ใช้งานได้จริงนอกเหนือจากเดโม ให้สร้างโมเดลความปลอดภัยตั้งแต่เนิ่น ๆ

ใช้รายการอนุญาตไดเรกทอรี

Claude ควรสามารถมองเห็นเฉพาะพาธที่คุณอนุมัติอย่างชัดเจน นั่นคือเหตุผลที่ _resolve_path() เป็นแกนหลักของเครื่องมือไฟล์

ใช้รายการอนุญาตคำสั่ง

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

แยกเครื่องมืออ่านจากเครื่องมือดำเนินการ

เครื่องมือแบบอ่านอย่างเดียวควรเป็นค่าเริ่มต้น ควรเพิ่มเครื่องมือดำเนินการอย่างตั้งใจ

บันทึกทุกอย่าง

แม้แต่บันทึก JSON แบบต่อท้ายอย่างเดียวก็ทำให้การดีบักและความไว้วางใจดีขึ้นอย่างมาก

เพิ่มเลเยอร์การยืนยันสำหรับการเขียน

หากคุณเพิ่ม write_file, move_file, หรือ delete_file ในภายหลัง ให้เครื่องมือเหล่านั้นต้องใช้โทเค็นการยืนยันครั้งที่สองหรือคงถูกปิดใช้งานตามค่าเริ่มต้น

พิจารณาโหมดทดลองใช้งาน

สำหรับเครื่องมือที่ดำเนินการ โหมดทดลองใช้งานถูกมองข้าม มันช่วยให้ Claude อธิบายว่ามัน จะ ทำอะไรก่อนที่จะทำ

รันภายใต้ผู้ใช้ที่ถูกจำกัดเมื่อเป็นไปได้

หากคุณจริงจังกับระบบอัตโนมัติในเครื่อง อย่าให้เซิร์ฟเวอร์ MCP ของคุณมีสิทธิ์ OS มากกว่าที่ต้องการ

กฎง่าย ๆ ที่มีประโยชน์:

• ระดับ 1: เครื่องมือแบบอ่านอย่างเดียว
• ระดับ 2: การดำเนินการความเสี่ยงต่ำเช่นเปิดไฟล์ / เปิดแอป
• ระดับ 3: การดำเนินการเขียนที่ยืนยันแล้ว
• ระดับ 4: การดำเนินการทำลายล้างที่คุณไม่ควรเปิดเผยอย่างไม่เป็นทางการ

คนส่วนใหญ่ไม่เคยต้องการระดับ 4

สิ่งที่ควรปรับปรุงหลังจาก v1

เวอร์ชันแรกที่ดีจะได้รับสิทธิ์ในการมีความสามารถมากขึ้น

เมื่อเซิร์ฟเวอร์พื้นฐานมีความเสถียรแล้ว อัปเกรดที่สมเหตุสมผลถัดไปคือ:

1. ไฟล์นโยบายแบบรวมศูนย์

ย้ายกฎของคุณไปยัง config/policy.json เพื่อให้การเปลี่ยนแปลงเป็นแบบประกาศ

ตัวอย่าง:

1{
2  "allowed_roots": [
3    "~/Documents",
4    "~/Desktop",
5    "./"
6  ],
7  "allowed_commands": [
8    "pwd",
9    "ls",
10    "git status",
11    "git diff --stat",
12    "python --version"
13  ]
14}

1. การบันทึกที่มีโครงสร้าง

บันทึกการเรียกเครื่องมือ การประทับเวลา อาร์กิวเมนต์ และผลลัพธ์ไปยัง logs/server.log หรือไฟล์ JSONL

1. การดำเนินการคำสั่งที่ปลอดภัยยิ่งขึ้น

แทนที่จะใช้เครื่องมือคำสั่งทั่วไปเครื่องมือเดียว ให้แยกคำสั่งเป็นเครื่องมือที่แคบลง เช่น:

• git_status
• show_current_directory
• list_project_files

นั่นทำให้การเลือกเครื่องมือง่ายขึ้นสำหรับ Claude และความปลอดภัยง่ายขึ้นสำหรับคุณ

1. การจัดการภาพหน้าจอที่ดีขึ้น

คุณสามารถพัฒนาจาก "บันทึกภาพหน้าจอลงดิสก์" เป็น:

• การจับภาพประทับเวลา
• การจับภาพหน้าต่างที่ใช้งาน
• การจับภาพพื้นที่
• กฎการเก็บรักษาไฟล์

1. อะแดปเตอร์อัตโนมัติเฉพาะ OS

บน macOS คุณอาจเพิ่ม AppleScript หรือ Shortcuts ในภายหลัง บน Windows, PowerShell หรือ UI Automation บน Linux ตัวเรียกใช้และเครื่องมือหน้าต่างเฉพาะเดสก์ท็อป

แต่สิ่งนั้นควรมาหลังจากที่แกนหลักในเครื่องที่น่าเบื่อมีความน่าเชื่อถือแล้ว

ข้อผิดพลาดทั่วไปที่ผู้คนทำกับเซิร์ฟเวอร์ MCP ในเครื่อง

ข้อผิดพลาดสามารถคาดเดาได้

ข้อผิดพลาดที่ 1: พลังมากเกินไป เร็วเกินไป

ผู้คนชอบแนวคิดของการควบคุมคอมพิวเตอร์อย่างสมบูรณ์ พวกเขาเกลียดการดีบักมัน เริ่มให้เล็กลง

ข้อผิดพลาดที่ 2: ชื่อเครื่องมือที่คลุมเครือ

ถ้าชื่อเครื่องมือของคุณคลุมเครือ Claude จะใช้มันไม่ดี จงชัดเจน

ไม่ดี:

• system_action
• computer_control

ดีกว่า:

• list_files
• read_file
• run_command
• take_screenshot
• open_target

ข้อผิดพลาดที่ 3: ผลลัพธ์ที่ไม่มีโครงสร้าง

กลุ่มข้อความที่ผสมกันยากกว่าที่ Claude จะใช้เหตุผลมากกว่าวัตถุ JSON ที่สะอาด

ข้อผิดพลาดที่ 4: ไม่มีการบันทึก

ถ้าเครื่องมือล้มเหลวและคุณไม่เห็นสาเหตุ ระบบจะกลายเป็นการเดา

ข้อผิดพลาดที่ 5: การปฏิบัติต่อโมเดลเหมือนเลเยอร์ควบคุม

Claude คือเลเยอร์การให้เหตุผล เซิร์ฟเวอร์ของคุณยังคงต้องเป็นเลเยอร์การบังคับใช้

ความแตกต่างนั้นไม่สามารถต่อรองได้

สถาปัตยกรรมนี้ทำได้ดีกว่าระบบอัตโนมัติทั่วไปอย่างไร

ระบบอัตโนมัติเดสก์ท็อปแบบดั้งเดิมมักจะเป็นหนึ่งในสองสิ่ง:

• สคริปต์ GUI ที่เปราะบาง
• สคริปต์ที่แยกเดี่ยวซึ่งต้องการให้มนุษย์รู้ว่าควรเรียกใช้เมื่อใด

เซิร์ฟเวอร์ MCP ในเครื่องเปลี่ยนสิ่งนั้นเพราะ Claude สามารถตัดสินใจได้ว่า เครื่องมือใด ที่จะใช้ตามคำขอของผู้ใช้และบริบทที่มีอยู่

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

นี่คือเหตุผลที่ MCP รู้สึกสำคัญ มันไม่ใช่แค่รูปแบบการรวมอีกแบบหนึ่ง มันเป็นวิธีที่สะอาดกว่าในการเปิดเผยการใช้เครื่องมือให้กับโมเดลโดยไม่ต้องฮาร์ดโค้ดทุกเวิร์กโฟลว์ที่เป็นไปได้ในเลเยอร์แอปพลิเคชัน

ขีดจำกัดที่คุณควรเคารพ

แม้แต่เซิร์ฟเวอร์ MCP ในเครื่องที่ดีก็มีข้อจำกัดจริง

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

พูดอีกอย่างคือ: อย่าสับสนระหว่าง "โมเดลสามารถดำเนินการ" กับ "โมเดลควรดำเนินการโดยไม่มีการดูแล"

รูปแบบที่มีคุณค่ามากกว่าคือการควบคุมร่วมกัน ไม่ใช่การปกครองตนเองแบบไม่เห็นอะไร