Blog

วิธีสร้าง MCP Server สำหรับ Claude Code อย่างรวดเร็ว

Audrey Lopez

Audrey Lopez

13 October 2025

วิธีสร้าง MCP Server สำหรับ Claude Code อย่างรวดเร็ว

Apidog สำหรับองค์กร

การติดตั้งแบบ On-Premises

SSO & RBAC

รองรับมาตรฐาน SOC 2

สำรวจ Apidog Enterprise

Model Context Protocol (MCP) ปฏิวัติวิธีการที่ผู้ช่วย AI โต้ตอบกับเครื่องมือและแหล่งข้อมูลภายนอก ลองนึกถึง MCP เป็นพอร์ต USB-C สากลสำหรับแอปพลิเคชัน AI ซึ่งเป็นวิธีมาตรฐานในการเชื่อมต่อ Claude Code กับแหล่งข้อมูล API หรือเครื่องมือเกือบทุกชนิดที่คุณจินตนาการได้ คู่มือฉบับสมบูรณ์นี้จะนำคุณสร้างเซิร์ฟเวอร์ MCP ของคุณเองตั้งแต่เริ่มต้น ทำให้ Claude Code สามารถเข้าถึงฟังก์ชันที่กำหนดเองซึ่งขยายขีดความสามารถให้เหนือกว่าคุณสมบัติในตัวอย่างมาก

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

💡
ต้องการเครื่องมือทดสอบ API ที่ยอดเยี่ยมซึ่งสร้าง เอกสารประกอบ API ที่สวยงาม หรือไม่?

ต้องการแพลตฟอร์มแบบ All-in-One ที่รวมเข้าด้วยกันสำหรับทีมพัฒนาของคุณเพื่อทำงานร่วมกันด้วย ประสิทธิภาพสูงสุด หรือไม่?

Apidog มอบทุกความต้องการของคุณ และ มาแทนที่ Postman ในราคาที่เข้าถึงได้มากกว่ามาก!
ปุ่ม

MCP Server คืออะไร และทำไมทุกคนถึงพูดถึงมัน

อะไรที่ทำให้ MCP แตกต่าง

MCP (Model Context Protocol) เป็นโปรโตคอลแบบเปิดที่พัฒนาโดย Anthropic ซึ่งช่วยให้โมเดล AI สามารถสื่อสารกับเซิร์ฟเวอร์ภายนอกผ่านอินเทอร์เฟซที่เป็นมาตรฐาน ต่างจากการรวม API แบบดั้งเดิมที่คุณต้องฮาร์ดโค้ดปลายทางเฉพาะ MCP มอบวิธีที่มีโครงสร้างสำหรับผู้ช่วย AI ในการค้นหา ทำความเข้าใจ และใช้เครื่องมือภายนอกแบบไดนามิก

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

เจาะลึกสถาปัตยกรรม MCP

โปรโตคอลนี้เป็นไปตามสถาปัตยกรรมแบบไคลเอนต์-เซิร์ฟเวอร์ โดยมีบทบาทที่กำหนดไว้อย่างชัดเจน:

อธิบายขั้นตอนการสื่อสาร

เมื่อ Claude Code ต้องการใช้เครื่องมือภายนอก สิ่งที่จะเกิดขึ้นมีดังนี้:

  1. Discovery Phase: Claude Code สอบถามเซิร์ฟเวอร์ของคุณเพื่อค้นหาเครื่องมือที่พร้อมใช้งาน
  2. Schema Validation: เซิร์ฟเวอร์ของคุณตอบกลับด้วยคำจำกัดความของเครื่องมือและสคีมาอินพุต
  3. Tool Selection: Claude Code เลือกเครื่องมือที่เหมาะสมตามคำขอของผู้ใช้
  4. Execution Phase: Claude Code ส่งการเรียกเครื่องมือพร้อมพารามิเตอร์ที่ผ่านการตรวจสอบแล้ว
  5. Result Processing: เซิร์ฟเวอร์ของคุณประมวลผลคำขอและส่งคืนผลลัพธ์ที่มีโครงสร้าง

ขั้นตอนการทำงานนี้ช่วยให้มั่นใจในความปลอดภัยของประเภท การจัดการข้อผิดพลาดที่เหมาะสม และพฤติกรรมที่สอดคล้องกันในการรวม MCP ทั้งหมด

ข้อกำหนดเบื้องต้นและการตั้งค่าสภาพแวดล้อม

การวิเคราะห์ข้อกำหนดของระบบ

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

สำหรับการพัฒนา Python:

สำหรับการพัฒนา TypeScript/JavaScript:

Core Dependencies:

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

1. ติดตั้ง Claude Code CLI

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

# Install Claude Code globally
npm install -g @anthropic-ai/claude-code

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

2. ตรวจสอบการติดตั้ง

ตรวจสอบว่า Claude Code ติดตั้งและเข้าถึงได้อย่างถูกต้อง:

# Verify installation and check version
claude --version

# Check available commands
claude --help

3. การตั้งค่าสิทธิ์ที่สำคัญเป็นครั้งแรก

ขั้นตอนนี้มีความสำคัญอย่างยิ่งและมักถูกมองข้าม:

# Run initial setup with permissions bypass
claude --dangerously-skip-permissions

คำสั่งนี้ทำอะไรบ้าง:

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

ข้อควรพิจารณาด้านความปลอดภัย: แฟล็ก --dangerously-skip-permissions ปลอดภัยสำหรับสภาพแวดล้อมการพัฒนา แต่ข้ามการแจ้งเตือนความปลอดภัยตามปกติ ในสภาพแวดล้อมการผลิต ให้ตรวจสอบคำขอสิทธิ์แต่ละรายการอย่างรอบคอบ

การกำหนดค่าที่สำคัญ: การทำความเข้าใจขอบเขตของ MCP

ทำไมขอบเขตการกำหนดค่าถึงสำคัญ

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

Claude Code ใช้ระบบการกำหนดค่าแบบลำดับชั้นที่ออกแบบมาเพื่อให้ความยืดหยุ่นในขณะที่ยังคงรักษาความปลอดภัย แต่ละขอบเขตมีวัตถุประสงค์เฉพาะและมีกรณีการใช้งานที่แตกต่างกัน

อธิบายลำดับชั้นของขอบเขตการกำหนดค่า

1. ขอบเขตโปรเจกต์ (.mcp.json) - ลำดับความสำคัญสูงสุด

