gurddy mcp

ทางการ

พื้นที่เก็บข้อมูลนี้ประกอบด้วยเซิร์ฟเวอร์ MCP (Model Context Protocol) ที่ทำงานได้อย่างสมบูรณ์ โดยให้โซลูชันสำหรับปัญหาการตอบสนองข้อจำกัด (CSP) และการโปรแกรมเชิงเส้น (LP) ซึ่งอิงตามแพ็กเกจ gurddy และรองรับการแก้ปัญหาคลาสสิกที่หลากหลาย

GitHub
2

คุณทำอะไรได้บ้างด้วย Gurddy MCP?

  • แก้ปัญหา N-Queens สำหรับกระดานทุกขนาด — ให้ AI ของคุณวาง N ควีนบนกระดาน N×N โดยไม่มีการโจมตีกัน โดยใช้ solve_n_queens
  • แก้ปัญหาซูโดกุ — ระบุตาราง 9×9 โดยใส่ศูนย์แทนช่องว่าง แล้วรับคำตอบที่สมบูรณ์ผ่าน solve_sudoku
  • ปรับแผนการผลิตให้เหมาะสม — เพิ่มกำไรสูงสุดจากผลิตภัณฑ์ต่างๆ ภายใต้ข้อจำกัดด้านทรัพยากร พร้อมการวิเคราะห์ความไว (sensitivity analysis) แบบเลือกได้ โดยใช้ solve_production_planning
  • หาจุดสมดุลของแนชในเกมผลรวมศูนย์ — คำนวณกลยุทธ์ผสมที่เหมาะสมที่สุดสำหรับเกมสองผู้เล่น เช่น เป่ายิ้งฉุบ โดยใช้ solve_minimax_game
  • แก้เกม 24 แต้ม — ค้นหานิพจน์ทางคณิตศาสตร์ที่ให้ผลลัพธ์เป็น 24 จากตัวเลขสี่ตัวที่กำหนด โดยใช้ solve_24_point_game
  • ปรับพอร์ตการลงทุนให้เหมาะสมด้วย SciPy — เพิ่มผลตอบแทนที่ปรับตามความเสี่ยงสูงสุดโดยใช้การปรับความแปรปรวนเฉลี่ย (mean-variance optimization) ผ่าน solve_scipy_portfolio_optimization

เอกสาร

Gurddy MCP Server

PyPI version Python Support License: MIT Live Demo

เซิร์ฟเวอร์ Model Context Protocol (MCP) ที่ครอบคลุมสำหรับการแก้ปัญหา Constraint Satisfaction Problems (CSP), Linear Programming (LP), Minimax optimization และปัญหาการหาค่าเหมาะที่สุดขั้นสูงที่ขับเคลื่อนด้วย SciPy สร้างขึ้นบนไลบรารีการหาค่าเหมาะที่สุด gurddy พร้อมการผสานรวม SciPy รองรับการแก้ปัญหาคลาสสิกหลากหลายผ่านการขนส่ง MCP สองแบบ: stdio (สำหรับการผสานรวม IDE) และ HTTP แบบสตรีมได้ (สำหรับเว็บไคลเอนต์)

🚀 เริ่มต้นอย่างรวดเร็ว (Stdio): pip install gurddy_mcp จากนั้นกำหนดค่าใน IDE ของคุณ

🌐 เริ่มต้นอย่างรวดเร็ว (HTTP): docker run -p 8080:8080 gurddy-mcp หรือดูคู่มือการปรับใช้

📦 แพ็คเกจ PyPI: https://pypi.org/project/gurddy_mcp

คุณสมบัติหลัก

🎯 การแก้ปัญหา CSP

  • ปัญหา N-Queens: วางราชินี N ตัวบนกระดานหมากรุก N×N โดยไม่มีการโจมตีกัน
  • การระบายสีกราฟ: กำหนดสีให้จุดยอดเพื่อให้จุดยอดที่อยู่ติดกันมีสีต่างกัน
  • การระบายสีแผนที่: ระบายสีภูมิภาคทางภูมิศาสตร์โดยให้ภูมิภาคที่อยู่ติดกันมีสีต่างกัน
  • ตัวแก้ Sudoku: แก้ปริศนา Sudoku มาตรฐาน 9×9
  • ปริศนาตรรกะ: ปริศนาม้าลายของไอน์สไตน์และปัญหาตรรกะที่กำหนดเอง
  • การจัดตาราง: การจัดตารางเรียน, การจัดตารางประชุม, การจัดสรรทรัพยากร
  • ตัวแก้ CSP ทั่วไป: รองรับปัญหาความพึงพอใจของข้อจำกัดที่กำหนดเอง

📊 ปัญหา LP/การหาค่าเหมาะที่สุด

  • Linear Programming: การหาค่าเหมาะที่สุดของตัวแปรต่อเนื่องด้วยข้อจำกัดเชิงเส้น
  • Mixed Integer Programming: การหาค่าเหมาะที่สุดด้วยตัวแปรจำนวนเต็มและต่อเนื่อง
  • การวางแผนการผลิต: การหาค่าเหมาะที่สุดของการผลิตภายใต้ข้อจำกัดทรัพยากรพร้อมการวิเคราะห์ความไว
  • การหาค่าเหมาะที่สุดของพอร์ตโฟลิโอ: การจัดสรรการลงทุนภายใต้ข้อจำกัดความเสี่ยง
  • ปัญหาการขนส่ง: การหาค่าเหมาะที่สุดของห่วงโซ่อุปทานและโลจิสติกส์

