สร้างเซิร์ฟเวอร์ MCP สำหรับ Claude Code — คำแนะนำเชิงปฏิบัติและทันสมัย

CometAPI
AnnaNov 22, 2025
สร้างเซิร์ฟเวอร์ MCP สำหรับ Claude Code — คำแนะนำเชิงปฏิบัติและทันสมัย

Model Context Protocol (MCP) เป็นมาตรฐานเปิดที่ให้โมเดลเช่น Anthropic Claude และเครื่องมือสำหรับนักพัฒนาเช่น รหัสคล็อด เรียกออกไปยังเครื่องมือภายนอก แหล่งข้อมูล และคำเตือนในวิธีมาตรฐานที่ปลอดภัย

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

Model Context Protocol (MCP) คืออะไร?

MCP (Model Context Protocol) คือ ข้อมูลจำเพาะแบบเปิด ออกแบบมาเพื่อกำหนดมาตรฐานว่าไคลเอนต์โมเดลภาษา (เช่น Claude, Claude Code หรือฟรอนต์เอนด์ LLM อื่นๆ) จะเชื่อมต่อกับเซิร์ฟเวอร์เครื่องมือและแหล่งข้อมูลอย่างไร ลองนึกถึง MCP ว่าเป็น "พอร์ต USB-C สำหรับ LLM" ซึ่งกำหนดรูปแบบการขนส่ง/JSON-RPC และเป็นวิธีทั่วไปที่เซิร์ฟเวอร์จะเผยแพร่ความสามารถสามประเภท:

  • แหล่งข้อมูล — ข้อมูลประเภทไฟล์หรือข้อมูลเอกสารที่ไคลเอนต์สามารถอ่านได้ (เช่น แถวฐานข้อมูล ไฟล์ข้อความ เพย์โหลด JSON)
  • เครื่องมือ — ฟังก์ชันที่เรียกได้ซึ่งโมเดลสามารถขอให้โฮสต์ดำเนินการได้ (โดยได้รับการอนุมัติจากผู้ใช้)
  • แจ้ง — เทมเพลตคำเตือนหรือเวิร์กโฟลว์ที่นำมาใช้ซ้ำได้ซึ่งโมเดล/ไคลเอนต์สามารถเรียกใช้ได้

MCP รองรับการขนส่งหลายรูปแบบ (stdio, HTTP, SSE) และมี schema, SDK และเซิร์ฟเวอร์ตัวอย่าง คุณจึงไม่จำเป็นต้องคิดค้นรูปแบบ wire เอง โปรโตคอลนี้ได้รับการดูแลแบบสาธารณะ (spec + SDK) และมีบทช่วยสอนและแกลเลอรีเซิร์ฟเวอร์ตัวอย่างเพื่อเร่งการใช้งาน

MCP ได้รับการออกแบบทางสถาปัตยกรรมอย่างไร?

สถาปัตยกรรมของ MCP นั้นถูกออกแบบมาให้เรียบง่ายและเป็นโมดูล โดยชิ้นส่วนหลักๆ คือ MCP เซิร์ฟเวอร์, เอ็มซีพี ลูกค้า และ การขนส่ง ที่บรรจุข้อความเฟรม JSON-RPC ระหว่างกัน ด้านล่างนี้คือส่วนประกอบหลักที่คุณจะใช้เมื่อสร้างเซิร์ฟเวอร์สำหรับ Claude Code (หรือไคลเอนต์ MCP อื่นๆ)

เซิร์ฟเวอร์ ไคลเอนต์ และโปรโตคอล

  • เซิร์ฟเวอร์ MCP — บริการที่ เผยแพร่ เครื่องมือ ทรัพยากร และคำแนะนำ เครื่องมือสามารถทำงานด้านผลข้างเคียงหรือดึงข้อมูลได้ ทรัพยากรแสดงเนื้อหาแบบอ่านอย่างเดียว คำแนะนำคือเทมเพลตคำแนะนำที่สามารถนำกลับมาใช้ซ้ำได้ ซึ่งลูกค้าสามารถขอให้แบบจำลองสุ่มตัวอย่างได้
  • ไคลเอนต์ MCP (โฮสต์) — โดยทั่วไปเป็นส่วนหนึ่งของโฮสต์ LLM (เช่น Claude Code, ปลั๊กอิน VS Code, ไคลเอนต์เบราว์เซอร์) โดยจะค้นหาเซิร์ฟเวอร์ที่พร้อมใช้งาน นำเสนอคำอธิบายเครื่องมือให้กับโมเดล และกำหนดเส้นทางการเรียกที่เริ่มต้นโดยโมเดลไปยังเซิร์ฟเวอร์
  • โปรโตคอล — ข้อความจะถูกเข้ารหัสเป็น JSON-RPC ข้อมูลจำเพาะจะกำหนดเหตุการณ์ในวงจรชีวิต การค้นพบเครื่องมือ การเรียกใช้ การดำเนินการให้เสร็จสมบูรณ์/การสุ่มตัวอย่าง และวิธีการส่งผลลัพธ์ที่มีโครงสร้างกลับไปยังไคลเอนต์และโมเดล