ตำแหน่ง: ไดเรกทอรีรากของโปรเจกต์ในไฟล์ .mcp.json

วัตถุประสงค์: เซิร์ฟเวอร์ MCP เฉพาะโปรเจกต์ที่ควรจะพร้อมใช้งานเฉพาะเมื่อทำงานในโปรเจกต์นั้นๆ

กรณีการใช้งาน: การเชื่อมต่อฐานข้อมูลเฉพาะโปรเจกต์, linters เฉพาะโปรเจกต์, หรือเครื่องมือสร้างที่กำหนดเอง

เมื่อขอบเขตโปรเจกต์เหมาะสม:

2. ขอบเขตผู้ใช้ (-scope user) - การกำหนดค่า Global

ตำแหน่ง: การกำหนดค่าไดเรกทอรีหลักของผู้ใช้

วัตถุประสงค์: เซิร์ฟเวอร์ MCP ที่พร้อมใช้งานทั่วโลกในทุกโปรเจกต์และไดเรกทอรี

กรณีการใช้งาน: เครื่องมืออเนกประสงค์ เช่น API สภาพอากาศ, เครื่องมือคำนวณ, หรือยูทิลิตี้ระบบ

ทำไมขอบเขตผู้ใช้จึงเป็นที่นิยมมากกว่า:

3. ขอบเขต Local (ค่าเริ่มต้น) - เฉพาะไดเรกทอรี

ตำแหน่ง: บริบทของไดเรกทอรีที่ทำงานปัจจุบัน

วัตถุประสงค์: การตั้งค่าเซิร์ฟเวอร์ MCP แบบรวดเร็วและชั่วคราว

ข้อจำกัด: ใช้งานได้เฉพาะเมื่อคุณเรียกใช้ Claude Code จากไดเรกทอรีนั้นๆ เท่านั้น

ข้อผิดพลาดในการกำหนดค่าที่พบบ่อย

❌ แนวทางที่ผิด (ขอบเขต Local - ฟังก์ชันจำกัด):

claude mcp add my-server python3 /path/to/server.py

ปัญหา: เซิร์ฟเวอร์นี้ทำงานได้เฉพาะเมื่อคุณอยู่ในไดเรกทอรีที่ลงทะเบียนเท่านั้น

✅ แนวทางที่ถูกต้อง (ขอบเขตผู้ใช้ - การเข้าถึง Global):

claude mcp add --scope user my-server python3 /path/to/server.py

ประโยชน์: เซิร์ฟเวอร์นี้ทำงานได้จากไดเรกทอรีใดก็ได้บนระบบของคุณ

การวางแผนไดเรกทอรีเชิงกลยุทธ์

โครงสร้างไดเรกทอรีที่แนะนำ

สร้างโครงสร้างไดเรกทอรีที่จัดระเบียบอย่างดีเพื่อการบำรุงรักษาในระยะยาว:

# Create permanent storage location
mkdir -p ~/.claude-mcp-servers/

# Organize by functionality
mkdir -p ~/.claude-mcp-servers/apis/
mkdir -p ~/.claude-mcp-servers/utilities/
mkdir -p ~/.claude-mcp-servers/development/

ประโยชน์ของโครงสร้างที่จัดระเบียบ

การบำรุงรักษา: ง่ายต่อการค้นหาและอัปเดตเซิร์ฟเวอร์ในภายหลัง

ความปลอดภัย: การแยกที่ชัดเจนระหว่างเครื่องมือประเภทต่างๆ

การสำรองข้อมูล: ง่ายต่อการสำรองเซิร์ฟเวอร์ MCP ทั้งหมดโดยการสำรองไดเรกทอรีเดียว

การแบ่งปัน: ง่ายต่อการแบ่งปันการกำหนดค่าเซิร์ฟเวอร์กับสมาชิกในทีม

คู่มือการแก้ไขปัญหาขอบเขต

การวินิจฉัยปัญหาขอบเขต

หากเซิร์ฟเวอร์ MCP ของคุณไม่ปรากฏขึ้น ให้ทำตามลำดับการวินิจฉัยนี้:

  1. ตรวจสอบการกำหนดค่าขอบเขตปัจจุบัน:
claude mcp list
  1. ตรวจสอบว่าคุณไม่ได้อยู่ในไดเรกทอรีที่มีขอบเขตโปรเจกต์ที่ขัดแย้งกัน:
ls .mcp.json
  1. ทดสอบจากไดเรกทอรีต่างๆ:
cd ~ && claude mcp list
cd /tmp && claude mcp list

การแก้ไขปัญหาขอบเขต

ปัญหา: เซิร์ฟเวอร์ทำงานได้เพียงในไดเรกทอรีเดียว

วิธีแก้ไข: ลบการกำหนดค่า local และเพิ่มใหม่ด้วยขอบเขตผู้ใช้

# Remove problematic local configuration
claude mcp remove my-server

# Re-add with global user scope
claude mcp add --scope user my-server python3 /path/to/server.py

การสร้างเซิร์ฟเวอร์ MCP ตัวแรกของคุณ

การทำความเข้าใจกระบวนการพัฒนา

การสร้างเซิร์ฟเวอร์ MCP เกี่ยวข้องกับการทำความเข้าใจทั้งโปรโตคอล MCP และข้อกำหนดเฉพาะของกรณีการใช้งานของคุณ เราจะเริ่มต้นด้วยเซิร์ฟเวอร์ "Hello World" พื้นฐานเพื่อทำความเข้าใจหลักการพื้นฐาน จากนั้นจะสร้างต่อจากรากฐานนั้น

กระบวนการพัฒนามีขั้นตอนดังนี้:

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

ขั้นตอนที่ 1: รากฐานและโครงสร้างโปรเจกต์

การสร้างสภาพแวดล้อมการพัฒนา

ขั้นแรก สร้างสภาพแวดล้อมการพัฒนาที่เหมาะสมสำหรับเซิร์ฟเวอร์ MCP ของคุณ:

# Navigate to your MCP servers directory
cd ~/.claude-mcp-servers/

# Create a new server project
mkdir my-first-server
cd my-first-server

# Initialize the project structure
touch server.py
touch requirements.txt
touch .env

ทำไมโครงสร้างนี้ถึงสำคัญ

การพัฒนาที่จัดระเบียบ: การเก็บแต่ละเซิร์ฟเวอร์ไว้ในไดเรกทอรีของตัวเองช่วยป้องกันข้อขัดแย้งและทำให้การบำรุงรักษาง่ายขึ้น