🎮 Minimax/ทฤษฎีเกม

  • เกมผลรวมศูนย์: แก้เกมสองผู้เล่น (Rock-Paper-Scissors, Matching Pennies, Battle of Sexes)
  • สมดุลแนชกลยุทธ์ผสม: ค้นหากลยุทธ์ความน่าจะเป็นที่เหมาะสมที่สุด
  • การหาค่าเหมาะที่สุดแบบทนทาน: ลดการสูญเสียกรณีเลวร้ายที่สุดภายใต้ความไม่แน่นอน
  • การตัดสินใจ Maximin: เพิ่มผลได้กรณีเลวร้ายที่สุด (กลยุทธ์อนุรักษ์นิยม)
  • เกมความปลอดภัย: การจัดสรรทรัพยากรผู้ป้องกัน-ผู้โจมตี
  • พอร์ตโฟลิโอทนทาน: ลดการสูญเสียสูงสุดในสถานการณ์ตลาดต่างๆ
  • การวางแผนการผลิต: การตัดสินใจผลิตแบบอนุรักษ์นิยม (เพิ่มกำไรขั้นต่ำ)
  • การแข่งขันโฆษณา: เกมส่วนแบ่งตลาดและกลยุทธ์การแข่งขัน

🔬 การผสานรวม SciPy

  • การหาค่าเหมาะที่สุดของพอร์ตโฟลิโอแบบไม่เชิงเส้น: แบบจำลองความเสี่ยงกำลังสองด้วยการหาค่าเหมาะที่สุดของ SciPy
  • การประมาณค่าพารามิเตอร์ทางสถิติ: การปรับการแจกแจงด้วยข้อจำกัด (MLE, การจับคู่ควอนไทล์)
  • การหาค่าเหมาะที่สุดของการประมวลผลสัญญาณ: การออกแบบตัวกรอง FIR ด้วยการหาค่าเหมาะที่สุดของการตอบสนองความถี่
  • CSP-SciPy แบบผสม: การเลือกสถานที่แบบไม่ต่อเนื่อง + การหาค่าเหมาะที่สุดของกำลังการผลิตต่อเนื่อง
  • การอินทิเกรตเชิงตัวเลข: ปัญหาการหาค่าเหมาะที่สุดที่เกี่ยวข้องกับอินทิกรัลและฟังก์ชันซับซ้อน

🧮 ปัญหาคณิตศาสตร์คลาสสิก

  • เกม 24 จุด: ค้นหานิพจน์เลขคณิตเพื่อให้ได้ 24 โดยใช้ตัวเลขสี่ตัว
  • ปัญหาไก่-กระต่าย: ปัญหาข้อจำกัดคลาสสิกที่มีหัวและขา
  • Mini Sudoku: ตัวแก้ Sudoku 4×4 โดยใช้เทคนิค CSP
  • ปัญหา 4-Queens: N-Queens แบบง่ายเพื่อการศึกษา
  • 0-1 Knapsack: ปัญหาการหาค่าเหมาะที่สุดคลาสสิกที่มีข้อจำกัดน้ำหนักและมูลค่า

🔌 การรองรับโปรโตคอล MCP

  • การขนส่ง Stdio: การผสานรวม IDE ในเครื่อง (Kiro, Claude Desktop, Cline, ฯลฯ)
  • การขนส่ง HTTP แบบสตรีมได้: เว็บไคลเอนต์และการเข้าถึงระยะไกลพร้อมการสตรีมเสริม
  • อินเทอร์เฟซแบบรวม: เครื่องมือเดียวกันในการขนส่งทั้งสองแบบ
  • JSON-RPC 2.0: การปฏิบัติตามโปรโตคอลอย่างสมบูรณ์
  • การอนุมัติอัตโนมัติ: กำหนดค่าเครื่องมือที่เชื่อถือได้เพื่อการดำเนินการที่ราบรื่น

การติดตั้ง

จาก PyPI (แนะนำ)

# Install the latest stable version
pip install gurddy_mcp

# Or install with development dependencies
pip install gurddy_mcp[dev]

จากซอร์ส

# Clone the repository
git clone https://github.com/novvoo/gurddy-mcp.git
cd gurddy-mcp

# Install in development mode
pip install -e .

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

# Test MCP stdio server
echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | gurddy-mcp

การใช้งาน

1. เซิร์ฟเวอร์ MCP Stdio (อินเทอร์เฟซหลัก)

คำสั่ง gurddy-mcp หลักคือเซิร์ฟเวอร์ MCP stdio ที่สามารถผสานรวมกับเครื่องมือเช่น Kiro

ตัวเลือก A: ใช้ uvx (แนะนำ - เวอร์ชันล่าสุดเสมอ)

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

กำหนดค่าใน ~/.kiro/settings/mcp.json หรือ .kiro/settings/mcp.json:

แนะนำ: ระบุเวอร์ชันล่าสุดอย่างชัดเจน

{
  "mcpServers": {
    "gurddy": {
      "command": "uvx",
      "args": ["gurddy-mcp@latest"],
      "env": {},
      "disabled": false,
      "autoApprove": [
        "run_example",
        "info",
        "install",
        "solve_n_queens",
        "solve_sudoku",
        "solve_graph_coloring",
        "solve_map_coloring",
        "solve_lp",
        "solve_production_planning",
        "solve_minimax_game",
        "solve_minimax_decision",
        "solve_24_point_game",
        "solve_chicken_rabbit_problem",
        "solve_scipy_portfolio_optimization",
        "solve_scipy_statistical_fitting",
        "solve_scipy_facility_location"
      ]
    }
  }
}

ทางเลือก: ไม่ระบุเวอร์ชัน (ใช้ล่าสุดเช่นกัน)

{
  "mcpServers": {
    "gurddy": {
      "command": "uvx",
      "args": ["gurddy-mcp"],
      "env": {},
      "disabled": false,
      "autoApprove": [
        "run_example", "info", "install", "solve_n_queens", "solve_sudoku", 
        "solve_graph_coloring", "solve_map_coloring", "solve_lp", 
        "solve_production_planning", "solve_minimax_game", "solve_minimax_decision",
        "solve_24_point_game", "solve_chicken_rabbit_problem", 
        "solve_scipy_portfolio_optimization", "solve_scipy_statistical_fitting", 
        "solve_scipy_facility_location"
      ]
    }
  }
}

ตรึงเวอร์ชันเฉพาะ (หากจำเป็น)