รูปแบบการสื่อสาร (สิ่งที่เกิดขึ้นเมื่อใช้เครื่องมือ)

  1. ไคลเอนต์ส่งข้อความผู้ใช้ไปยังโมเดล
  2. แบบจำลองวิเคราะห์บริบทและตัดสินใจเรียกใช้เครื่องมือที่เปิดเผยโดย MCP (หรือเครื่องมือหลายตัว)
  3. ไคลเอนต์ส่งต่อการเรียกเครื่องมือไปยังเซิร์ฟเวอร์ MCP ผ่านการขนส่งที่เลือก
  4. เซิร์ฟเวอร์ดำเนินการเครื่องมือและส่งผลลัพธ์กลับมา
  5. แบบจำลองจะรับผลลัพธ์จากเครื่องมือและสร้างคำตอบสุดท้ายให้กับผู้ใช้

การใช้งานเบื้องต้น

  • JSON-RPC ข้อความปฏิบัติตามรูปแบบ MCP
  • คำจำกัดความของเครื่องมือ จะถูกเผยแพร่ในการตอบกลับการค้นพบของเซิร์ฟเวอร์เพื่อให้ไคลเอนต์สามารถนำเสนอใน UI ได้
  • แหล่งข้อมูล มีการอ้างอิงโดย @source:path ไวยากรณ์โดยไคลเอนต์ (เช่น @postgres:...) ช่วยให้โมเดลอ้างอิงถึงเนื้อหาภายนอกโดยไม่ต้องใส่ข้อมูลขนาดใหญ่ลงในพรอมต์

เหตุใดจึงต้องบูรณาการ Claude Code เข้ากับเซิร์ฟเวอร์ MCP?

Claude Code คือบริการของ Anthropic ที่มุ่งเน้นเวิร์กโฟลว์ที่เน้นโค้ดและนักพัฒนา (การรวมโปรแกรมแก้ไข/IDE การทำความเข้าใจโค้ด ฯลฯ) การเปิดเผยเครื่องมือภายในของคุณ (การค้นหาซอร์สโค้ด, CI รันเนอร์, ระบบตั๋ว, รีจิสทรีส่วนตัว) ผ่านเซิร์ฟเวอร์ MCP ช่วยให้ Claude Code สามารถเรียกใช้งานเครื่องมือเหล่านี้ได้ เครื่องมือชั้นหนึ่ง ภายในการสนทนาการเข้ารหัสและการไหลของตัวแทน

การรวม Claude Code เข้ากับเซิร์ฟเวอร์ MCP จะช่วยปลดล็อกความสามารถที่เกี่ยวข้องกับการผลิตในทางปฏิบัติสำหรับตัวแทนการเข้ารหัส:

1. ให้แบบจำลอง กระทำ บนระบบจริง

Claude Code สามารถขอให้เซิร์ฟเวอร์ MCP สืบค้นตัวติดตามปัญหา รันการสืบค้นฐานข้อมูล อ่านเอกสารขนาดใหญ่ หรือสร้าง PR ของ GitHub ซึ่งช่วยให้สามารถทำงานอัตโนมัติแบบครบวงจรจากภายในเซสชันการเขียนโค้ดได้ เอกสารของ Claude Code รองรับฟังก์ชันนี้อย่างชัดเจน (ตัวอย่าง: การสืบค้น Postgres, Sentry หรือการสร้าง PR)

2. ถ่ายโอนข้อมูลขนาดใหญ่และตรรกะเฉพาะทาง

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

3. ความปลอดภัยและการกำกับดูแล

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

4. การนำกลับมาใช้ใหม่และระบบนิเวศ

