gurddy mcp

आधिकारिक

यह रिपॉजिटरी एक पूर्णतः कार्यात्मक MCP (मॉडल कॉन्टेक्स्ट प्रोटोकॉल) सर्वर है, जो कंस्ट्रेंट सैटिस्फैक्शन प्रॉब्लम्स (CSP) और लीनियर प्रोग्रामिंग (LP) के समाधान प्रदान करता है। यह gurddy पैकेज पर आधारित है और विभिन्न प्रकार की क्लासिक समस्याओं को हल करने में सहायता करता है।

GitHub
2

Gurddy MCP के साथ आप क्या कर सकते हैं?

  • किसी भी बोर्ड आकार के लिए N-Queens हल करें — अपने AI से N×N बोर्ड पर बिना हमले के N रानियाँ रखने के लिए कहें, solve_n_queens का उपयोग करें।
  • सुडोकू पहेलियाँ हल करें — खाली स्थानों के लिए शून्य वाला 9×9 ग्रिड प्रदान करें और solve_sudoku के माध्यम से पूर्ण हल प्राप्त करें।
  • उत्पादन योजनाओं को अनुकूलित करें — संसाधन बाधाओं और वैकल्पिक संवेदनशीलता विश्लेषण के साथ उत्पादों में लाभ को अधिकतम करें, solve_production_planning का उपयोग करें।
  • शून्य-योग खेलों में नैश संतुलन खोजें — solve_minimax_game का उपयोग करके रॉक-पेपर-सीज़र्स जैसे दो-खिलाड़ी खेलों के लिए इष्टतम मिश्रित रणनीतियाँ गणना करें।
  • 24-पॉइंट गेम हल करें — चार दिए गए संख्याओं से 24 मान देने वाले अंकगणितीय व्यंजक खोजें, solve_24_point_game का उपयोग करें।
  • SciPy के साथ निवेश पोर्टफोलियो को अनुकूलित करें — solve_scipy_portfolio_optimization के माध्यम से माध्य-विचरण अनुकूलन का उपयोग करके जोखिम-समायोजित प्रतिफल को अधिकतम करें।

दस्तावेज़

Gurddy MCP सर्वर

PyPI version Python Support License: MIT Live Demo

प्रतिबंध संतुष्टि समस्याओं (CSP), रैखिक प्रोग्रामिंग (LP), मिनिमैक्स अनुकूलन, और SciPy-संचालित उन्नत अनुकूलन समस्याओं को हल करने के लिए एक व्यापक मॉडल संदर्भ प्रोटोकॉल (MCP) सर्वर। SciPy एकीकरण के साथ gurddy अनुकूलन लाइब्रेरी पर निर्मित, यह दो 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-रानी समस्या: N रानियों को N×N शतरंज बोर्ड पर बिना किसी हमले के रखें
  • ग्राफ रंगाई: शीर्षों को रंग असाइन करें ताकि आसन्न शीर्ष भिन्न हों
  • मानचित्र रंगाई: भौगोलिक क्षेत्रों को रंगें जहाँ आसन्न क्षेत्र भिन्न हों
  • सुडोकू सॉल्वर: मानक 9×9 सुडोकू पहेलियाँ हल करें
  • तर्क पहेलियाँ: आइंस्टीन की ज़ेबरा पहेली और कस्टम तर्क समस्याएं
  • शेड्यूलिंग: पाठ्यक्रम शेड्यूलिंग, बैठक शेड्यूलिंग, संसाधन आवंटन
  • सामान्य CSP सॉल्वर: कस्टम प्रतिबंध संतुष्टि समस्याओं के लिए समर्थन

📊 LP/अनुकूलन समस्याएं

  • रैखिक प्रोग्रामिंग: रैखिक प्रतिबंधों के साथ सतत चर अनुकूलन
  • मिश्रित पूर्णांक प्रोग्रामिंग: पूर्णांक और सतत चर के साथ अनुकूलन
  • उत्पादन योजना: संवेदनशीलता विश्लेषण के साथ संसाधन-प्रतिबंधित उत्पादन अनुकूलन
  • पोर्टफोलियो अनुकूलन: जोखिम प्रतिबंधों के तहत निवेश आवंटन
  • परिवहन समस्याएं: आपूर्ति श्रृंखला और रसद अनुकूलन