{
  "mcpServers": {
    "gurddy": {
      "command": "uvx",
      "args": ["gurddy-mcp==<VERSION>"],
      "env": {},
      "disabled": false,
      "autoApprove": [
        "run_example", "info", "install", "solve_n_queens", "solve_sudoku", 
        "solve_graph_coloring", "solve_map_coloring", "solve_lp", 
        "solve_production_planning", "solve_minimax_game", "solve_minimax_decision",
        "solve_24_point_game", "solve_chicken_rabbit_problem", 
        "solve_scipy_portfolio_optimization", "solve_scipy_statistical_fitting", 
        "solve_scipy_facility_location"
      ]
    }
  }
}

ทำไมต้องใช้ uvx?

  • ✅ เรียกใช้เวอร์ชันล่าสุดที่เผยแพร่โดยอัตโนมัติเสมอ
  • ✅ ไม่ต้องติดตั้งหรืออัปเกรดด้วยตนเอง
  • ✅ สภาพแวดล้อมแยกต่อการดำเนินการ
  • ✅ ไม่มีข้อขัดแย้งของ dependencies กับ Python ระบบของคุณ

ข้อกำหนดเบื้องต้น: ติดตั้ง uv ก่อน:

# macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Or using pip
pip install uv

# Or using Homebrew (macOS)
brew install uv

ตัวเลือก B: ใช้คำสั่งโดยตรง (หลังการติดตั้ง)

หากคุณติดตั้ง gurddy-mcp ผ่าน pip แล้ว:

{
  "mcpServers": {
    "gurddy": {
      "command": "gurddy-mcp",
      "args": [],
      "env": {},
      "disabled": false,
      "autoApprove": [
        "run_example", "info", "install", "solve_n_queens", "solve_sudoku", 
        "solve_graph_coloring", "solve_map_coloring", "solve_lp", 
        "solve_production_planning", "solve_minimax_game", "solve_minimax_decision",
        "solve_24_point_game", "solve_chicken_rabbit_problem", 
        "solve_scipy_portfolio_optimization", "solve_scipy_statistical_fitting", 
        "solve_scipy_facility_location"
      ]
    }
  }
}

เครื่องมือ MCP ที่มีให้ (ทั้งหมด 16 รายการ):

  • info - รับข้อมูลและความสามารถของเซิร์ฟเวอร์ gurddy MCP
  • install - ติดตั้งหรืออัปเกรดแพ็คเกจ gurddy
  • run_example - เรียกใช้โปรแกรมตัวอย่าง (n_queens, graph_coloring, minimax, scipy_optimization, classic_problems, ฯลฯ)
  • solve_n_queens - แก้ปัญหา N-Queens สำหรับขนาดกระดานใดๆ
  • solve_sudoku - แก้ปริศนา Sudoku 9×9 โดยใช้ CSP
  • solve_graph_coloring - แก้การระบายสีกราฟด้วยสีที่กำหนดค่าได้
  • solve_map_coloring - แก้ปัญหาการระบายสีแผนที่ (เช่น ออสเตรเลีย, สหรัฐอเมริกา)
  • solve_lp - แก้ Linear Programming (LP) หรือ Mixed Integer Programming (MIP)
  • solve_production_planning - การหาค่าเหมาะที่สุดของการผลิตพร้อมการวิเคราะห์ความไวเสริม
  • solve_minimax_game - เกมผลรวมศูนย์สองผู้เล่น (ค้นหาสมดุลแนช)
  • solve_minimax_decision - การหาค่าเหมาะที่สุดแบบทนทาน (ลดการสูญเสียสูงสุดหรือเพิ่มผลได้ขั้นต่ำ)
  • solve_24_point_game - แก้เกม 24 จุดด้วยตัวเลขสี่ตัวโดยใช้การดำเนินการเลขคณิต
  • solve_chicken_rabbit_problem - แก้ปัญหาไก่-กระต่ายคลาสสิกด้วยข้อจำกัดหัวและขา
  • solve_scipy_portfolio_optimization - แก้การหาค่าเหมาะที่สุดของพอร์ตโฟลิโอแบบไม่เชิงเส้นโดยใช้ SciPy
  • solve_scipy_statistical_fitting - แก้การประมาณค่าพารามิเตอร์ทางสถิติโดยใช้ SciPy
  • solve_scipy_facility_location - แก้ปัญหาการเลือกสถานที่โดยใช้วิธี CSP-SciPy แบบผสม

ทดสอบเซิร์ฟเวอร์ MCP:

# Test initialization
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' | gurddy-mcp

# Test listing tools
echo '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' | gurddy-mcp

# Test info tools
echo '{"jsonrpc":"2.0","id":10,"method":"tools/call","params":{"name":"info","arguments":{"":""}}}' | gurddy-mcp |jq 

# Test run example tools
echo '{"jsonrpc":"2.0","id":10,"method":"tools/call","params":{"name":"run_example","arguments":{"example":"n_queens"}}}' | gurddy-mcp |jq

# Test sudoku tools
cat <<EOF | tr -d '\n'|gurddy-mcp|jq
{"jsonrpc":"2.0","id":123,"method":"tools/call","params":{
  "name":"solve_sudoku",
  "arguments":{
    "puzzle":[
      [5,3,0,0,7,0,0,0,0],
      [6,0,0,1,9,5,0,0,0],
      [0,9,8,0,0,0,0,6,0],
      [8,0,0,0,6,0,0,0,3],
      [4,0,0,8,0,3,0,0,1],
      [7,0,0,0,2,0,0,0,6],
      [0,6,0,0,0,0,2,8,0],
      [0,0,0,4,1,9,0,0,5],
      [0,0,0,0,8,0,0,7,9]
    ]
  }
}}
EOF

2. เซิร์ฟเวอร์ MCP HTTP

เริ่มเซิร์ฟเวอร์ MCP HTTP (โปรโตคอล MCP ผ่าน HTTP แบบสตรีมได้):

การพัฒนาในเครื่อง:

uvicorn mcp_server.mcp_http_server:app --host 127.0.0.1 --port 8080

Docker:

# Build the image
docker build -t gurddy-mcp .

# Run the container
docker run -p 8080:8080 gurddy-mcp

เข้าถึงเซิร์ฟเวอร์:

ทดสอบเซิร์ฟเวอร์ MCP HTTP:

การขนส่ง HTTP (ไม่สตรีม):

# List available tools
curl -X POST http://127.0.0.1:8080/mcp/http \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

