วิธีการใช้งาน MCP กับ API ของ OpenAI โดยใช้ Dolphin-MCP

บทนำ

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

ภาพรวมทางเทคนิค

Dolphin-MCP ทำหน้าที่เป็นชั้นการแปลระหว่างข้อกำหนด MCP และ API LLM ต่างๆ สำหรับการบูรณาการกับ OpenAI มัน:

• แปลงข้อความโพรโทคอล MCP เป็นรูปแบบ API ของ OpenAI
• จัดการความแตกต่างในการแม็พโทเคนระหว่างโมเดล
• จัดการสถานะและประวัติของการสนทนา
• ให้ความสามารถในการดำเนินการเครื่องมือในลักษณะที่ไม่ขึ้นกับโมเดล

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

ก่อนเริ่มต้น โปรดตรวจสอบว่าคุณมี:

• Python 3.8+
• pip (ตัวจัดการแพ็คเกจ)
• คีย์ API ของ OpenAI
• ติดตั้ง Git
• ความเข้าใจพื้นฐานเกี่ยวกับ LLM และแนวคิด API

ขั้นตอนการติดตั้ง

# โคลนที่จัดเก็บ Dolphin-MCP
git clone https://github.com/cognitivecomputations/dolphin-mcp.git
cd dolphin-mcp

# สร้างสภาพแวดล้อมเสมือน
python -m venv venv
source venv/bin/activate  # บน Windows: venv\Scripts\activate

# ติดตั้ง dependencies
pip install -r requirements.txt

# ติดตั้งแพ็คเกจในโหมดพัฒนา
pip install -e .

การตั้งค่า

1. การตั้งค่าตัวแปรสภาพแวดล้อม

สร้างไฟล์ .env ในรากโปรเจกต์ของคุณ:

OPENAI_API_KEY=sk-your-openai-api-key-here
MCP_MODEL=gpt-4-0125-preview
MCP_PROVIDER=openai

2. การสร้างไฟล์การตั้งค่า

สร้างไฟล์ config.json:

{
  "provider": "openai",
  "model_settings": {
    "model": "gpt-4-0125-preview",
    "temperature": 0.7,
    "max_tokens": 2048
  },
  "api_config": {
    "api_key": "sk-your-openai-api-key-here",
    "base_url": "https://api.openai.com/v1",
    "timeout": 120
  }
}

ตัวอย่างการใช้งานพื้นฐาน

ตัวอย่างที่ 1: การสนทนาเรียบง่าย

from dolphin_mcp import DolphinMCP

# เริ่มต้นไคลเอนต์
mcp_client = DolphinMCP.from_config("./config.json")

# สร้างการสนทนา
conversation = mcp_client.create_conversation()

# เพิ่มข้อความระบบ
conversation.add_system_message("คุณเป็นผู้ช่วย AI ที่มีประโยชน์เฉพาะด้านการเขียนโปรแกรม Python.")

# ส่งข้อความผู้ใช้และรับการตอบกลับ
response = conversation.add_user_message("ฉันจะนำเสนอต้นไม้ค้นหาแบบไบนารีใน Python ได้อย่างไร?")

# พิมพ์การตอบกลับ
print(response.content)

ตัวอย่างที่ 2: การใช้เครื่องมือร่วมกับ OpenAI

from dolphin_mcp import DolphinMCP
from dolphin_mcp.tools import WebSearchTool, CodeExecutionTool

# เริ่มต้นไคลเอนต์พร้อมเครื่องมือ
mcp_client = DolphinMCP.from_config("./config.json")

# ลงทะเบียนเครื่องมือ
mcp_client.register_tool(WebSearchTool(api_key="your-search-api-key"))
mcp_client.register_tool(CodeExecutionTool())

# สร้างการสนทนาพร้อมเปิดใช้งานเครื่องมือ
conversation = mcp_client.create_conversation()

# เพิ่มคำสั่งระบบสำหรับเครื่องมือ
conversation.add_system_message("""
คุณเป็นผู้ช่วย AI ที่มีการเข้าถึงเครื่องมือดังต่อไปนี้:
- web_search: ค้นหาข้อมูลปัจจุบันจากอินเทอร์เน็ต
- code_execution: รันโค้ด Python อย่างปลอดภัยใน sandbox

ใช้เครื่องมือเหล่านี้เมื่อจำเป็นเพื่อให้การตอบกลับที่ถูกต้องและมีประโยชน์
""")