🎮 मिनिमैक्स/खेल सिद्धांत

  • शून्य-योग खेल: दो-खिलाड़ी खेल हल करें (रॉक-पेपर-सिज़र्स, मैचिंग पेनीज़, लिंगों की लड़ाई)
  • मिश्रित रणनीति नैश संतुलन: इष्टतम संभाव्य रणनीतियाँ खोजें
  • मजबूत अनुकूलन: अनिश्चितता के तहत सबसे खराब स्थिति के नुकसान को कम करें
  • मैक्सिमिन निर्णय: सबसे खराब स्थिति के लाभ को अधिकतम करें (रूढ़िवादी रणनीतियाँ)
  • सुरक्षा खेल: रक्षक-हमलावर संसाधन आवंटन
  • मजबूत पोर्टफोलियो: बाजार परिदृश्यों में अधिकतम हानि को कम करें
  • उत्पादन योजना: रूढ़िवादी उत्पादन निर्णय (न्यूनतम लाभ को अधिकतम करें)
  • विज्ञापन प्रतियोगिता: बाजार हिस्सेदारी खेल और प्रतिस्पर्धी रणनीतियाँ

🔬 SciPy एकीकरण

  • अरैखिक पोर्टफोलियो अनुकूलन: SciPy अनुकूलन के साथ द्विघात जोखिम मॉडल
  • सांख्यिकीय पैरामीटर अनुमान: प्रतिबंधों के साथ वितरण फिटिंग (MLE, मात्रात्मक मिलान)
  • सिग्नल प्रोसेसिंग अनुकूलन: आवृत्ति प्रतिक्रिया अनुकूलन के साथ FIR फ़िल्टर डिज़ाइन
  • हाइब्रिड CSP-SciPy: असतत सुविधा चयन + सतत क्षमता अनुकूलन
  • संख्यात्मक एकीकरण: समाकलन और जटिल फलनों से जुड़ी अनुकूलन समस्याएं

🧮 क्लासिक गणित समस्याएं

  • 24-पॉइंट गेम: चार संख्याओं का उपयोग करके 24 तक पहुँचने के लिए अंकगणितीय व्यंजक खोजें
  • मुर्गी-खरगोश समस्या: सिर और पैरों के साथ क्लासिक प्रतिबंध समस्या
  • मिनी सुडोकू: CSP तकनीकों का उपयोग करके 4×4 सुडोकू सॉल्वर
  • 4-रानी समस्या: शैक्षिक उद्देश्यों के लिए सरलीकृत N-रानी
  • 0-1 नैपसैक: वजन और मूल्य प्रतिबंधों के साथ क्लासिक अनुकूलन समस्या

🔌 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 का उपयोग क्यों करें?

  • ✅ हमेशा नवीनतम प्रकाशित संस्करण स्वचालित रूप से चलाता है
  • ✅ कोई मैन्युअल स्थापना या उन्नयन की आवश्यकता नहीं
  • ✅ प्रति निष्पादन पृथक वातावरण
  • ✅ आपके सिस्टम 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: सीधे कमांड का उपयोग करना (स्थापना के बाद)

यदि आपने पहले से ही pip के माध्यम से gurddy-mcp स्थापित किया है:

