CHUK MCP Solver Server

You can run and integrate a Production-ready MCP server that uses constraint solving to help with scheduling, routing, budgeting, and many other optimization tasks. This server enables you to solve complex problems with a simple API, work asynchronously, and scale with multiple solver strategies while preserving useful metadata and explanations for infeasibility or optimality.

How to use

You interact with the MCP server through a client that sends a well-formed solve request. The server supports high-level problem APIs (such as scheduling, routing, budgeting, and assignment) and also a general constraint solver. You choose a problem type, provide variables, constraints, and an objective, and the server returns the best feasible solution or the optimal solution along with timing, feasibility, and diagnostic information. Use the high-level APIs to avoid lower-level model details and still get structured results, explanations, and useful analytics.

To get started quickly, you can run a hosted endpoint or run a local instance. The hosted endpoint is ready for testing and demos, while the local option gives you full control and privacy. You can also run the MCP server locally via containerization for consistent environments.

How to install

Prerequisites: you need a recent Python runtime and a tool to install and run dependencies. You can also use the uvx helper for a streamlined, zero-install start.

1. Quick start with uvx (recommended) — run directly without installation:

uvx chuk-mcp-solver

2. Quick start with uvx — install as a package and then run locally:

uvx install chuk-mcp-solver

3. Public MCP endpoint — no installation needed for testing or demos.

https://solver.chukai.io/mcp

4. Install from Python package index (PyPI) — with pip or uv for speed:

pip install chuk-mcp-solver

uv pip install chuk-mcp-solver

5. Local development — clone the project and install development dependencies:

git clone https://github.com/chuk-ai/chuk-mcp-solver.git
cd chuk-mcp-solver
uv pip install -e ".[dev]"

Configuration and connection methods

You can connect your client to MCP servers using either a public HTTP endpoint or a local stdio setup. The HTTP endpoint is convenient for quick testing and demos, while the stdio setup lets you run the server on your machine for privacy and control.

# Public hosted endpoint (HTTP)
URL: https://solver.chukai.io/mcp

Local stdio configuration with uvx (recommended for full control):

{
  "mcpServers": {
    "solver": {
      "command": "uvx",
      "args": ["chuk-mcp-solver"]
    }
  }
}

Development mode with a local runner (alternative stdio setup) shows how to run from source using the uv tool:

{
  "mcpServers": {
    "solver": {
      "command": "uv",
      "args": ["run", "chuk-mcp-solver"],
      "cwd": "/path/to/chuk-mcp-solver"
    }
  }
}

Examples and usage patterns

The server exposes high-level APIs for scheduling, routing, budgeting, and assignment that automatically translate your request into a CP-SAT model. You can send a problem definition with variables, constraints, and an objective, and receive an answer with status, objective value, and a detailed schedule or route. The server also provides helpful validation and error messages to guide you when a model is invalid.

Common workflows include solving project schedules with resource constraints, optimizing delivery routes for fleets, selecting portfolios under budget and dependencies, and assigning tasks to agents while balancing workload. You can also run a generic constraint model when you need more control or when solving non-scheduling problems.

Notes on programmatic usage and API focus

You can programmatically submit problems using a structured request model. The solver can return the best feasible solution, the optimal solution, or a partial solution if time limits are reached. Results include the status, objective value, solution values for each variable, and explanations of feasibility or infeasibility.

If you want to explore scheduling problems, routing problems, budget allocations, or task assignments, there are high-level APIs designed to simplify these tasks and return rich results, including critical paths, resource utilization, and load timelines.

Security and reliability notes

Run the solver in a protected environment when handling sensitive data. Enable warm starts and deterministic solving by providing a fixed random seed when you need reproducibility. The server supports asynchronous operation and provides robust error handling and diagnostics to help you understand infeasibilities.

Troubleshooting and tips

If you encounter timeouts, you can request partial solutions to see the best solution found within the time limit. Check the validation messages for suggestions to fix typos or undefined variables in your model. Use the caching features to avoid repeating identical problems.

Available tools

solve_constraint_model

Solve a general constraint or optimization model by specifying variables, constraints, and an objective. Supports multiple constraint types and search configurations.

solve_scheduling_problem

High-level API for scheduling problems that builds a CP-SAT model from tasks, resources, dependencies, and deadlines, returning a schedule and makespan.

solve_routing_problem

High-level API for routing problems (TSP/VRP) with locations, vehicles, and distance matrices, returning routes and total distance/cost.

solve_budget_allocation

High-level API for budget allocation and knapsack-like problems with dependencies and conflicts across multiple resources.

solve_assignment_problem

High-level API for assigning tasks to agents with skills, capacity, and cost considerations.