การแยก Dependency: แต่ละเซิร์ฟเวอร์สามารถมีข้อกำหนดของตัวเองได้โดยไม่ส่งผลกระทบต่อเซิร์ฟเวอร์อื่น

การจัดการการกำหนดค่า: ไฟล์สภาพแวดล้อมช่วยให้การกำหนดค่าปลอดภัยโดยไม่ต้องฮาร์ดโค้ดค่า

การทำความเข้าใจข้อกำหนดของเซิร์ฟเวอร์ MCP

เซิร์ฟเวอร์ MCP ทุกตัวต้องใช้เมธอด JSON-RPC หลักสามตัว:

  1. initialize: สร้างการเชื่อมต่อและประกาศความสามารถของเซิร์ฟเวอร์
  2. tools/list: ส่งคืนเครื่องมือที่พร้อมใช้งานและสคีมาของเครื่องมือเหล่านั้น
  3. tools/call: ดำเนินการเรียกเครื่องมือเฉพาะด้วยพารามิเตอร์ที่ให้มา

ขั้นตอนที่ 2: การนำเฟรมเวิร์กเซิร์ฟเวอร์หลักไปใช้

สร้างไฟล์ชื่อ server.py พร้อมด้วยเทมเพลตเซิร์ฟเวอร์ MCP พื้นฐาน:

#!/usr/bin/env python3
"""
Custom MCP Server for Claude Code Integration
"""

import json
import sys
import os
from typing import Dict, Any, Optional

# Ensure unbuffered output for proper MCP communication
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 1)
sys.stderr = os.fdopen(sys.stderr.fileno(), 'w', 1)

def send_response(response: Dict[str, Any]):
    """Send a JSON-RPC response to Claude Code"""
    print(json.dumps(response), flush=True)

def handle_initialize(request_id: Any) -> Dict[str, Any]:
    """Handle MCP initialization handshake"""
    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "protocolVersion": "2024-11-05",
            "capabilities": {
                "tools": {}
            },
            "serverInfo": {
                "name": "my-custom-server",
                "version": "1.0.0"
            }
        }
    }

def handle_tools_list(request_id: Any) -> Dict[str, Any]:
    """List available tools for Claude Code"""
    tools = [
        {
            "name": "hello_world",
            "description": "A simple demonstration tool",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "Name to greet"
                    }
                },
                "required": ["name"]
            }
        }
    ]

    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "tools": tools
        }
    }

def handle_tool_call(request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
    """Execute tool calls from Claude Code"""
    tool_name = params.get("name")
    arguments = params.get("arguments", {})

    try:
        if tool_name == "hello_world":
            name = arguments.get("name", "World")
            result = f"Hello, {name}! Your MCP server is working perfectly."
        else:
            raise ValueError(f"Unknown tool: {tool_name}")

        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "content": [
                    {
                        "type": "text",
                        "text": result
                    }
                ]
            }
        }
    except Exception as e:
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {
                "code": -32603,
                "message": str(e)
            }
        }

def main():
    """Main server loop handling JSON-RPC communication"""
    while True:
        try:
            line = sys.stdin.readline()
            if not line:
                break

            request = json.loads(line.strip())
            method = request.get("method")
            request_id = request.get("id")
            params = request.get("params", {})

            if method == "initialize":
                response = handle_initialize(request_id)
            elif method == "tools/list":
                response = handle_tools_list(request_id)
            elif method == "tools/call":
                response = handle_tool_call(request_id, params)
            else:
                response = {
                    "jsonrpc": "2.0",
                    "id": request_id,
                    "error": {
                        "code": -32601,
                        "message": f"Method not found: {method}"
                    }
                }

            send_response(response)

        except json.JSONDecodeError:
            continue
        except EOFError:
            break
        except Exception as e:
            if 'request_id' in locals():
                send_response({
                    "jsonrpc": "2.0",
                    "id": request_id,
                    "error": {
                        "code": -32603,
                        "message": f"Internal error: {str(e)}"
                    }
                })

if __name__ == "__main__":
    main()

คำอธิบายสถาปัตยกรรมโค้ด

การตั้งค่า Input/Output: บรรทัดแรกๆ กำหนดค่า I/O แบบ unbuffered ซึ่งมีความสำคัญต่อการสื่อสาร MCP เอาต์พุตแบบ buffered อาจทำให้ข้อความล่าช้าซึ่งทำให้โปรโตคอลเสียหายได้

การจัดการ JSON-RPC: ลูปหลักอ่านคำขอ JSON-RPC จาก stdin และเขียนการตอบกลับไปยัง stdout ซึ่งเป็นไปตามข้อกำหนด MCP สำหรับการสื่อสารเซิร์ฟเวอร์ภายใน

กลยุทธ์การจัดการข้อผิดพลาด: โค้ดใช้การจัดการข้อผิดพลาดหลายชั้น:

การปฏิบัติตามโปรโตคอล: การตอบกลับแต่ละรายการมีฟิลด์ jsonrpc: "2.0" และ ID คำขอที่จำเป็นสำหรับการเชื่อมโยงที่ถูกต้อง

ขั้นตอนที่ 3: การเตรียมและการทดสอบเซิร์ฟเวอร์

ทำให้เซิร์ฟเวอร์สามารถเรียกใช้งานได้

# Make the server executable
chmod +x server.py

ทำไมสิทธิ์ในการเรียกใช้งานถึงสำคัญ: เซิร์ฟเวอร์ MCP ถูกเปิดใช้งานเป็น subprocess โดย Claude Code หากไม่มีสิทธิ์ในการเรียกใช้งาน การเปิดใช้งานจะล้มเหลวพร้อมข้อผิดพลาดสิทธิ์ที่ไม่ชัดเจน

การทดสอบโปรโตคอลด้วยตนเอง

ก่อนลงทะเบียนกับ Claude Code ให้ทดสอบการนำโปรโตคอลไปใช้ของเซิร์ฟเวอร์:

# Test the initialize handshake
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | python3 server.py

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

ขั้นตอนการตรวจสอบ

ดำเนินการตรวจสอบเหล่านี้ก่อนดำเนินการต่อ:

  1. การตรวจสอบไวยากรณ์: python3 -m py_compile server.py
  2. การทดสอบ Import: python3 -c "import json, sys, os"
  3. การทดสอบการดำเนินการ: ตรวจสอบว่าการทดสอบโปรโตคอลด้วยตนเองทำงานได้