{
  "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-रानी समस्या हल करें
  • solve_sudoku - CSP का उपयोग करके 9×9 सुडोकू पहेलियाँ हल करें
  • solve_graph_coloring - विन्यास योग्य रंगों के साथ ग्राफ रंगाई हल करें
  • solve_map_coloring - मानचित्र रंगाई समस्याएँ हल करें (जैसे, ऑस्ट्रेलिया, USA)
  • solve_lp - रैखिक प्रोग्रामिंग (LP) या मिश्रित पूर्णांक प्रोग्रामिंग (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 सर्वर

HTTP MCP सर्वर प्रारंभ करें (स्ट्रीम करने योग्य HTTP पर MCP प्रोटोकॉल):

स्थानीय विकास:

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

डॉकर:

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

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

सर्वर तक पहुँचें:

HTTP MCP सर्वर का परीक्षण करें:

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-रानी समस्या हल करें।

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

solve_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

PuLP का उपयोग करके एक रैखिक प्रोग्रामिंग (LP) या मिश्रित पूर्णांक प्रोग्रामिंग (MIP) समस्या हल करें।

{
  "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

मिनिमैक्स (खेल सिद्धांत) का उपयोग करके दो-खिलाड़ी शून्य-योग खेल हल करें।

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

निर्दिष्ट खिलाड़ी के लिए इष्टतम मिश्रित रणनीति और खेल मूल्य लौटाता है।

solve_minimax_decision

अनिश्चितता के तहत एक मिनिमैक्स निर्णय समस्या हल करें (मजबूत अनुकूलन)।

{
  "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
  }
}

माध्य-विचरण अनुकूलन का उपयोग करके जोखिम दंड घटाकर प्रतिफल को अधिकतम करने के लिए पोर्टफोलियो भार का अनुकूलन करता है।

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) के साथ जोड़ता है।

डॉकर परिनियोजन

बिल्ड और चलाएँ

# 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

डॉकर कम्पोज़

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

उदाहरण आउटपुट

N-रानी समस्या

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-mcpstdin/stdout पर MCPIDE एकीकरण (Kiro, Claude Desktop, आदि)
स्ट्रीम करने योग्य HTTPuvicorn mcp_server.mcp_http_server:appवैकल्पिक स्ट्रीमिंग के साथ HTTP पर MCPवेब क्लाइंट, दूरस्थ पहुँच, डॉकर परिनियोजन

सभी परिवहन समान MCP प्रोटोकॉल लागू करते हैं और समान उपकरण प्रदान करते हैं।

HTTP परिवहन सुविधाएँ

HTTP परिवहन (/mcp/http एंडपॉइंट):

  • एकल अनुरोध-प्रतिक्रिया पैटर्न
  • वैकल्पिक स्ट्रीमिंग: Accept: text/event-stream या X-Stream: true हेडर जोड़ें
  • एकबारगी अनुरोधों के लिए सरल
  • मानक HTTP क्लाइंट के साथ संगत
  • प्रबंधित करने के लिए कोई कनेक्शन स्थिति नहीं
  • नियमित JSON प्रतिक्रियाओं और SSE-स्वरूपित स्ट्रीमिंग प्रतिक्रियाओं दोनों का समर्थन करता है

उदाहरण आउटपुट

N-रानी समस्या

$ 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-रानी समस्या

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-रानी समस्या (दृश्य बोर्ड प्रदर्शन के साथ 4, 6, 8 रानियाँ)
  • graph_coloring - ग्राफ रंगाई (त्रिभुज, वर्ग, पीटरसन ग्राफ, पहिया ग्राफ)
  • map_coloring - मानचित्र रंगाई (ऑस्ट्रेलिया, USA पश्चिमी राज्य, यूरोप)
  • scheduling - शेड्यूलिंग समस्याएं (पाठ्यक्रम शेड्यूलिंग, बैठक शेड्यूलिंग, संसाधन आवंटन)
  • logic_puzzles - तर्क पहेलियाँ (सरल तर्क पहेली, आइंस्टीन की ज़ेबरा पहेली)
  • optimized_csp - उन्नत CSP तकनीकें (सुडोकू सॉल्वर)

LP उदाहरण ✅

  • lp / optimized_lp - रैखिक प्रोग्रामिंग उदाहरण:
    • जोखिम प्रतिबंधों के साथ पोर्टफोलियो अनुकूलन
    • परिवहन समस्या (आपूर्ति श्रृंखला अनुकूलन)
    • प्रतिबंध शिथिलन विश्लेषण
    • समस्या आकारों में प्रदर्शन तुलना

मिनिमैक्स उदाहरण ✅

  • minimax - मिनिमैक्स अनुकूलन और खेल सिद्धांत:
    • रॉक-पेपर-सिज़र्स (शून्य-योग खेल)
    • मैचिंग पेनीज़ (समन्वय खेल)
    • लिंगों की लड़ाई (मिश्रित रणनीति संतुलन)
    • मजबूत पोर्टफोलियो अनुकूलन (अधिकतम हानि कम करें)
    • उत्पादन योजना (न्यूनतम लाभ अधिकतम करें)
    • सुरक्षा संसाधन आवंटन (रक्षक-हमलावर खेल)
    • विज्ञापन प्रतियोगिता (बाजार हिस्सेदारी खेल)

SciPy एकीकरण उदाहरण ✅

  • scipy_optimization - SciPy के साथ उन्नत अनुकूलन:
    • द्विघात जोखिम मॉडल के साथ अरैखिक पोर्टफोलियो अनुकूलन
    • सांख्यिकीय पैरामीटर अनुमान (बाधाओं के साथ वितरण फिटिंग)
    • सिग्नल प्रोसेसिंग अनुकूलन (FIR फ़िल्टर डिज़ाइन)
    • हाइब्रिड CSP-SciPy सुविधा स्थान (असतत + सतत अनुकूलन)
    • अनुकूलन उद्देश्यों में संख्यात्मक समाकलन

क्लासिक गणित समस्याएं ✅

  • classic_problems - शैक्षिक गणित समस्या समाधान:
    • 24-पॉइंट गेम (24 तक पहुँचने के लिए अंकगणितीय व्यंजक)
    • मुर्गी-खरगोश समस्या (क्लासिक बाधा संतुष्टि)
    • 4×4 मिनी सुडोकू (सरलीकृत CSP प्रदर्शन)
    • 4-रानी समस्या (शैक्षिक N-रानी संस्करण)
    • 0-1 नैपसैक समस्या (क्लासिक अनुकूलन)

समर्थित समस्या प्रकार

🧩 CSP समस्याएं

  • N-रानी: किसी भी बोर्ड आकार के लिए क्लासिक N-रानी समस्या (N=4 से N=100+)
  • ग्राफ रंगाई: मनमाने ग्राफ के लिए शीर्ष रंगाई (त्रिभुज, पीटरसन, पहिया, आदि)
  • मानचित्र रंगाई: भौगोलिक क्षेत्र रंगाई (ऑस्ट्रेलिया, USA, यूरोप मानचित्र)
  • सुडोकू: बाधा प्रसार के साथ मानक 9×9 सुडोकू पहेलियाँ
  • तर्क पहेलियाँ: आइंस्टीन की ज़ेबरा पहेली और कस्टम तार्किक तर्क समस्याएं
  • शेड्यूलिंग: पाठ्यक्रम शेड्यूलिंग, बैठक कक्ष, समय बाधाओं के साथ संसाधन आवंटन

📈 अनुकूलन समस्याएं

  • रैखिक प्रोग्रामिंग: रैखिक बाधाओं के साथ सतत चर अनुकूलन
  • पूर्णांक प्रोग्रामिंग: असतत चर अनुकूलन (उत्पादन मात्रा, असाइनमेंट)
  • मिश्रित पूर्णांक प्रोग्रामिंग: संयुक्त सतत और असतत चर
  • उत्पादन योजना: बहु-उत्पाद संसाधन-बाधित अनुकूलन
  • पोर्टफोलियो अनुकूलन: जोखिम और रिटर्न बाधाओं के साथ निवेश आवंटन
  • परिवहन: आपूर्ति श्रृंखला अनुकूलन (गोदामों से ग्राहकों तक)

🎲 खेल सिद्धांत और मजबूत अनुकूलन

  • शून्य-योग खेल: रॉक-पेपर-सिज़र्स, मैचिंग पेनीज़, लिंगों की लड़ाई
  • मिश्रित रणनीति नैश संतुलन: दोनों खिलाड़ियों के लिए इष्टतम संभाव्य रणनीतियाँ
  • मिनिमैक्स निर्णय: अनिश्चितता परिदृश्यों में सबसे खराब स्थिति के नुकसान को कम करें
  • मैक्सिमिन निर्णय: सबसे खराब स्थिति के लाभ को अधिकतम करें (रूढ़िवादी रणनीतियाँ)
  • मजबूत पोर्टफोलियो: बाजार परिदृश्यों में अधिकतम हानि को कम करें
  • सुरक्षा खेल: रक्षक-हमलावर संसाधन आवंटन समस्याएं

🔬 SciPy-संचालित उन्नत अनुकूलन

  • अरैखिक पोर्टफोलियो अनुकूलन: शार्प अनुपात अधिकतमकरण के साथ द्विघात जोखिम मॉडल
  • सांख्यिकीय पैरामीटर अनुमान: बाधाओं के साथ MLE और मात्रक-आधारित वितरण फिटिंग
  • सिग्नल प्रोसेसिंग: आवृत्ति प्रतिक्रिया अनुकूलन के साथ FIR फ़िल्टर डिज़ाइन
  • हाइब्रिड अनुकूलन: Gurddy CSP को SciPy सतत अनुकूलन के साथ संयोजित करें
  • संख्यात्मक समाकलन: जटिल गणितीय फलनों से जुड़ी अनुकूलन समस्याएं

🧮 क्लासिक शैक्षिक समस्याएं

  • 24-पॉइंट गेम: 24 तक पहुँचने के लिए चार संख्याओं का उपयोग करके अंकगणितीय व्यंजक खोजें
  • मुर्गी-खरगोश समस्या: सिर और पैरों के साथ क्लासिक बाधा संतुष्टि
  • मिनी सुडोकू: CSP तकनीकों का उपयोग करके 4×4 सुडोकू हल करना
  • N-रानी संस्करण: क्लासिक समस्या के शैक्षिक संस्करण
  • नैपसैक समस्याएं: वजन और मूल्य बाधाओं के साथ 0-1 नैपसैक अनुकूलन

प्रदर्शन सुविधाएँ

  • तेज़ समाधान: छोटी-मध्यम समस्याओं के लिए मिलीसेकंड प्रतिक्रिया (N-रानी N≤12, <50 शीर्षों वाले ग्राफ)
  • स्केलेबल: बड़ी समस्याओं को संभालता है (N-रानी N=100+, 1000+ चरों वाला LP)
  • मेमोरी कुशल: बैकट्रैकिंग खोज और बाधा प्रसार मेमोरी उपयोग को कम करते हैं
  • विस्तारणीय: कस्टम बाधाएं, उद्देश्य फलन और समस्या प्रकार
  • समवर्ती-सुरक्षित: HTTP API समवर्ती अनुरोध प्रसंस्करण का समर्थन करता है
  • उत्पादन के लिए तैयार: डॉकर परिनियोजन, स्वास्थ्य जांच, त्रुटि प्रबंधन

प्रदर्शन बेंचमार्क

मानक हार्डवेयर पर सामान्य निष्पादन समय:

  • CSP उदाहरण: 0.4-0.5s (N-रानी, ग्राफ रंगाई, तर्क पहेलियाँ)
  • LP उदाहरण: 0.8-0.9s (पोर्टफोलियो, परिवहन, उत्पादन योजना)
  • मिनिमैक्स उदाहरण: 0.3-0.5s (खेल हल करना, मजबूत अनुकूलन)
  • SciPy उदाहरण: 0.5-1.2s (अरैखिक अनुकूलन, सांख्यिकीय फिटिंग)
  • क्लासिक समस्याएं: 0.1-0.3s (24-पॉइंट, मुर्गी-खरगोश, मिनी सुडोकू)
  • सुडोकू: मानक 9×9 पहेलियों के लिए <0.1s
  • बड़ी N-रानी: N=100 के लिए ~2-3s

समस्या निवारण

सामान्य त्रुटियाँ

  • "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 उदाहरण शामिल हैं:

  • अरैखिक पोर्टफोलियो अनुकूलन: शार्प अनुपात अधिकतमकरण के साथ द्विघात जोखिम मॉडल
  • सांख्यिकीय पैरामीटर अनुमान: 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 फ़ाइल देखें।