Skip to main content
Glama

Moltline Optimize

Validate Problem

validate_problem
Read-onlyIdempotent

Check a problem's shape and obvious feasibility before spending solver time. FREE.

Typical input {"type": "route", "problem": {"stops": [...], "matrix": [[...]], "vehicles": [...]}} returns {"ok": false, "issues": ["total demand 34 exceeds total capacity 30"], "size": {"stops": 14, "vehicles": 2}, "tier_hint": "route_plan_fleet (licence) - more than 12 stops"}. Types: route, pack, cut1d, cut2d, roster, knapsack; the problem object uses the same fields as the matching tool. Use first when an agent has assembled the problem from other data. Not a solve: it never calls the solver. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": ""} (for example {"error": "type must be one of "}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
typeYesroute, pack, cut1d, cut2d, roster or knapsack.
problemYesthe same object you would pass to the tool (stops/matrix/vehicles, items/containers, ...).

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. First observed

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint and idempotentHint, it discloses cost ('FREE'), the important invalid-input behavior (never raises a protocol error; returns an error object), and the guarantee that it does not invoke the solver. This is exactly the behavioral context an agent needs and goes well beyond annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Dense but well-organized: purpose, cost, typical request/response, type list, usage timing, non-solve guarantee, error contract, retry safety. Each sentence carries distinct information and key points are front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema exists and annotations cover safety, the description still supplies the missing operational context: how to interpret errors, that it is read-only/idempotent for retries, and how the problem object maps to sibling tools. Nothing an agent needs to call it correctly is absent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 100% schema coverage the baseline is 3, and the description adds genuinely useful meaning: 'problem' uses the same fields as the matching solver tool, and the typical-input example shows the nested shape for route. This exceeds baseline but does not need to enumerate every subtype.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific action ('check a problem's shape and obvious feasibility') on a clear resource, enumerates the accepted problem types, and explicitly differentiates itself from solver siblings with 'Not a solve: it never calls the solver.' An agent can immediately distinguish it from route_plan, pack_bins, etc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Directs agents to use it first when they have assembled a problem from other data and frames it as a pre-solve gate ('before spending solver time'). It says what it is not (not a solve) but does not name specific alternatives for when validation is unnecessary, though the sibling list makes the contrast clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

TDQS

A4.5/5.0
Disambiguation5/5

Each solver targets a distinct optimization domain (cutting, packing, routing, knapsack, rostering), and scale variants like pack_bins/pack_bins_large and route_plan/route_plan_fleet are explicitly differentiated by size/scope. Helper and meta tools (distance_matrix_haversine, validate_problem, explain_solution) are clearly separate from solve tools.

Naming Consistency4/5

Names are uniformly lowercase snake_case and organized into recognizable families such as cutting_stock_1d/2d, pack_bins/pack_bins_large, and route_plan/route_plan_fleet. The pattern is not strictly verb_object throughout—knapsack_select and distance_matrix_haversine are noun-first or descriptive—so there is minor inconsistency.

Tool Count5/5

With 11 tools, the server is well-scoped for an optimization toolkit: one core solver per problem type, a large-scale packer variant, a distance-matrix helper, and validation/explanation tools. Each tool has a clear role, and the count supports broad coverage without becoming bloated.

Completeness4/5

The server covers a complete solve-validate-explain workflow across major OR problem types—cutting, packing, routing, knapsack, and rostering. Minor gaps exist, such as pack_bins_large not being listed as recognized by explain_solution, and some features are explicitly documented exclusions rather than missing functionality.

Resources