# คำถามจากผู้ใช้ที่ต้องการเครื่องมือ
response = conversation.add_user_message(
    "สภาพอากาศปัจจุบันในนิวยอร์กเป็นอย่างไร? นอกจากนี้คุณยังสามารถแสดงวิธีการคำนวณแฟกทอเรียลของตัวเลขใน Python ได้ไหม?"
)

# การตอบกลับจะรวมถึงการใช้เครื่องมือโดยอัตโนมัติ
print(response.content)
print("\nการดำเนินการเครื่องมือ:")
for tool_name, tool_result in response.tool_results.items():
    print(f"{tool_name}: {tool_result}")

การตั้งค่าขั้นสูง

การใช้จุดสิ้นสุดที่เข้ากันได้กับ OpenAI

หากคุณต้องการใช้จุดสิ้นสุดที่เข้ากันได้กับ OpenAI (เช่น Azure OpenAI หรือโมเดลที่โฮสต์ด้วยตัวเอง) ให้แก้ไขการตั้งค่าของคุณ:

{
  "provider": "openai",
  "model_settings": {
    "model": "การปรับใช้โมเดลที่กำหนดเองของคุณ",
    "temperature": 0.7,
    "max_tokens": 2048
  },
  "api_config": {
    "api_key": "your-api-key",
    "base_url": "https://your-custom-endpoint.com/v1",
    "api_version": "2023-07-01-preview",  // สำหรับ Azure
    "api_type": "azure"  // สำหรับ Azure
  }
}

การใช้งานเครื่องมือที่กำหนดเอง

Dolphin-MCP อนุญาตให้คุณสร้างเครื่องมือที่กำหนดเองสำหรับโมเดล OpenAI นี่คือวิธีการ implement เครื่องมือเครื่องคิดเลขที่กำหนดเอง:

from dolphin_mcp.tools import BaseTool
import math

class CalculatorTool(BaseTool):
    name = "calculator"
    description = "ทำการคำนวณทางคณิตศาสตร์"
    
    async def execute(self, expression: str):
        try:
            # สร้างสภาพแวดล้อมที่ปลอดภัยด้วยฟังก์ชันทางคณิตศาสตร์ที่จำกัด
            safe_env = {
                "sqrt": math.sqrt,
                "sin": math.sin,
                "cos": math.cos,
                "tan": math.tan,
                "pi": math.pi,
                "e": math.e
            }
            
            # ประเมินผลแสดงที่ไปในสภาพแวดล้อมที่ปลอดภัย
            result = eval(expression, {"__builtins__": {}}, safe_env)
            return str(result)
        except Exception as e:
            return f"เกิดข้อผิดพลาดในการคำนวณ: {str(e)}"
    
    @property
    def parameters(self):
        return {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "นิพจน์ทางคณิตศาสตร์ที่ต้องประเมิน"
                }
            },
            "required": ["expression"]
        }

# ตัวอย่างการใช้งาน
mcp_client = DolphinMCP.from_config("./config.json")
mcp_client.register_tool(CalculatorTool())

การจัดการการตอบกลับแบบสตรีม

สำหรับแอปพลิเคชันที่ต้องการการตอบกลับแบบเรียลไทม์:

async def stream_response():
    mcp_client = DolphinMCP.from_config("./config.json")
    conversation = mcp_client.create_conversation()
    
    # ตั้งค่าการสนทนา
    conversation.add_system_message("คุณเป็นผู้ช่วย AI ที่มีประโยชน์.")
    
    # สตรีมการตอบกลับ
    async for chunk in conversation.add_user_message_streaming(
        "อธิบายการคอมพิวเตอร์ควอนตัมในภาษาง่าย."
    ):
        if chunk.type == "content":
            print(chunk.content, end="", flush=True)
        elif chunk.type == "tool_start":
            print(f"\n[เริ่มต้นการใช้เครื่องมือ: {chunk.tool_name}]")
        elif chunk.type == "tool_result":
            print(f"\n[ผลลัพธ์เครื่องมือจาก {chunk.tool_name}]: {chunk.result}")
        elif chunk.type == "error":
            print(f"\nข้อผิดพลาด: {chunk.error}")
    
    print("\nการตอบกลับเสร็จสิ้น.")

# เรียกใช้ฟังก์ชัน async
import asyncio
asyncio.run(stream_response())

การจัดการข้อผิดพลาด

กำหนดการจัดการข้อผิดพลาดอย่างเข้มงวดเพื่อจัดการปัญหาที่เกิดจาก API:

from dolphin_mcp.exceptions import MCPAPIError, MCPConfigError, MCPTimeoutError

try:
    mcp_client = DolphinMCP.from_config("./config.json")
    conversation = mcp_client.create_conversation()
    response = conversation.add_user_message("สร้างการตอบกลับที่ซับซ้อน")
    
except MCPTimeoutError:
    print("คำขอหมดเวลา โปรดตรวจสอบการเชื่อมต่อเครือข่ายของคุณหรือเพิ่มค่า timeout.")
    
except MCPAPIError as e:
    print(f"ข้อผิดพลาด API: {e.status_code} - {e.message}")
    if e.status_code == 429:
        print("เกินขีดจำกัดอัตรา โปรดใช้กลยุทธ์ backoff ที่เพิ่มขึ้น.")
    
except MCPConfigError as e:
    print(f"ข้อผิดพลาดในการกำหนดค่า: {e}")
    
except Exception as e:
    print(f"ข้อผิดพลาดที่ไม่คาดคิด: {e}")

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

สำหรับสภาพแวดล้อมการผลิต โปรดพิจารณาการเพิ่มประสิทธิภาพเหล่านี้:

# การใช้เซสชันซ้ำสำหรับการจัดการการเชื่อมโยง
from dolphin_mcp import DolphinMCP
import aiohttp

async def optimized_mcp_usage():
    # สร้างเซสชันร่วมสำหรับการจัดการการเชื่อมโยง
    async with aiohttp.ClientSession() as session:
        mcp_client = DolphinMCP.from_config(
            "./config.json",
            session=session,
            request_timeout=60,
            connection_pool_size=10
        )
        
        # ประมวลผลการสนทนาหลายรายการอย่างมีประสิทธิภาพ
        tasks = []
        for i in range(5):
            conversation = mcp_client.create_conversation()
            conversation.add_system_message("คุณเป็นผู้ช่วยที่มีประโยชน์.")
            tasks.append(conversation.add_user_message_async(f"คำถาม {i}: การเรียนรู้ของเครื่องคืออะไร?"))
        
        # รวบรวมการตอบกลับทั้งหมด
        responses = await asyncio.gather(*tasks)
        
        for i, response in enumerate(responses):
            print(f"การตอบกลับ {i}: {response.content[:100]}...")

การรวมเข้ากับเว็บแอปพลิเคชัน

ตัวอย่างการรวม Flask:

from flask import Flask, request, jsonify
from dolphin_mcp import DolphinMCP

app = Flask(__name__)
mcp_client = DolphinMCP.from_config("./config.json")

@app.route("/chat", methods=["POST"])
def chat():
    data = request.json
    conversation_id = data.get("conversation_id")
    message = data.get("message")
    
    # ดึงหรือสร้างการสนทนา
    if conversation_id and conversation_id in active_conversations:
        conversation = active_conversations[conversation_id]
    else:
        conversation = mcp_client.create_conversation()
        conversation_id = conversation.id
        active_conversations[conversation_id] = conversation
        conversation.add_system_message("คุณเป็นผู้ช่วย AI ที่มีประโยชน์.")
    
    # ประมวลผลข้อความ
    response = conversation.add_user_message(message)
    
    return jsonify({
        "conversation_id": conversation_id,
        "response": response.content,
        "tool_results": response.tool_results
    })

if __name__ == "__main__":
    active_conversations = {}
    app.run(debug=True)

การแก้ไขปัญหาเรื่องทั่วไป

บทสรุป

Dolphin-MCP ให้วิธีการที่ยืดหยุ่นและเป็นโอเพนซอร์สในการใช้โมเดล OpenAI ด้วยโพรโทคอล MCP การนำเสนอนี้ช่วยให้ผู้พัฒนาหลีกเลี่ยงการติดพันกับผู้ให้บริการในขณะที่รักษาส่วนติดต่อที่สอดคล้องกันทั่วทั้งผู้ให้บริการ LLM ที่แตกต่างกัน โดยการทำตามขั้นตอนในคู่มือนี้ คุณสามารถใช้พลังของโมเดล GPT ผ่านสถาปัตยกรรม MCP ที่เป็นมาตรฐานได้

philschmid.de แสดงการรวมที่คล้ายกันกับ LLM อื่นๆ และเครื่องมือเช่น mcpadapt สามารถช่วยขยายความสามารถของ Dolphin-MCP ได้มากยิ่งขึ้น.