เซิร์ฟเวอร์ MCP สามารถนำมาใช้ซ้ำได้ระหว่างไคลเอนต์และทีมต่างๆ สร้างเพียงครั้งเดียวและไคลเอนต์ Claude/LLM หลายตัวสามารถใช้บริการเดียวกันได้ (หรือสลับการใช้งาน)

คุณต้องการอะไรก่อนที่จะเริ่ม?

ความต้องการขั้นต่ำ

  • เครื่องพัฒนาที่มี หลาม 3.10+ (เราจะใช้ Python ในตัวอย่างนี้) นอกจากนี้ MCP SDK ยังรองรับ Node หรือภาษาอื่นๆ อีกด้วย
  • uv (เครื่องมือของ Astral) หรือโปรแกรมรันเนอร์ที่เทียบเท่าสำหรับการรันเซิร์ฟเวอร์ MCP stdio (บทช่วยสอน MCP ใช้ uv). ขั้นตอนการติดตั้งแสดงด้านล่างนี้.
  • ติดตั้ง Claude Code หรือเข้าถึงไคลเอนต์ Claude (เดสก์ท็อปหรือ CLI) เพื่อลงทะเบียนและทดสอบเซิร์ฟเวอร์ของคุณ หรือไคลเอนต์ใดๆ ที่รองรับ MCP Claude Code รองรับ HTTP, SSE และเซิร์ฟเวอร์ stdio ภายในเครื่อง
  • บันทึกความปลอดภัย:เพิ่มเซิร์ฟเวอร์ MCP ที่เชื่อถือได้ให้กับ Claude Code ในการตั้งค่าทีมหรือองค์กรเท่านั้น — MCP ช่วยให้เซิร์ฟเวอร์เข้าถึงข้อมูลที่ละเอียดอ่อนได้ และมีความเสี่ยงที่จะแทรกข้อมูลทันทีหากเซิร์ฟเวอร์ส่งคืนเนื้อหาที่เป็นอันตราย

วิธีการติดตั้งและตรวจสอบ Claude Code CLI

นี่คือ คู่มือการติดตั้งและใช้งาน Claude Code.

1) สรุปโดยย่อ — วิธีการติดตั้งที่แนะนำ

ใช้ โปรแกรมติดตั้งดั้งเดิม (แนะนำ) หรือ Homebrew บน macOS/Linux มี NPM ให้ใช้งานหากคุณต้องการติดตั้งแบบ Node ส่วน Windows มีตัวติดตั้ง PowerShell / CMD ที่มา: เอกสาร Claude Code อย่างเป็นทางการและ GitHub

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

  • macOS 10.15+, Ubuntu 20.04+/Debian 10+ หรือ Windows 10+ (แนะนำ WSL บน Windows)
  • Node.js 18+ จำเป็นเท่านั้น สำหรับวิธีการติดตั้ง NPM

3) คำสั่งการติดตั้ง (เลือกหนึ่งคำสั่ง)

ดั้งเดิม (แนะนำ — ไม่ต้องพึ่งพาโหนด)，macOS / Linux / WSL:

curl -fsSL https://claude.ai/install.sh | bash
# optional: install latest explicitly

curl -fsSL https://claude.ai/install.sh | bash -s latest
# or install a specific version

curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58

Windows PowerShell:

irm https://claude.ai/install.ps1 | iex
# or for latest: & (::Create((irm https://claude.ai/install.ps1))) latest

(เหล่านี้เป็นสคริปต์ติดตั้งดั้งเดิมอย่างเป็นทางการ)

NPM (หากคุณต้องการติดตั้งแบบทั่วโลกโดยใช้ Node):

# requires Node.js 18+

npm install -g @anthropic-ai/claude-code

อย่า ใช้ sudo npm install -g — เตือนเกี่ยวกับการติดตั้ง sudo global (ปัญหาการอนุญาต/ความปลอดภัย) หากคุณพบข้อผิดพลาดเกี่ยวกับการอนุญาต ให้ใช้ nvm หรือแก้ไขคำนำหน้าทั่วโลก npm ของคุณแทนที่จะใช้ sudo

4) ตรวจสอบว่ามีการติดตั้งไบนารีแล้ว (การตรวจสอบพื้นฐาน)

รันสิ่งเหล่านี้ในเครื่องทันทีหลังการติดตั้ง:

# is the command on PATH?

which claude

# version (or -v)

claude --version
# or

claude -v

# help (sanity check)

claude --help