ขั้นตอนที่ 4: การลงทะเบียนกับ Claude Code

การเพิ่มเซิร์ฟเวอร์ของคุณ

ลงทะเบียนเซิร์ฟเวอร์ของคุณโดยใช้ขอบเขตที่เหมาะสมและพาธแบบ absolute:

# Register with global user scope for universal access
claude mcp add --scope user my-first-server python3 ~/.claude-mcp-servers/my-first-server/server.py

รายละเอียดสำคัญ:

การตรวจสอบและการแก้ไขปัญหา

# Verify registration
claude mcp list

# Check for any connection issues
claude mcp get my-first-server

ปัญหาการลงทะเบียนที่พบบ่อย:

ตัวอย่างขั้นสูง: การรวม Weather API

ก้าวข้าม Hello World

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

การวางแผนการรวม API ของคุณ

ก่อนเขียนโค้ด ให้พิจารณาแง่มุมการรวมเหล่านี้:

การเลือก API: เราจะใช้ OpenWeatherMap API เนื่องจากความเรียบง่ายและ tier ฟรี

ขั้นตอนข้อมูล: คำขอของผู้ใช้ → การตรวจสอบพารามิเตอร์ → การเรียก API → การจัดรูปแบบการตอบกลับ → การตอบกลับของ Claude

สถานการณ์ข้อผิดพลาด: ความล้มเหลวของเครือข่าย, คีย์ API ไม่ถูกต้อง, การตอบกลับที่ผิดรูปแบบ, การจำกัดอัตรา

ความปลอดภัย: คีย์ API จัดเก็บในตัวแปรสภาพแวดล้อม, การทำความสะอาดอินพุต

กลยุทธ์การนำไปใช้

มาสร้างเซิร์ฟเวอร์นี้ทีละขั้นตอน โดยนำแต่ละส่วนไปใช้พร้อมการจัดการข้อผิดพลาดอย่างเต็มที่:

#!/usr/bin/env python3
import json
import sys
import os
import requests
from typing import Dict, Any

# Configuration - use environment variables for security
WEATHER_API_KEY = os.environ.get("OPENWEATHER_API_KEY", "your-api-key-here")

def get_weather(city: str) -> str:
    """Fetch current weather data for a specified city"""
    try:
        url = "<http://api.openweathermap.org/data/2.5/weather>"
        params = {
            "q": city,
            "appid": WEATHER_API_KEY,
            "units": "metric"
        }
        response = requests.get(url, params=params, timeout=10)
        data = response.json()

        if response.status_code == 200:
            temp = data["main"]["temp"]
            desc = data["weather"][0]["description"]
            humidity = data["main"]["humidity"]
            return f"Weather in {city}: {temp}°C, {desc.title()}, Humidity: {humidity}%"
        else:
            return f"Error fetching weather: {data.get('message', 'Unknown error')}"
    except requests.RequestException as e:
        return f"Network error: {str(e)}"
    except Exception as e:
        return f"Error processing weather data: {str(e)}"

def handle_tools_list(request_id: Any) -> Dict[str, Any]:
    """Enhanced tools list with weather functionality"""
    tools = [
        {
            "name": "get_weather",
            "description": "Get current weather conditions for any city worldwide",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name (e.g., 'London', 'Tokyo', 'New York')"
                    }
                },
                "required": ["city"]
            }
        }
    ]

    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "tools": tools
        }
    }

def handle_tool_call(request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
    """Enhanced tool execution with weather functionality"""
    tool_name = params.get("name")
    arguments = params.get("arguments", {})

    try:
        if tool_name == "get_weather":
            city = arguments.get("city")
            if not city:
                raise ValueError("City name is required")
            result = get_weather(city)
        else:
            raise ValueError(f"Unknown tool: {tool_name}")

        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "content": [
                    {
                        "type": "text",
                        "text": result
                    }
                ]
            }
        }
    except Exception as e:
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {
                "code": -32603,
                "message": str(e)
            }
        }

# Include the same main() function and other handlers from the basic example

คุณสมบัติขั้นสูงที่อธิบาย

ความปลอดภัยของตัวแปรสภาพแวดล้อม: คีย์ API ถูกโหลดจากตัวแปรสภาพแวดล้อม ไม่เคยฮาร์ดโค้ด ซึ่งป้องกันการเปิดเผยโดยไม่ตั้งใจในการควบคุมเวอร์ชัน

การจัดการข้อผิดพลาดที่แข็งแกร่ง: ฟังก์ชัน get_weather() จัดการสถานการณ์ข้อผิดพลาดหลายอย่าง:

สคีมาเครื่องมือที่ได้รับการปรับปรุง: สคีมาเครื่องมือสภาพอากาศมีคำอธิบายและตัวอย่างโดยละเอียด ช่วยให้ Claude Code เข้าใจวิธีใช้เครื่องมือได้อย่างมีประสิทธิภาพ

ขั้นตอนที่ 5: การจัดการ Dependency และ Configuration อย่างมืออาชีพ

การสร้างไฟล์ Requirements ที่เหมาะสม

requests>=2.28.0
python-dotenv>=1.0.0

กลยุทธ์การตรึงเวอร์ชัน: การใช้ข้อกำหนดเวอร์ชันขั้นต่ำ (>=) ช่วยให้มั่นใจในความเข้ากันได้ในขณะที่อนุญาตให้อัปเดตความปลอดภัยได้ สำหรับเซิร์ฟเวอร์การผลิต ให้พิจารณาการตรึงเวอร์ชันที่แน่นอน

การกำหนดค่าสภาพแวดล้อมที่ปลอดภัย

สร้างไฟล์ .env สำหรับการจัดการการกำหนดค่า:

# Weather API configuration
OPENWEATHER_API_KEY=your_actual_api_key_here

# Server configuration
MCP_LOG_LEVEL=INFO
MCP_DEBUG=false

# Optional: Rate limiting
MCP_MAX_REQUESTS_PER_MINUTE=60

แนวทางปฏิบัติที่ดีที่สุดด้านความปลอดภัย:

การติดตั้งและการแยก Dependency

# Create virtual environment for isolation
python3 -m venv mcp-env
source mcp-env/bin/activate  # On Windows: mcp-env\\\\Scripts\\\\activate

# Install dependencies
pip install -r requirements.txt

# Verify installation
python3 -c "import requests; print('Dependencies installed successfully')"