# Call a tool
curl -X POST http://127.0.0.1:8080/mcp/http \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"info","arguments":{}}}'

การขนส่ง HTTP (สตรีมด้วยส่วนหัว Accept):

# List tools with streaming response
curl -X POST http://127.0.0.1:8080/mcp/http \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

# Call a tool with streaming response
curl -X POST http://127.0.0.1:8080/mcp/http \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"solve_n_queens","arguments":{"n":4}}}'

การขนส่ง HTTP (สตรีมด้วยส่วนหัว X-Stream):

# Alternative way to enable streaming
curl -X POST http://127.0.0.1:8080/mcp/http \
  -H "Content-Type: application/json" \
  -H "X-Stream: true" \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"info","arguments":{}}}'

ตัวอย่างไคลเอนต์ Python:

  • examples/streamable_http_client.py - ไคลเอนต์การขนส่ง HTTP พร้อมตัวอย่างการสตรีม

เครื่องมือ MCP

เซิร์ฟเวอร์มีเครื่องมือ MCP ดังต่อไปนี้:

info

รับข้อมูลเกี่ยวกับแพ็คเกจ gurddy

{
  "name": "info",
  "arguments": {}
}

install

ติดตั้งหรืออัปเกรดแพ็คเกจ gurddy

{
  "name": "install",
  "arguments": {
    "package": "gurddy",
    "upgrade": false
  }
}

run_example

เรียกใช้ตัวอย่าง gurddy

{
  "name": "run_example",
  "arguments": {
    "example": "n_queens"
  }
}

ตัวอย่างที่มี: lp, csp, n_queens, graph_coloring, map_coloring, scheduling, logic_puzzles, optimized_csp, optimized_lp, minimax, scipy_optimization, classic_problems

solve_n_queens

แก้ปัญหา N-Queens

{
  "name": "solve_n_queens",
  "arguments": {
    "n": 8
  }
}

solve_sudoku

แก้ปริศนา Sudoku 9x9

{
  "name": "solve_sudoku",
  "arguments": {
    "puzzle": [[5,3,0,...], [6,0,0,...], ...]
  }
}

solve_graph_coloring

แก้ปัญหาการระบายสีกราฟ

{
  "name": "solve_graph_coloring",
  "arguments": {
    "edges": [[0,1], [1,2], [2,0]],
    "num_vertices": 3,
    "max_colors": 3
  }
}

solve_map_coloring

แก้ปัญหาการระบายสีแผนที่

{
  "name": "solve_map_coloring",
  "arguments": {
    "regions": ["A", "B", "C"],
    "adjacencies": [["A", "B"], ["B", "C"]],
    "max_colors": 2
  }
}

solve_lp

แก้ปัญหา Linear Programming (LP) หรือ Mixed Integer Programming (MIP) โดยใช้ PuLP

{
  "name": "solve_lp",
  "arguments": {
    "profits": {
      "ProductA": 30,
      "ProductB": 40
    },
    "consumption": {
      "ProductA": {"Labor": 2, "Material": 3},
      "ProductB": {"Labor": 3, "Material": 2}
    },
    "capacities": {
      "Labor": 100,
      "Material": 120
    },
    "integer": true
  }
}

solve_production_planning

แก้ปัญหาการหาค่าเหมาะที่สุดของการวางแผนการผลิตพร้อมการวิเคราะห์ความไวเสริม

{
  "name": "solve_production_planning",
  "arguments": {
    "profits": {
      "ProductA": 30,
      "ProductB": 40
    },
    "consumption": {
      "ProductA": {"Labor": 2, "Material": 3},
      "ProductB": {"Labor": 3, "Material": 2}
    },
    "capacities": {
      "Labor": 100,
      "Material": 120
    },
    "integer": true,
    "sensitivity_analysis": false
  }
}

solve_minimax_game

แก้เกมผลรวมศูนย์สองผู้เล่นโดยใช้ minimax (ทฤษฎีเกม)

{
  "name": "solve_minimax_game",
  "arguments": {
    "payoff_matrix": [
      [0, -1, 1],
      [1, 0, -1],
      [-1, 1, 0]
    ],
    "player": "row"
  }
}

ส่งคืนกลยุทธ์ผสมที่เหมาะสมที่สุดและมูลค่าเกมสำหรับผู้เล่นที่ระบุ

solve_minimax_decision

แก้ปัญหาการตัดสินใจ minimax ภายใต้ความไม่แน่นอน (การหาค่าเหมาะที่สุดแบบทนทาน)

{
  "name": "solve_minimax_decision",
  "arguments": {
    "scenarios": [
      {"A": -0.2, "B": -0.1, "C": 0.05},
      {"A": 0.3, "B": 0.2, "C": -0.02},
      {"A": 0.05, "B": 0.03, "C": -0.01}
    ],
    "decision_vars": ["A", "B", "C"],
    "budget": 100.0,
    "objective": "minimize_max_loss"
  }
}

วัตถุประสงค์: minimize_max_loss (พอร์ตโฟลิโอทนทาน) หรือ maximize_min_gain (การผลิตแบบอนุรักษ์นิยม)

solve_24_point_game

แก้เกม 24 จุดด้วยตัวเลขสี่ตัวโดยใช้การดำเนินการเลขคณิต

{
  "name": "solve_24_point_game",
  "arguments": {
    "numbers": [1, 2, 3, 4]
  }
}

ค้นหานิพจน์เลขคณิตโดยใช้ +, -, *, / และวงเล็บเพื่อให้ได้ 24 พอดี

solve_chicken_rabbit_problem

แก้ปัญหาไก่-กระต่ายคลาสสิกด้วยข้อจำกัดหัวและขา

{
  "name": "solve_chicken_rabbit_problem",
  "arguments": {
    "total_heads": 35,
    "total_legs": 94
  }
}

กำหนดจำนวนไก่ (2 ขา) และกระต่าย (4 ขา) จากจำนวนหัวและขาทั้งหมด

solve_scipy_portfolio_optimization

แก้การหาค่าเหมาะที่สุดของพอร์ตโฟลิโอแบบไม่เชิงเส้นโดยใช้ SciPy ด้วยแบบจำลองความเสี่ยงกำลังสอง