ที่คาดว่าจะ which แสดงเส้นทาง (เช่น /usr/local/bin/claude or ~/.nvm/.../bin/claude) and claude --version พิมพ์สตริงแบบเซมเวอร์ ทั้งเอกสารและ README แสดง claude เป็นจุดเข้า CLI หลัก

5) ตรวจสอบสถานะการติดตั้งและการกำหนดค่า (การตรวจสอบที่แนะนำ)

a) claude doctor,วิ่ง:

claude doctor

การวินิจฉัยในตัวนี้จะตรวจสอบประเภทการติดตั้งของคุณ ปัญหาทั่วไป (เช่น ปัญหาการอนุญาต npm) การอ้างอิง เช่น ripgrepและแนะนำวิธีแก้ไข เอกสารแนะนำให้รันอย่างชัดเจน claude doctor หลังจากติดตั้งแล้ว

ข) ทำการทดสอบควัน (แบบไม่โต้ตอบ)

จากไดเร็กทอรีโครงการของคุณ:

cd /path/to/your/project
claude -p "Explain this project in 3 sentences"

สิ่งนี้ใช้ พิมพ์ โหมด (-p) เพื่อส่งคำเตือนครั้งเดียวแล้วออก เหมาะสำหรับ CI หรือการตรวจสอบการทำงานอย่างรวดเร็ว

c) การตรวจสอบการพิสูจน์ตัวตน (ตรวจสอบให้แน่ใจว่า CLI สามารถเข้าถึง Anthropic ได้)

Claude Code รองรับโฟลว์การตรวจสอบสิทธิ์หลายแบบ (OAuth ของคอนโซล, คีย์ API, การผสานรวมผู้ให้บริการ) การตรวจสอบทั่วไป:

  1. หากใช้คีย์ API (CI / headless / local env var):
export ANTHROPIC_API_KEY="sk-..."
# then

claude auth status
claude auth whoami    # or `claude auth whoami` / `claude whoami` depending on version

คุณสามารถใช้ได้ โคเมทเอพีไอรหัส API ของ Claude Code เพื่อใช้ในการใช้งาน API ของ Claude ผ่าน CometAPI จะทำให้คุณได้รับส่วนลด 20%

  1. หากคุณใช้ OAuth ผ่านคอนโซล - วิ่ง:
claude auth status
claude auth whoami

คุณควรเห็นข้อมูลบัญชี/แผนหรือการยืนยันว่าคุณได้รับการตรวจสอบแล้ว

การเตรียมสภาพแวดล้อมแบบทีละขั้นตอน

ด้านล่างนี้เป็นขั้นตอนที่ชัดเจนในการเตรียมสแต็กนักพัฒนาสองชุดทั่วไป (TypeScript และ Python) ตามด้วยการตรวจสอบอย่างรวดเร็วเพื่อให้แน่ใจว่าทุกอย่างทำงานได้

H3 — A. การตั้งค่า TypeScript / Node (เส้นทางที่เร็วที่สุด)

  1. สร้างโครงการและติดตั้ง SDK:
mkdir mcp-demo && cd mcp-demo
npm init -y
npm install @modelcontextprotocol/sdk express zod
npm install --save-dev typescript tsx @types/node @types/express
  1. สร้างบัญชีตัวแทน server.ts(เราให้ตัวอย่างครบถ้วนในหัวข้อ “วิธีสร้างอย่างรวดเร็ว…”)
  2. วิ่ง:
npx -y tsx server.ts
  1. ทดสอบในพื้นที่ด้วย ผู้ตรวจสอบ MCP หรือเพิ่มใน Claude Code:
npx @modelcontextprotocol/inspector
# or (for Claude Code)

claude mcp add --transport http my-server http://localhost:3000/mcp

(คำสั่ง Inspector และ Claude ช่วยให้คุณตรวจสอบการค้นพบและเรียกใช้เครื่องมือ)

จะสร้างเซิร์ฟเวอร์ MCP สำหรับ Claude Code ได้อย่างรวดเร็วอย่างไร?

รายการตรวจสอบด่วน

  1. เริ่มต้นเซิร์ฟเวอร์ของคุณ (แนะนำ Streamable HTTP): node server.ts or uvicorn server:app.

  2. จากเครื่องพัฒนาของคุณ:

  • ใช้ ผู้ตรวจสอบ MCP เพื่อตรวจสอบ (npx @modelcontextprotocol/inspector) และยืนยัน tools/list และ resources/list; หรือ
  • เพิ่มเซิร์ฟเวอร์ลงใน Claude Code: claude mcp add --transport http <name> http://<host>:<port>/mcp (หรือทำตามขั้นตอน UI บนเว็บหากไคลเอนต์ของคุณรองรับ MCP ระยะไกล)