ทำไม virtual environments ถึงสำคัญ: การแยกช่วยป้องกันข้อขัดแย้งของ dependency ระหว่างเซิร์ฟเวอร์ MCP ที่แตกต่างกันและการติดตั้ง Python ของระบบของคุณ

การทดสอบและแก้ไขข้อบกพร่องเซิร์ฟเวอร์ MCP ของคุณ

กลยุทธ์การทดสอบที่ครอบคลุม

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

Testing Pyramid สำหรับเซิร์ฟเวอร์ MCP

  1. Unit Tests: การทดสอบฟังก์ชันแต่ละรายการ
  2. Protocol Tests: การตรวจสอบการปฏิบัติตาม JSON-RPC
  3. Integration Tests: การทดสอบการโต้ตอบกับ Claude Code
  4. End-to-End Tests: การตรวจสอบขั้นตอนการทำงานทั้งหมด

เลเยอร์ 1: การทดสอบโปรโตคอลด้วยตนเอง

การทดสอบเมธอด MCP หลัก

ก่อนการรวมใดๆ ให้ตรวจสอบว่าเซิร์ฟเวอร์ของคุณใช้โปรโตคอล MCP อย่างถูกต้อง:

# Test initialization handshake
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | python3 server.py

โครงสร้างการตอบกลับที่คาดหวัง:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "2024-11-05",
    "capabilities": {"tools": {}},
    "serverInfo": {"name": "your-server", "version": "1.0.0"}
  }
}

การทดสอบการค้นหาเครื่องมือ

# Test tools list endpoint
echo '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' | python3 server.py

รายการตรวจสอบการตรวจสอบ:

การทดสอบการดำเนินการเครื่องมือ

# Test actual tool functionality
echo '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_weather","arguments":{"city":"London"}}}' | python3 server.py

สิ่งที่ต้องตรวจสอบ:

เลเยอร์ 2: เฟรมเวิร์กการทดสอบอัตโนมัติ

การสร้างสคริปต์ทดสอบ

สร้างไฟล์ test_server.py สำหรับการทดสอบอัตโนมัติ:

#!/usr/bin/env python3
import json
import subprocess
import sys

def test_mcp_method(method, params=None):
    """Test a specific MCP method"""
    request = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": method,
        "params": params or {}
    }

    try:
        result = subprocess.run(
            [sys.executable, "server.py"],
            input=json.dumps(request),
            capture_output=True,
            text=True,
            timeout=10
        )
        return json.loads(result.stdout.strip())
    except Exception as e:
        return {"error": str(e)}

# Test suite
tests = [
    ("initialize", None),
    ("tools/list", None),
    ("tools/call", {"name": "hello_world", "arguments": {"name": "Test"}})
]

for method, params in tests:
    response = test_mcp_method(method, params)
    print(f"Testing {method}: {'✓ PASS' if 'result' in response else '✗ FAIL'}")

เลเยอร์ 3: การทดสอบการรวมกับ Claude Code

การลงทะเบียนและการตรวจสอบเซิร์ฟเวอร์

# Register your server
claude mcp add --scope user test-server python3 /full/path/to/server.py

# Verify registration
claude mcp list | grep test-server

# Check server health
claude mcp get test-server

การทดสอบการรวมแบบสด

# Start Claude Code in test mode
claude

# In Claude Code, test tool discovery
/mcp

# Test tool execution
mcp__test-server__hello_world name:"Integration Test"

รูปแบบการตั้งชื่อเครื่องมือ: Claude Code เพิ่มคำนำหน้าเครื่องมือด้วย mcp__<server-name>__<tool-name> เพื่อหลีกเลี่ยงข้อขัดแย้งในการตั้งชื่อ

เทคนิคการแก้ไขข้อบกพร่องขั้นสูง

การเปิดใช้งาน Debug Logging

เพิ่มการบันทึกที่ครอบคลุมลงในเซิร์ฟเวอร์ของคุณ:

import logging
import sys