{
  "name": "solve_scipy_portfolio_optimization",
  "arguments": {
    "expected_returns": [0.12, 0.18, 0.15],
    "covariance_matrix": [
      [0.04, 0.01, 0.02],
      [0.01, 0.09, 0.03],
      [0.02, 0.03, 0.06]
    ],
    "risk_tolerance": 1.0
  }
}

หาค่าเหมาะที่สุดของน้ำหนักพอร์ตโฟลิโอเพื่อเพิ่มผลตอบแทนลบด้วยค่าปรับความเสี่ยงโดยใช้การหาค่าเหมาะที่สุด mean-variance

solve_scipy_statistical_fitting

แก้การประมาณค่าพารามิเตอร์ทางสถิติโดยใช้ SciPy ด้วยการปรับการแจกแจง

{
  "name": "solve_scipy_statistical_fitting",
  "arguments": {
    "data": [1.2, 2.3, 1.8, 2.1, 1.9, 2.4, 1.7, 2.0],
    "distribution": "normal"
  }
}

ปรับการแจกแจงทางสถิติ ("normal", "exponential", "uniform") ให้เข้ากับข้อมูลและให้การทดสอบความดีของการปรับ

solve_scipy_facility_location

แก้ปัญหาการเลือกสถานที่โดยใช้วิธี CSP-SciPy แบบผสม

{
  "name": "solve_scipy_facility_location",
  "arguments": {
    "customer_locations": [[0, 0], [10, 10], [5, 15]],
    "customer_demands": [100, 150, 80],
    "facility_locations": [[2, 3], [8, 12], [6, 8]],
    "max_facilities": 2,
    "fixed_cost": 100.0
  }
}

รวมการเลือกสถานที่แบบไม่ต่อเนื่อง (CSP) กับการหาค่าเหมาะที่สุดของกำลังการผลิตต่อเนื่อง (SciPy) เพื่อลดต้นทุนรวม

การปรับใช้ Docker

สร้างและเรียกใช้

# Build the image
docker build -t gurddy-mcp .

# Run the container
docker run -p 8080:8080 gurddy-mcp

# Or with environment variables
docker run -p 8080:8080 -e PORT=8080 gurddy-mcp

Docker Compose

version: '3.8'
services:
  gurddy-mcp:
    build: .
    ports:
      - "8080:8080"
    environment:
      - PYTHONUNBUFFERED=1
    restart: unless-stopped

ตัวอย่างผลลัพธ์

ปัญหา N-Queens

POST /solve-n-queens
{
"n": 8
}

โครงสร้างโปรเจกต์

mcp_server/
├── handlers/
│   └── gurddy.py           # Core solver implementation (16 MCP tools)
│                          # - solve_24_point_game, solve_chicken_rabbit_problem
│                          # - solve_scipy_portfolio_optimization, solve_scipy_statistical_fitting
│                          # - solve_scipy_facility_location, and 11 other solvers
├── tools/                  # MCP tool wrappers
├── examples/               # Rich Problem Examples
│   ├── n_queens.py         # N-Queens Problem
│   ├── graph_coloring.py   # Graph Coloring Problem
│   ├── map_coloring.py     # Map Coloring Problem
│   ├── logic_puzzles.py    # Logic Puzzles
│   ├── scheduling.py       # Scheduling Problem
│   ├── scipy_optimization.py # SciPy Integration Examples
│   │                      # - Portfolio optimization, statistical fitting, facility location
│   ├── classic_problems.py # Classic Math Problems
│   │                      # - 24-point game, chicken-rabbit problem, mini sudoku
│   ├── optimized_csp.py    # Advanced CSP techniques
│   ├── optimized_lp.py     # Linear programming examples
│   └── minimax.py          # Game theory and robust optimization
├── mcp_stdio_server.py     # MCP Stdio Server (for IDE integration)
└── mcp_http_server.py      # MCP HTTP Server (for web clients)

examples/
└── http_mcp_client.py      # Example HTTP MCP client

Dockerfile                  # Docker configuration for HTTP server

การขนส่ง MCP

การขนส่งคำสั่งโปรโตคอลกรณีใช้งาน
Stdiogurddy-mcpMCP ผ่าน stdin/stdoutการผสานรวม IDE (Kiro, Claude Desktop, ฯลฯ)
HTTP แบบสตรีมได้uvicorn mcp_server.mcp_http_server:appMCP ผ่าน HTTP พร้อมการสตรีมเสริมเว็บไคลเอนต์, การเข้าถึงระยะไกล, การปรับใช้ Docker

การขนส่งทั้งหมดใช้โปรโตคอล MCP เดียวกันและให้เครื่องมือที่เหมือนกัน

คุณสมบัติการขนส่ง HTTP

การขนส่ง HTTP (จุดสิ้นสุด /mcp/http):

  • รูปแบบคำขอ-ตอบกลับเดี่ยว
  • การสตรีมเสริม: เพิ่มส่วนหัว Accept: text/event-stream หรือ X-Stream: true
  • ง่ายกว่าสำหรับคำขอครั้งเดียว
  • เข้ากันได้กับไคลเอนต์ HTTP มาตรฐาน
  • ไม่มีสถานะการเชื่อมต่อที่ต้องจัดการ
  • รองรับทั้งการตอบกลับ JSON ปกติและการตอบกลับแบบสตรีมที่จัดรูปแบบ SSE

ตัวอย่างผลลัพธ์

ปัญหา N-Queens

$ gurddy-mcp-cli run-example n_queens

Solving 8-Queens problem...

8-Queens Solution:
+---+---+---+---+---+---+---+---+
| Q |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+
|   |   |   |   | Q |   |   |   |
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   | Q |
+---+---+---+---+---+---+---+---+
|   |   |   |   |   | Q |   |   |
+---+---+---+---+---+---+---+---+
|   |   | Q |   |   |   |   |   |
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   | Q |   |
+---+---+---+---+---+---+---+---+
|   | Q |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+
|   |   |   | Q |   |   |   |   |
+---+---+---+---+---+---+---+---+
Queen positions: (0,0), (1,4), (2,7), (3,5), (4,2), (5,6), (6,1), (7,3)