หากคุณวางแผนที่จะใช้ตัวเชื่อมต่อ Messages API ของ Anthropic สำหรับ MCP ระยะไกล (ไม่มีไคลเอนต์แยกต่างหาก) โปรดอ่านเอกสารของ Claude — อาจต้องใช้ส่วนหัวเบต้า (ตรวจสอบเอกสารสำหรับส่วนหัวที่แน่นอนและสถานะการสนับสนุนปัจจุบัน)

ด้านล่างนี้คือตัวอย่างเซิร์ฟเวอร์ที่สมบูรณ์แต่กะทัดรัดสองตัวอย่างที่คุณสามารถคัดลอก รัน และเชื่อมต่อกับ Claude Code (หรือ MCP Inspector) ได้ ตัวอย่าง TypeScript ใช้ Express + TypeScript SDK ส่วนตัวอย่าง Python สาธิตการติดตั้ง FastAPI

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

ตัวอย่างที่ 1: TypeScript + Express (Streamable HTTP)

สร้างบัญชีตัวแทน server.ts (สมบูรณ์):

// server.ts
import express from "express";
import * as z from "zod/v4";
import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";

const server = new McpServer({ name: "claude-code-demo", version: "0.1.0" });

// Register a simple tool: add two numbers
server.registerTool(
  "add",
  {
    title: "Add",
    description: "Add two numbers a and b",
    inputSchema: { a: z.number(), b: z.number() },
    outputSchema: { result: z.number() }
  },
  async ({ a, b }) => {
    const output = { result: a + b };
    return {
      content: ,
      structuredContent: output
    };
  }
);

// Register a resource: greet user (dynamic)
server.registerResource(
  "greeting",
  new ResourceTemplate("greeting://{name}", { list: undefined }),
  { title: "Greeting", description: "Return a greeting for the name" },
  async (uri, params) => {
    return {
      contents: 
    };
  }
);

// Express + Streamable HTTP transport
const app = express();
app.use(express.json());

app.post("/mcp", async (req, res) => {
  const transport = new StreamableHTTPServerTransport({ enableJsonResponse: true });
  // Close transport when connection closes
  res.on("close", () => transport.close());
  await server.connect(transport);
  await transport.handleRequest(req, res, req.body);
});

const port = parseInt(process.env.PORT || "3000", 10);
app.listen(port, () => console.log(`MCP server listening: http://localhost:${port}/mcp`));

วิ่ง:

npm install
npx -y tsx server.ts

จากนั้นเชื่อมต่อใน Claude Code (ตัวอย่าง):

# Add the remote server to your Claude Code MCP list (local dev)

claude mcp add --transport http my-demo http://localhost:3000/mcp

ตัวอย่างนี้ดัดแปลงมาจาก TypeScript SDK Quick Start อย่างเป็นทางการ และสาธิตวิธีการลงทะเบียนเครื่องมือและทรัพยากร จากนั้นเปิดเผยผ่าน Streamable HTTP

ตัวอย่างที่ 2: Python + FastAPI (FastMCP + Streamable HTTP)

สร้างบัญชีตัวแทน server.py (สมบูรณ์):

# server.py

from fastapi import FastAPI
from mcp.server.fastmcp import FastMCP

app = FastAPI()
mcp = FastMCP("claude-python-demo", stateless_http=True)

# tool: simple sum

@mcp.tool()
def add(a: int, b: int) -> dict:
    """Add two integers"""
    return {"result": a + b}

# resource: simple greeting resource template

@mcp.resource("greeting://{name}")
def greeting(name: str):
    return {"contents": }

# mount the streamable-http MCP endpoint (FastMCP exposes an ASGI app)

app.mount("/mcp", mcp.streamable_http_app())

# optional endpoint to demonstrate other API routes

@app.get("/")
async def root():
    return {"status": "OK"}

วิ่ง:

uvicorn server:app --reload --port 8000

เชื่อมต่อกับผู้ตรวจสอบ:

npx @modelcontextprotocol/inspector
# In Inspector select Streamable HTTP and enter http://localhost:8000/mcp

ตัวอย่าง Python SDK และยูทิลิตี้ FastMCP ทำให้การลงทะเบียนเป็นเรื่องง่าย @mcp.tool() และ @mcp.resource() ฟังก์ชั่นตกแต่งที่ LLM สามารถค้นพบและเรียกใช้งาน