# Configure logging to stderr (won't interfere with JSON-RPC)
logging.basicConfig(
    level=logging.DEBUG,
    stream=sys.stderr,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

logger = logging.getLogger(__name__)

def handle_tool_call(request_id, params):
    logger.debug(f"Received tool call: {params}")
    # ... your tool logic
    logger.debug(f"Tool execution completed successfully")

การวิเคราะห์บันทึกเซิร์ฟเวอร์ MCP

Claude Code เก็บรักษาบันทึกสำหรับเซิร์ฟเวอร์ MCP แต่ละตัว:

# View recent logs (macOS)
tail -f ~/Library/Logs/Claude/mcp-server-*.log

# View recent logs (Linux)
tail -f ~/.config/claude/logs/mcp-server-*.log

# Search for errors
grep -i error ~/Library/Logs/Claude/mcp-server-*.log

รูปแบบการแก้ไขข้อบกพร่องที่พบบ่อย

ปัญหา: เซิร์ฟเวอร์เริ่มทำงาน แต่เครื่องมือไม่ปรากฏ

การวินิจฉัย: ตรวจสอบรูปแบบการตอบกลับ tools/list

วิธีแก้ไข: ตรวจสอบการปฏิบัติตาม JSON schema

ปัญหา: การเรียกเครื่องมือล้มเหลวอย่างเงียบๆ

การวินิจฉัย: ตรวจสอบการจัดการข้อผิดพลาดใน tools/call

วิธีแก้ไข: เพิ่มการจัดการข้อยกเว้นที่ครอบคลุม

ปัญหา: การเชื่อมต่อเซิร์ฟเวอร์หลุด

การวินิจฉัย: ตรวจสอบ I/O แบบ unbuffered และการจัดการข้อยกเว้นที่เหมาะสม

วิธีแก้ไข: ตรวจสอบการกำหนดค่า sys.stdout และการจัดการข้อผิดพลาดในลูปหลัก

การทดสอบประสิทธิภาพและความน่าเชื่อถือ

การทดสอบโหลดเซิร์ฟเวอร์ของคุณ

# Test multiple rapid requests
for i in {1..10}; do
  echo '{"jsonrpc":"2.0","id":'$i',"method":"tools/list","params":{}}' | python3 server.py &
done
wait

การตรวจสอบหน่วยความจำและทรัพยากร

# Monitor server resource usage
python3 -m memory_profiler server.py

# Check for memory leaks during extended operation
python3 -m tracemalloc server.py

การแก้ไขปัญหาทั่วไป

ปัญหาในระดับโปรโตคอล

  1. การตอบกลับ JSON ไม่ถูกต้อง: ใช้ json.loads() เพื่อตรวจสอบเอาต์พุต
  2. ฟิลด์ที่จำเป็นหายไป: ตรวจสอบการปฏิบัติตามข้อกำหนด MCP
  3. รหัสข้อผิดพลาดไม่ถูกต้อง: ใช้รหัสข้อผิดพลาด JSON-RPC มาตรฐาน

ปัญหาการรวม

  1. เซิร์ฟเวอร์ไม่ปรากฏ: ตรวจสอบสิทธิ์ไฟล์และพาธ Python
  2. เครื่องมือไม่สามารถเข้าถึงได้: ตรวจสอบการกำหนดค่าขอบเขตและการลงทะเบียน
  3. ความล้มเหลวในการตรวจสอบสิทธิ์: ตรวจสอบให้แน่ใจว่ามีการเริ่มต้น MCP อย่างถูกต้อง

แนวทางปฏิบัติที่ดีที่สุดและข้อควรพิจารณาด้านความปลอดภัย

การจัดการข้อผิดพลาดที่พร้อมสำหรับการผลิต

การนำการตรวจสอบที่แข็งแกร่งไปใช้

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

def validate_arguments(arguments: Dict[str, Any], required: List[str]):
    """Validate required arguments are present"""
    missing = [field for field in required if field not in arguments]
    if missing:
        raise ValueError(f"Missing required fields: {', '.join(missing)}")

def handle_tool_call(request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
    """Tool execution with proper validation"""
    try:
        tool_name = params.get("name")
        arguments = params.get("arguments", {})

        # Validate before processing
        if tool_name == "get_weather":
            validate_arguments(arguments, ["city"])

        # Process tool logic here

    except ValueError as ve:
        return create_error_response(request_id, -32602, str(ve))
    except Exception as e:
        return create_error_response(request_id, -32603, f"Internal error: {str(e)}")

มาตรฐานการตอบกลับข้อผิดพลาด

ปฏิบัติตามข้อตกลงรหัสข้อผิดพลาด JSON-RPC 2.0:

กรอบงานความปลอดภัยที่ครอบคลุม

1. การจัดการความลับ

ห้ามฮาร์ดโค้ดข้อมูลที่ละเอียดอ่อน ใช้แนวทางการกำหนดค่าแบบหลายชั้น:

import os
from pathlib import Path

def load_config():
    """Load configuration with fallback hierarchy"""
    # 1. Environment variables (highest priority)
    api_key = os.environ.get("API_KEY")

    # 2. Local .env file
    if not api_key:
        env_path = Path(".env")
        if env_path.exists():
            # Load from .env file
            pass

    # 3. System keyring (production)
    if not api_key:
        try:
            import keyring
            api_key = keyring.get_password("mcp-server", "api_key")
        except ImportError:
            pass

    if not api_key:
        raise ValueError("API key not found in any configuration source")

    return {"api_key": api_key}

2. การทำความสะอาดและการตรวจสอบอินพุต

ใช้การตรวจสอบอินพุตอย่างเข้มงวดเพื่อป้องกันการโจมตีแบบ injection:

import re
from typing import Any, Dict

def sanitize_string_input(value: str, max_length: int = 100) -> str:
    """Sanitize string inputs"""
    if not isinstance(value, str):
        raise ValueError("Expected string input")

    # Remove potentially dangerous characters
    sanitized = re.sub(r'[<>"\\\\']', '', value)

    # Limit length to prevent DoS
    if len(sanitized) > max_length:
        raise ValueError(f"Input too long (max {max_length} characters)")

    return sanitized.strip()

def validate_city_name(city: str) -> str:
    """Validate city name input"""
    sanitized = sanitize_string_input(city, 50)

    # Allow only letters, spaces, and common punctuation
    if not re.match(r'^[a-zA-Z\\\\s\\\\-\\\\.]+$', sanitized):
        raise ValueError("Invalid city name format")

    return sanitized

3. การจำกัดอัตราและการป้องกันทรัพยากร

ใช้การจำกัดอัตราเพื่อป้องกันการใช้ในทางที่ผิด:

import time
from collections import defaultdict
from threading import Lock

class RateLimiter:
    def __init__(self, max_requests: int = 60, window_seconds: int = 60):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.requests = defaultdict(list)
        self.lock = Lock()

    def allow_request(self, client_id: str = "default") -> bool:
        """Check if request is allowed under rate limit"""
        now = time.time()

        with self.lock:
            # Clean old requests
            self.requests[client_id] = [
                req_time for req_time in self.requests[client_id]
                if now - req_time < self.window_seconds
            ]

            # Check limit
            if len(self.requests[client_id]) >= self.max_requests:
                return False

            # Record this request
            self.requests[client_id].append(now)
            return True

# Global rate limiter instance
rate_limiter = RateLimiter()

การบันทึกและตรวจสอบขั้นสูง

การนำ Structured Logging ไปใช้

ใช้ structured logging เพื่อการแก้ไขข้อบกพร่องและการตรวจสอบที่ดีขึ้น:

import logging
import json
import sys
from datetime import datetime

class MCPFormatter(logging.Formatter):
    """Custom formatter for MCP server logs"""

    def format(self, record):
        log_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "level": record.levelname,
            "message": record.getMessage(),
            "module": record.module,
            "function": record.funcName,
        }

        # Add extra context if available
        if hasattr(record, 'tool_name'):
            log_entry["tool_name"] = record.tool_name
        if hasattr(record, 'request_id'):
            log_entry["request_id"] = record.request_id

        return json.dumps(log_entry)

# Configure structured logging
logger = logging.getLogger(__name__)
handler = logging.StreamHandler(sys.stderr)
handler.setFormatter(MCPFormatter())
logger.addHandler(handler)
logger.setLevel(logging.INFO)

การตรวจสอบประสิทธิภาพ

ติดตามเมตริกประสิทธิภาพของเซิร์ฟเวอร์:

import time
import statistics
from collections import deque

class PerformanceMonitor:
    def __init__(self, max_samples: int = 1000):
        self.response_times = deque(maxlen=max_samples)
        self.error_count = 0
        self.request_count = 0

    def record_request(self, duration: float, success: bool):
        """Record request metrics"""
        self.request_count += 1
        self.response_times.append(duration)

        if not success:
            self.error_count += 1

    def get_stats(self) -> Dict[str, Any]:
        """Get current performance statistics"""
        if not self.response_times:
            return {"no_data": True}

        return {
            "total_requests": self.request_count,
            "error_rate": self.error_count / self.request_count,
            "avg_response_time": statistics.mean(self.response_times),
            "p95_response_time": statistics.quantiles(self.response_times, n=20)[18],
            "p99_response_time": statistics.quantiles(self.response_times, n=100)[98]
        }

# Global performance monitor
perf_monitor = PerformanceMonitor()

กลยุทธ์การ Deployment และการบำรุงรักษา

การจัดการเวอร์ชัน

ใช้การกำหนดเวอร์ชันที่เหมาะสมสำหรับเซิร์ฟเวอร์ MCP ของคุณ:

__version__ = "1.2.3"
__mcp_version__ = "2024-11-05"

def get_server_info():
    """Return server information for MCP initialize"""
    return {
        "name": "my-production-server",
        "version": __version__,
        "mcp_protocol_version": __mcp_version__,
        "capabilities": ["tools", "resources"],  # Declare what you support
    }

การนำ Health Check ไปใช้

เพิ่มความสามารถในการตรวจสอบสุขภาพสำหรับการตรวจสอบ:

def handle_health_check(request_id: Any) -> Dict[str, Any]:
    """Health check endpoint for monitoring"""
    try:
        # Test core functionality
        test_db_connection()  # Example health check
        test_external_apis()  # Example health check

        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "status": "healthy",
                "timestamp": datetime.utcnow().isoformat(),
                "version": __version__,
                "uptime_seconds": time.time() - start_time,
                "performance": perf_monitor.get_stats()
            }
        }
    except Exception as e:
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "status": "unhealthy",
                "error": str(e),
                "timestamp": datetime.utcnow().isoformat()
            }
        }