ปริศนาตรรกะ

$ python -m mcp_server.server run-example logic_puzzles

Solving Simple Logic Puzzle:
Solution:
Position 1: Alice has Cat in Green house
Position 2: Bob has Dog in Red house  
Position 3: Carol has Fish in Blue house

Solving the Famous Zebra Puzzle (Einstein's Riddle)...
ANSWERS:
Who owns the zebra? Ukrainian (House 5)
Who drinks water? Japanese (House 2)

ตัวอย่าง HTTP API

การแก้ปัญหาคลาสสิก

การระบายสีแผนที่ออสเตรเลีย

import requests

response = requests.post("http://127.0.0.1:8080/solve-map-coloring", json={ 
"regions": ['WA', 'NT', 'SA', 'QLD', 'NSW', 'VIC', 'TAS'], 
"adjacencies": [ 
['WA', 'NT'], ['WA', 'SA'], ['NT', 'SA'], ['NT', 'QLD'], 
['SA', 'QLD'], ['SA', 'NSW'], ['SA', 'VIC'], 
['QLD', 'NSW'], ['NSW', 'VIC'] 
], 
"max_colors": 4
})

ปัญหา 8-Queens

response = requests.post("http://127.0.0.1:8080/solve-n-queens",
json={"n": 8})

ตัวอย่างที่มี

ตัวอย่างทั้งหมดสามารถเรียกใช้โดยใช้ gurddy-mcp run-example <name> หรือ python -m mcp_server.server run-example <name>:

ตัวอย่าง CSP ✅

  • n_queens - ปัญหา N-Queens (4, 6, 8 ราชินีพร้อมการแสดงกระดานภาพ)
  • graph_coloring - การระบายสีกราฟ (สามเหลี่ยม, สี่เหลี่ยม, กราฟ Petersen, กราฟวงล้อ)
  • map_coloring - การระบายสีแผนที่ (ออสเตรเลีย, รัฐตะวันตกของสหรัฐอเมริกา, ยุโรป)
  • scheduling - ปัญหาการจัดตาราง (การจัดตารางเรียน, การจัดตารางประชุม, การจัดสรรทรัพยากร)
  • logic_puzzles - ปริศนาตรรกะ (ปริศนาตรรกะอย่างง่าย, ปริศนาม้าลายของไอน์สไตน์)
  • optimized_csp - เทคนิค CSP ขั้นสูง (ตัวแก้ Sudoku)

ตัวอย่าง LP ✅

  • lp / optimized_lp - ตัวอย่าง Linear Programming:
    • การหาค่าเหมาะที่สุดของพอร์ตโฟลิโอด้วยข้อจำกัดความเสี่ยง
    • ปัญหาการขนส่ง (การหาค่าเหมาะที่สุดของห่วงโซ่อุปทาน)
    • การวิเคราะห์การผ่อนคลายข้อจำกัด
    • การเปรียบเทียบประสิทธิภาพตามขนาดปัญหา

ตัวอย่าง Minimax ✅

  • minimax - การหาค่าเหมาะที่สุด Minimax และทฤษฎีเกม:
    • Rock-Paper-Scissors (เกมผลรวมศูนย์)
    • Matching Pennies (เกมประสานงาน)
    • Battle of the Sexes (สมดุลกลยุทธ์ผสม)
    • การหาค่าเหมาะที่สุดของพอร์ตโฟลิโอทนทาน (ลดการสูญเสียสูงสุด)
    • การวางแผนการผลิต (เพิ่มกำไรขั้นต่ำ)
    • การจัดสรรทรัพยากรความปลอดภัย (เกมผู้ป้องกัน-ผู้โจมตี)
    • การแข่งขันโฆษณา (เกมส่วนแบ่งตลาด)

ตัวอย่างการใช้งาน SciPy ✅

  • scipy_optimization - การหาค่าเหมาะที่สุดขั้นสูงด้วย SciPy:
    • การหาค่าเหมาะที่สุดของพอร์ตโฟลิโอแบบไม่เชิงเส้นด้วยแบบจำลองความเสี่ยงกำลังสอง
    • การประมาณค่าพารามิเตอร์ทางสถิติ (การปรับการแจกแจงให้พอดีกับข้อจำกัด)
    • การหาค่าเหมาะที่สุดในการประมวลผลสัญญาณ (การออกแบบตัวกรอง FIR)
    • ตำแหน่งที่ตั้งสิ่งอำนวยความสะดวกแบบผสม CSP-SciPy (การหาค่าเหมาะที่สุดแบบไม่ต่อเนื่อง + ต่อเนื่อง)
    • การอินทิเกรตเชิงตัวเลขในวัตถุประสงค์การหาค่าเหมาะที่สุด

ปัญหาคณิตศาสตร์คลาสสิก ✅

  • classic_problems - การแก้ปัญหาคณิตศาสตร์เพื่อการศึกษา:
    • เกม 24 แต้ม (นิพจน์เลขคณิตเพื่อให้ได้ 24)
    • ปัญหาไก่-กระต่าย (ปัญหาความพึงพอใจของข้อจำกัดแบบคลาสสิก)
    • มินิซูโดกุ 4×4 (การสาธิต CSP แบบง่าย)
    • ปัญหาควีน 4 ตัว (รูปแบบปัญหาควีน N ตัวเพื่อการศึกษา)
    • ปัญหาเป้ 0-1 (การหาค่าเหมาะที่สุดแบบคลาสสิก)

ประเภทปัญหาที่รองรับ

🧩 ปัญหา CSP

  • N-Queens: ปัญหาควีน N ตัวแบบคลาสสิกสำหรับขนาดกระดานใดๆ (N=4 ถึง N=100+)
  • การระบายสีกราฟ: การระบายสีจุดยอดสำหรับกราฟใดๆ (สามเหลี่ยม, Petersen, วงล้อ, ฯลฯ)
  • การระบายสีแผนที่: การระบายสีภูมิภาคทางภูมิศาสตร์ (แผนที่ออสเตรเลีย, สหรัฐอเมริกา, ยุโรป)
  • ซูโดกุ: ปริศนาซูโดกุมาตรฐาน 9×9 พร้อมการเผยแพร่ข้อจำกัด
  • ปริศนาตรรกะ: ปริศนาม้าลายของไอน์สไตน์และปัญหาการให้เหตุผลเชิงตรรกะแบบกำหนดเอง
  • การจัดตารางเวลา: การจัดตารางเรียน, ห้องประชุม, การจัดสรรทรัพยากรพร้อมข้อจำกัดด้านเวลา

📈 ปัญหาการหาค่าเหมาะที่สุด

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

🎲 ทฤษฎีเกมและการหาค่าเหมาะที่สุดแบบทนทาน

  • เกมผลรวมเป็นศูนย์: เป่ายิ้งฉุบ, การโยนเหรียญ, สงครามระหว่างเพศ
  • สมดุลแนชแบบกลยุทธ์ผสม: กลยุทธ์ความน่าจะเป็นที่เหมาะสมที่สุดสำหรับผู้เล่นทั้งสอง
  • การตัดสินใจแบบมินิแมกซ์: ลดการสูญเสียในกรณีที่เลวร้ายที่สุดในสถานการณ์ความไม่แน่นอน
  • การตัดสินใจแบบแมกซิมิน: เพิ่มผลกำไรในกรณีที่เลวร้ายที่สุด (กลยุทธ์แบบอนุรักษ์นิยม)
  • พอร์ตโฟลิโอแบบทนทาน: ลดการสูญเสียสูงสุดในสถานการณ์ตลาดต่างๆ
  • เกมความปลอดภัย: ปัญหาการจัดสรรทรัพยากรระหว่างผู้ป้องกันและผู้โจมตี

🔬 การหาค่าเหมาะที่สุดขั้นสูงด้วย SciPy

  • การหาค่าเหมาะที่สุดของพอร์ตโฟลิโอแบบไม่เชิงเส้น: แบบจำลองความเสี่ยงกำลังสองพร้อมการเพิ่มอัตราส่วน Sharpe สูงสุด
  • การประมาณค่าพารามิเตอร์ทางสถิติ: การปรับการแจกแจงให้พอดีด้วยวิธี MLE และควอนไทล์พร้อมข้อจำกัด
  • การประมวลผลสัญญาณ: การออกแบบตัวกรอง FIR พร้อมการหาค่าเหมาะที่สุดของการตอบสนองความถี่
  • การหาค่าเหมาะที่สุดแบบผสม: รวม Gurddy CSP เข้ากับการหาค่าเหมาะที่สุดต่อเนื่องของ SciPy
  • การอินทิเกรตเชิงตัวเลข: ปัญหาการหาค่าเหมาะที่สุดที่เกี่ยวข้องกับฟังก์ชันทางคณิตศาสตร์ที่ซับซ้อน

🧮 ปัญหาคลาสสิกเพื่อการศึกษา

  • เกม 24 แต้ม: ค้นหานิพจน์เลขคณิตโดยใช้ตัวเลขสี่ตัวเพื่อให้ได้ 24
  • ปัญหาไก่-กระต่าย: ปัญหาความพึงพอใจของข้อจำกัดแบบคลาสสิกด้วยหัวและขา
  • มินิซูโดกุ: การแก้ซูโดกุ 4×4 โดยใช้เทคนิค CSP
  • รูปแบบปัญหาควีน N ตัว: รูปแบบเพื่อการศึกษาของปัญหาคลาสสิก
  • ปัญหาเป้: การหาค่าเหมาะที่สุดของเป้ 0-1 พร้อมข้อจำกัดด้านน้ำหนักและมูลค่า

คุณสมบัติด้านประสิทธิภาพ

  • การแก้ปัญหาที่รวดเร็ว: การตอบสนองระดับมิลลิวินาทีสำหรับปัญหาขนาดเล็กถึงกลาง (N-Queens N≤12, กราฟ <50 จุดยอด)
  • ปรับขนาดได้: จัดการปัญหาขนาดใหญ่ (N-Queens N=100+, LP ที่มีตัวแปร 1000+)
  • ใช้หน่วยความจำอย่างมีประสิทธิภาพ: การค้นหาแบบย้อนรอยและการเผยแพร่ข้อจำกัดช่วยลดการใช้หน่วยความจำ
  • ขยายได้: ข้อจำกัดแบบกำหนดเอง, ฟังก์ชันวัตถุประสงค์, และประเภทปัญหา
  • ปลอดภัยสำหรับการทำงานพร้อมกัน: HTTP API รองรับการประมวลผลคำขอพร้อมกัน
  • พร้อมสำหรับการใช้งานจริง: การปรับใช้ Docker, การตรวจสอบความสมบูรณ์, การจัดการข้อผิดพลาด

เกณฑ์มาตรฐานประสิทธิภาพ

เวลาดำเนินการทั่วไปบนฮาร์ดแวร์มาตรฐาน:

  • ตัวอย่าง CSP: 0.4-0.5 วินาที (N-Queens, การระบายสีกราฟ, ปริศนาตรรกะ)
  • ตัวอย่าง LP: 0.8-0.9 วินาที (พอร์ตโฟลิโอ, การขนส่ง, การวางแผนการผลิต)
  • ตัวอย่าง Minimax: 0.3-0.5 วินาที (การแก้เกม, การหาค่าเหมาะที่สุดแบบทนทาน)
  • ตัวอย่าง SciPy: 0.5-1.2 วินาที (การหาค่าเหมาะที่สุดแบบไม่เชิงเส้น, การปรับทางสถิติ)
  • ปัญหาคลาสสิก: 0.1-0.3 วินาที (24 แต้ม, ไก่-กระต่าย, มินิซูโดกุ)
  • ซูโดกุ: <0.1 วินาที สำหรับปริศนามาตรฐาน 9×9
  • N-Queens ขนาดใหญ่: ~2-3 วินาที สำหรับ N=100

การแก้ไขปัญหา

ข้อผิดพลาดทั่วไป

  • "gurddy package not available": ติดตั้งด้วย python -m mcp_server.server install
  • "No solution found": ไม่มีวิธีแก้ปัญหาภายใต้ข้อจำกัดที่กำหนด; ลองผ่อนคลายข้อจำกัด
  • "Invalid input types": ตรวจสอบประเภทข้อมูลของพารามิเตอร์อินพุต
  • "Unknown example": ใช้ python -m mcp_server.server run-example --help เพื่อดูตัวอย่างที่มีอยู่

ปัญหาการติดตั้ง

# install individually
pip install gurddy pulp>=2.6.0 scipy>=1.9.0 numpy>=1.21.0

# Check installation
python -c "import gurddy, pulp, scipy, numpy; print('All dependencies installed')"

การดีบักตัวอย่าง

รันตัวอย่างโดยตรงเพื่อการดีบัก:

# After installing gurddy_mcp
python -c "from mcp_server.examples import n_queens; n_queens.main()"

# Or from source - CSP examples
python mcp_server/examples/n_queens.py
python mcp_server/examples/graph_coloring.py
python mcp_server/examples/logic_puzzles.py
python mcp_server/examples/optimized_csp.py

# LP and optimization examples
python mcp_server/examples/optimized_lp.py

# Game theory and minimax examples
python mcp_server/examples/minimax.py

# SciPy integration examples (includes portfolio, statistical fitting, facility location)
python mcp_server/examples/scipy_optimization.py

# Classic math problems (includes 24-point game, chicken-rabbit problem)
python mcp_server/examples/classic_problems.py

# Test individual MCP tools directly
python -c "from mcp_server.handlers.gurddy import solve_24_point_game; print(solve_24_point_game([1,2,3,4]))"
python -c "from mcp_server.handlers.gurddy import solve_chicken_rabbit_problem; print(solve_chicken_rabbit_problem(35, 94))"
python -c "from mcp_server.handlers.gurddy import solve_scipy_portfolio_optimization; print(solve_scipy_portfolio_optimization([0.12, 0.18], [[0.04, 0.01], [0.01, 0.09]]))"

ข้อกำหนดการใช้งาน SciPy

ตัวอย่างการใช้งาน SciPy ต้องการการพึ่งพาเพิ่มเติม:

# Install SciPy and NumPy 
pip install scipy>=1.9.0 numpy>=1.21.0

# Verify SciPy integration
python -c "import scipy.optimize, numpy; print('SciPy integration ready')"

ตัวอย่าง SciPy รวมถึง:

  • การหาค่าเหมาะที่สุดของพอร์ตโฟลิโอแบบไม่เชิงเส้น: แบบจำลองความเสี่ยงกำลังสองพร้อมการเพิ่มอัตราส่วน Sharpe สูงสุด
  • การประมาณค่าพารามิเตอร์ทางสถิติ: การปรับการแจกแจงให้พอดีด้วยวิธี MLE และควอนไทล์
  • การประมวลผลสัญญาณ: การออกแบบตัวกรอง FIR พร้อมการหาค่าเหมาะที่สุดของการตอบสนองความถี่
  • CSP-SciPy แบบผสม: ตำแหน่งที่ตั้งสิ่งอำนวยความสะดวกที่รวมการหาค่าเหมาะที่สุดแบบไม่ต่อเนื่องและต่อเนื่อง
  • การอินทิเกรตเชิงตัวเลข: ปัญหาการหาค่าเหมาะที่สุดที่ซับซ้อนเกี่ยวกับอินทิกรัล

การพัฒนา

สถาปัตยกรรม

โปรเจกต์ใช้ รีจิสทรีเครื่องมือแบบรวมศูนย์ พร้อม สกีมาที่สร้างขึ้นอัตโนมัติ เพื่อให้แน่ใจถึงความสอดคล้องระหว่างเซิร์ฟเวอร์ stdio และ HTTP:

  • คำจำกัดความของเครื่องมือ: mcp_server/tool_definitions.py (เมตาดาต้าพื้นฐานเท่านั้น)
  • รีจิสทรีที่สร้างขึ้นอัตโนมัติ: mcp_server/tool_registry.py (สกีมาที่สร้างจากลายเซ็นฟังก์ชัน)
  • เซิร์ฟเวอร์ Stdio: mcp_server/mcp_stdio_server.py (สำหรับการรวม IDE)
  • เซิร์ฟเวอร์ HTTP: mcp_server/mcp_http_server.py (สำหรับไคลเอนต์เว็บ)
  • ตัวจัดการ: mcp_server/handlers/gurddy.py (การนำเครื่องมือไปใช้)
  • ตัวสร้างสกีมา: scripts/generate_registry.py (สร้างสกีมาจากลายเซ็นฟังก์ชันโดยอัตโนมัติ)

การเพิ่มเครื่องมือใหม่

  1. นำตัวจัดการไปใช้ ใน mcp_server/handlers/gurddy.py:

    def my_new_tool(param1: str, param2: int = 10) -> Dict[str, Any]:
    """Tool implementation with proper type hints."""
    return {"result": "success"}

  2. เพิ่มเมตาดาต้าพื้นฐาน ใน mcp_server/tool_definitions.py:

    {
    "name": "my_new_tool",
    "function": "my_new_tool",
    "description": "Description of what the tool does",
    "category": "optimization",
    "module": "handlers.gurddy"
}

  3. สร้างสกีมาและตรวจสอบ:

    # Auto-generate schemas from function signatures
python scripts/generate_registry.py

# Verify consistency
python scripts/verify_consistency.py
pytest tests/test_consistency.py -v

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

ข้อจำกัดแบบกำหนดเอง

# Define a custom constraint in gurddy
def custom_constraint(var1, var2):
    return var1 + var2 <= 10

model.addConstraint(gurddy.FunctionConstraint(custom_constraint, (var1, var2)))

การทดสอบ

# Run all tests
pytest

# Run specific test suites
pytest tests/test_consistency.py -v
pytest tests/test_tool_registry.py -v

# Verify tool registry consistency
python scripts/verify_consistency.py

ใบอนุญาต

โปรเจกต์นี้ได้รับอนุญาตภายใต้ใบอนุญาตโอเพนซอร์ส โปรดดูไฟล์ LICENSE สำหรับรายละเอียด