Claude Code เรียกเครื่องมือของคุณว่าอย่างไร?

เมื่อ LLM ตัดสินใจใช้เครื่องมือ ไคลเอนต์จะส่งการเรียกใช้ JSON-RPC ไปยังเซิร์ฟเวอร์ MCP เซิร์ฟเวอร์จะดำเนินการเครื่องมือที่ร้องขอ (เช่น สืบค้นฐานข้อมูล รันการทดสอบ หรือเรียกใช้ API ภายนอก) และส่งกลับ เนื้อหาที่มีโครงสร้าง และ เนื้อหาที่นำเสนอได้ไคลเอนต์ (Claude Code) สามารถรวมเอาต์พุตที่มีโครงสร้างไว้ในบริบทของโมเดล เพื่อให้โมเดลสามารถวิเคราะห์ข้อมูลที่เชื่อถือได้ต่อไปได้ ไม่ใช่แค่เอาต์พุตข้อความของเซิร์ฟเวอร์เท่านั้น TypeScript SDK รองรับการลงทะเบียน inputSchema และ outputSchema (zod) ดังนั้นอาร์กิวเมนต์และเอาต์พุตจึงได้รับการตรวจสอบและพิมพ์ด้วยเครื่อง

คุณควรใช้เครื่องมือทดสอบและแก้ไขจุดบกพร่องใด

ผู้ตรวจสอบ MCP

การขอ ผู้ตรวจสอบ MCP เป็นเครื่องมือสำหรับนักพัฒนาซอฟต์แวร์แบบ Visual อย่างเป็นทางการสำหรับการทดสอบเซิร์ฟเวอร์ MCP ช่วยให้คุณเชื่อมต่อกับเซิร์ฟเวอร์ (stdio, SSE หรือ streamable-HTTP) แสดงรายการเครื่องมือ เรียกใช้งานด้วยตนเอง และตรวจสอบวงจรชีวิตของข้อความ JSON-RPC ซึ่งมีประโยชน์อย่างยิ่งในระหว่างการพัฒนา เริ่มต้นใช้งานผ่าน npx @modelcontextprotocol/inspector.

การทดสอบในพื้นที่เทียบกับการทดสอบระยะไกล

  • ท้องถิ่น (stdio) — วงจรการวนซ้ำอย่างรวดเร็วสำหรับแอปเดสก์ท็อปและการดีบักแบบออฟไลน์
  • HTTP ที่สามารถสตรีมได้ — ทดสอบกับผู้ตรวจสอบหรือเชื่อมต่อกับ Claude Code โดยใช้ claude mcp add CLI หรือตัวเชื่อมต่อ MCP ใน Messages API สำหรับการทดสอบระยะไกล ตรวจสอบให้แน่ใจว่าได้ระบุส่วนหัวการตรวจสอบสิทธิ์ที่จำเป็นสำหรับเซิร์ฟเวอร์ของคุณ

สรุป

MCP คือสะพานเชื่อมระหว่าง LLM สมัยใหม่กับระบบที่จัดเก็บข้อมูลและดำเนินการจริง สำหรับเวิร์กโฟลว์โค้ด การผสานรวม Claude Code เข้ากับเซิร์ฟเวอร์ MCP ช่วยให้โมเดลสามารถเข้าถึงคลังข้อมูล CI ตัวติดตามปัญหา และเครื่องมือที่กำหนดเองได้อย่างมีโครงสร้างและตรวจสอบได้ ส่งผลให้ระบบอัตโนมัติแม่นยำยิ่งขึ้นและปลอดภัยยิ่งขึ้น ด้วย SDK อย่างเป็นทางการใน TypeScript และ Python, Streamable HTTP สำหรับการโฮสต์ระยะไกล และเครื่องมืออย่าง MCP Inspector คุณสามารถสร้างเซิร์ฟเวอร์ขนาดเล็กได้ภายในไม่กี่นาที และทำซ้ำเพื่อนำไปใช้งานจริงได้

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

พร้อมไปหรือยัง?→ ลงทะเบียน CometAPI วันนี้ !

หากคุณต้องการทราบเคล็ดลับ คำแนะนำ และข่าวสารเกี่ยวกับ AI เพิ่มเติม โปรดติดตามเราที่ VK, X และ ไม่ลงรอยกัน!

อ่านเพิ่มเติม

500+ โมเดลใน API เดียว

ลดราคาสูงสุด 20%