การจัดการ Graceful Shutdown

ใช้การทำความสะอาดที่เหมาะสมเมื่อเซิร์ฟเวอร์ปิด:

import signal
import sys

class MCPServer:
    def __init__(self):
        self.running = True
        self.active_requests = set()

        # Register signal handlers
        signal.signal(signal.SIGINT, self.shutdown_handler)
        signal.signal(signal.SIGTERM, self.shutdown_handler)

    def shutdown_handler(self, signum, frame):
        """Handle graceful shutdown"""
        logger.info(f"Received signal {signum}, initiating graceful shutdown")
        self.running = False

        # Wait for active requests to complete
        timeout = 30  # seconds
        start_time = time.time()

        while self.active_requests and (time.time() - start_time) < timeout:
            time.sleep(0.1)

        logger.info("Shutdown complete")
        sys.exit(0)

กรณีการใช้งานจริงและแอปพลิเคชันขั้นสูง

รูปแบบการรวมระดับองค์กร

เซิร์ฟเวอร์ MCP มีความเป็นเลิศในสภาพแวดล้อมระดับองค์กรที่ Claude Code จำเป็นต้องรวมเข้ากับระบบธุรกิจที่มีอยู่ นี่คือรูปแบบการรวมที่ได้รับการพิสูจน์แล้ว:

เซิร์ฟเวอร์รวมฐานข้อมูล

การทำงานอัตโนมัติในขั้นตอนการพัฒนา

การตรวจสอบและการดำเนินงานระบบ

รูปแบบสถาปัตยกรรมขั้นสูง

การจัดการหลายเซิร์ฟเวอร์

สำหรับขั้นตอนการทำงานที่ซับซ้อน ให้ออกแบบเซิร์ฟเวอร์ MCP ที่ประสานงานซึ่งกันและกัน:

# Server coordination pattern
def coordinate_workflow(workflow_id: str, steps: List[Dict]) -> Dict:
    """Coordinate multi-step workflow across servers"""
    results = {}

    for step in steps:
        server_name = step["server"]
        tool_name = step["tool"]
        params = step["params"]

        # Call other MCP server through Claude Code
        result = call_mcp_tool(server_name, tool_name, params)
        results[step["id"]] = result

        # Handle dependencies between steps
        if step.get("depends_on"):
            inject_dependencies(params, results, step["depends_on"])

    return {"workflow_id": workflow_id, "results": results}

การทำ Caching และการเพิ่มประสิทธิภาพ

ใช้ caching อัจฉริยะสำหรับข้อมูลที่ถูกร้องขอบ่อย:

import hashlib
import pickle
from datetime import datetime, timedelta

class IntelligentCache:
    def __init__(self, default_ttl: int = 3600):
        self.cache = {}
        self.default_ttl = default_ttl

    def get_cache_key(self, tool_name: str, params: Dict) -> str:
        """Generate consistent cache key"""
        key_data = f"{tool_name}:{json.dumps(params, sort_keys=True)}"
        return hashlib.md5(key_data.encode()).hexdigest()

    def get(self, tool_name: str, params: Dict) -> Optional[Any]:
        """Get cached result if valid"""
        key = self.get_cache_key(tool_name, params)

        if key in self.cache:
            data, expiry = self.cache[key]
            if datetime.now() < expiry:
                return data
            else:
                del self.cache[key]

        return None

    def set(self, tool_name: str, params: Dict, result: Any, ttl: Optional[int] = None):
        """Cache result with TTL"""
        key = self.get_cache_key(tool_name, params)
        expiry = datetime.now() + timedelta(seconds=ttl or self.default_ttl)
        self.cache[key] = (result, expiry)

กลยุทธ์การ Deployment สำหรับการผลิต

การ Deployment แบบ Containerized

บรรจุเซิร์ฟเวอร์ MCP ของคุณเป็น Docker container เพื่อการ Deployment ที่สอดคล้องกัน:

FROM python:3.11-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \\\\
    curl \\\\
    && rm -rf /var/lib/apt/lists/*

# Copy and install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY server.py .
COPY config/ ./config/

# Create non-root user
RUN useradd -m -s /bin/bash mcpuser
USER mcpuser

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \\\\
    CMD python3 -c "import requests; requests.get('<http://localhost:8080/health>')"

CMD ["python3", "server.py"]

การ Deployment บน Kubernetes

Deployment เซิร์ฟเวอร์ MCP ใน Kubernetes เพื่อความสามารถในการขยายและความน่าเชื่อถือ:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-weather-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mcp-weather-server
  template:
    metadata:
      labels:
        app: mcp-weather-server
    spec:
      containers:
      - name: mcp-server
        image: your-registry/mcp-weather-server:latest
        ports:
        - containerPort: 8080
        env:
        - name: OPENWEATHER_API_KEY
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: openweather-api-key
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10

ข้อควรพิจารณาด้านการขยายและประสิทธิภาพ

รูปแบบการขยายแบบ Horizontal

ออกแบบเซิร์ฟเวอร์ MCP ของคุณให้รองรับการขยายแบบ horizontal:

  1. การออกแบบแบบ Stateless: ทำให้เซิร์ฟเวอร์เป็น stateless เพื่อให้สามารถทำซ้ำได้ง่าย
  2. Load Balancing: กระจายคำขอไปยังอินสแตนซ์เซิร์ฟเวอร์หลายตัว
  3. Database Pooling: ใช้ connection pooling สำหรับเซิร์ฟเวอร์ที่ใช้ฐานข้อมูล
  4. Caching Strategies: ใช้ Redis หรือ Memcached สำหรับ caching ที่ใช้ร่วมกัน

เทคนิคการเพิ่มประสิทธิภาพ

import asyncio
import aiohttp
from concurrent.futures import ThreadPoolExecutor

class HighPerformanceMCPServer:
    def __init__(self):
        self.executor = ThreadPoolPoolExecutor(max_workers=10)
        self.session = None

    async def async_tool_call(self, tool_name: str, params: Dict) -> Dict:
        """Handle tool calls asynchronously"""
        if not self.session:
            self.session = aiohttp.ClientSession()

        # Use async operations for I/O bound tasks
        if tool_name == "web_search":
            return await self.async_web_search(params)
        elif tool_name == "database_query":
            return await self.async_database_query(params)
        else:
            # Use thread pool for CPU-bound tasks
            loop = asyncio.get_event_loop()
            return await loop.run_in_executor(
                self.executor,
                self.sync_tool_call,
                tool_name,
                params
            )

บทสรุปและขั้นตอนถัดไป

เชี่ยวชาญการพัฒนา MCP

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

ตลอดคู่มือฉบับสมบูรณ์นี้ คุณได้เรียนรู้เกี่ยวกับ:

ทักษะพื้นฐาน:

ความพร้อมสำหรับการผลิต:

ความสามารถขั้นสูง:

แนวทางการพัฒนาเชิงกลยุทธ์

ระยะที่ 1: การสร้างรากฐาน (สัปดาห์ที่ 1-2)

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

ระยะที่ 2: การขยายการรวม (สัปดาห์ที่ 3-4)

สร้างเซิร์ฟเวอร์ที่ซับซ้อนมากขึ้นซึ่งรวมเข้ากับระบบที่มีอยู่:

ระยะที่ 3: การ Deployment ระดับองค์กร (เดือนที่ 2+)

Deployment เซิร์ฟเวอร์ที่พร้อมสำหรับการผลิตพร้อมการสนับสนุนการดำเนินงานเต็มรูปแบบ:

กลยุทธ์ความสำเร็จระยะยาว

การมีส่วนร่วมกับชุมชน

การปรับปรุงอย่างต่อเนื่อง

โอกาสในการสร้างนวัตกรรม

อนาคตของการพัฒนา MCP

Model Context Protocol เป็นรากฐานสำหรับระบบนิเวศใหม่ของแอปพลิเคชันที่รวม AI เข้าด้วยกัน ในขณะที่คุณสร้างเซิร์ฟเวอร์ MCP คุณไม่ได้เพียงแค่สร้างเครื่องมือสำหรับ Claude Code เท่านั้น แต่คุณกำลังสร้างส่วนประกอบที่นำมาใช้ซ้ำได้ ซึ่งจะทำงานได้ในระบบนิเวศที่ขยายตัวของผู้ช่วย AI ที่เข้ากันได้กับ MCP

การลงทุนของคุณในการพัฒนา MCP ให้ผลตอบแทนผ่าน:

การแจ้งเตือนความสำเร็จที่สำคัญ

เมื่อคุณเริ่มต้นการเดินทางในการพัฒนา MCP โปรดจำหลักการสำคัญเหล่านี้:

  1. ความเชี่ยวชาญในการกำหนดค่าขอบเขต: ใช้ -scope user เสมอสำหรับเซิร์ฟเวอร์พัฒนา เว้นแต่คุณต้องการข้อจำกัดระดับโปรเจกต์โดยเฉพาะ
  2. ความปลอดภัยต้องมาก่อน: ห้ามฮาร์ดโค้ดความลับ ตรวจสอบอินพุตเสมอ ใช้การจำกัดอัตรา
  3. ความสมบูรณ์ของการจัดการข้อผิดพลาด: คาดการณ์และจัดการโหมดความล้มเหลวทั้งหมดอย่างสง่างาม
  4. ความละเอียดในการทดสอบ: ทดสอบการปฏิบัติตามโปรโตคอล ฟังก์ชันการทำงาน และการรวม
  5. คุณภาพของเอกสารประกอบ: จัดทำเอกสารเซิร์ฟเวอร์ของคุณสำหรับการทำงานร่วมกันของทีมและการบำรุงรักษา

การรับความช่วยเหลือและแหล่งข้อมูล

เมื่อคุณพบความท้าทาย:

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

จำไว้ว่า: การรวมที่ซับซ้อนทุกอย่างเริ่มต้นด้วยเซิร์ฟเวอร์ "Hello World" ที่เรียบง่าย เริ่มต้นจากพื้นฐาน เชี่ยวชาญหลักการพื้นฐาน และค่อยๆ สร้างเครื่องมือที่รวม AI เข้าด้วยกันซึ่งจะเปลี่ยนวิธีการทำงานของคุณ

💡
ต้องการเครื่องมือทดสอบ API ที่ยอดเยี่ยมซึ่งสร้าง เอกสารประกอบ API ที่สวยงาม หรือไม่?

ต้องการแพลตฟอร์มแบบ All-in-One ที่รวมเข้าด้วยกันสำหรับทีมพัฒนาของคุณเพื่อทำงานร่วมกันด้วย ประสิทธิภาพสูงสุด หรือไม่?

Apidog มอบทุกความต้องการของคุณ และ มาแทนที่ Postman ในราคาที่เข้าถึงได้มากกว่ามาก!
ปุ่ม

ฝึกการออกแบบ API แบบ Design-first ใน Apidog

ค้นพบวิธีที่ง่ายขึ้นในการสร้างและใช้ API

ลงทะเบียนฟรีดาวน์โหลด