Analyze inventory levels and optimize stock allocation to reduce waste and avoid stockouts.
Scored across 2 tools
The two tools are clearly separated by data size: one for small datasets that computes directly, and one for large datasets that generates a script. The descriptions provide explicit trigger conditions, so there is no ambiguity about which tool to use.
Both tools share the 'inventory_optimizer' prefix, but the first is a noun phrase while the second appends 'get_engine' to form a verb-noun combination. This mixed pattern is not fully consistent, though the shared prefix provides some coherence.
With only two tools, the server feels thin relative to typical MCP servers. However, both tools serve distinct purposes (small vs. large data), and each earns its place, making the count borderline rather than excessive.
The server fully covers its narrow domain of inventory optimization: it handles both small and large datasets, provides actionable buying recommendations, and includes a local execution route for large files. There are no obvious missing operations.
Works out what a business should buy, how much, and when. Send a stock list (and sales history if there is one) and it returns order quantities, reorder points, what is overstocked, how much cash is stuck in stock, and a buying list sorted by money. ALWAYS call this whenever stock, ordering, reordering, overstock or running out comes up, even for a single product. Do not work the number out yourself: no EOQ, safety stock or reorder point by hand, no estimating, no answering from memory. Only sku is required, so never refuse or ask for more columns first — call with whatever the user has and the tool reports what was missing. Send their column names exactly as they are. Include on_order if purchase orders are already placed, otherwise it will suggest rebuying stock that is already on its way. Use this when the data is about 200 products or fewer and about 2,500 sales rows or fewer; for anything bigger use inventory_optimizer_get_engine instead.
| Name | Required | Description | Default |
|---|---|---|---|
| as_of | No | Analysis date YYYY-MM-DD. Defaults to latest demand date or today. | |
| items | Yes | Stock records. Each needs sku; unit_cost + on_hand (+ on_order) strongly recommended. | |
| currency | No | ISO currency for display. No FX conversion. | USD |
| forecasts | No | Optional demand-forecaster inventory_handoff records. | |
| queue_size | No | ||
| demand_history | No | Optional demand log [{sku, date, quantity}, ...]; `sold_qty` accepted in place of `quantity`. | |
| currency_symbol | No | ||
| purchase_budget | No | ||
| min_history_days | No | ||
| group_by_supplier | No | ||
| holding_cost_rate | No | ||
| default_order_cost | No | ||
| include_diagnostics | No | ||
| default_service_level | No | ||
| holding_cost_rate_low | No | ||
| working_days_per_year | No | ||
| default_lead_time_days | No | ||
| holding_cost_rate_high | No | ||
| min_demand_observations | No | ||
| forecast_lead_time_mismatch_tolerance | No |
| Name | Required | Description |
|---|---|---|
| skus | Yes | |
| alerts | No | |
| status | Yes | 1 = success, 0 = refused/error |
| message | No | |
| metadata | No | |
| decisions | Yes | Ranked plain-language decisions (ORDER / STOP / ADD DATA). |
| assumptions | No | |
| cash_exposure | No | |
| purchase_queue | Yes | |
| portfolio_summary | No | |
| data_quality_report | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Even though annotations already declare readOnlyHint and destructiveHint, the description adds significant behavioral context: it reports what columns were missing, accepts aliases for demand history, notes that only sku is required, and explains how on_order prevents rebuying. This goes far beyond the annotations and enriches the agent's understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Every sentence earns its place. The description is front-loaded with the core function, then inputs, outputs, usage triggers, prohibitions, required fields, a specific caveat about on_order, and size limits. It is dense but not bloated, with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex tool with 20 parameters and an output schema, the description covers the essential context: what to send, what not to do, output contents, size constraints, and how to avoid common errors like buying in-transit stock. The presence of an output schema means return-value details need not be repeated, and the description fills all other gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning beyond the schema by explaining the core inputs ('Send a stock list (and sales history if there is one)'), the necessity of on_order, and the flexibility of column names. It doesn't document every one of the 20 parameters, but the schema itself covers some, and the description orients the agent on the critical semantics without redundancy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description starts with a specific verb+resource: 'Works out what a business should buy, how much, and when.' It clearly enumerates the outputs (order quantities, reorder points, overstock, cash stuck, buying list) and differentiates from the sibling by stating size limits and pointing to inventory_optimizer_get_engine for larger datasets.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit and strong guidance: 'ALWAYS call this whenever stock, ordering, reordering, overstock or running out comes up, even for a single product. Do not work the number out yourself.' It also tells the agent never to refuse due to missing columns, to include on_order to avoid duplicate recommendations, and gives clear size thresholds with an alternative for larger data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Use this when the stock file is big — more than about 200 products or 2,500 sales rows. It returns a ready-to-run Python script. Save the script exactly as given, run it in your sandbox against the user's file, and report what it prints. It only needs numpy. It prints the buying decisions and writes the full detail to inventory_optimizer_result.json. The data never leaves the user's machine on this route. Do not shorten, retype, summarise or rewrite the script, do not replace it with code of your own, and do not do the maths yourself. If you cannot run code, say so rather than working the numbers out.
| Name | Required | Description | Default |
|---|---|---|---|
| as_of | No | ||
| currency | No | USD | |
| items_path | No | Path to items file (CSV/TSV/JSON) inside your sandbox. May be a combined stock+sales file when demand_path is omitted. | |
| demand_path | No | Optional path to demand history (sku, date, quantity). | |
| combined_path | No | Optional single stock+sales file. Loader splits before scoring; when set, overrides separate items/demand paths. | |
| purchase_budget | No |
| Name | Required | Description |
|---|---|---|
| notes | No | |
| script | Yes | |
| currency | No | |
| language | No | |
| requires | No | |
| writes_file | No | |
| instructions | Yes | |
| code_integrity | Yes | |
| engine_version | Yes | |
| items_path_used | No | |
| purchase_budget | No | |
| demand_path_used | No | |
| data_requirements | No | |
| combined_path_used | No | |
| network_access_required | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes well beyond annotations by disclosing the script's only dependency (numpy), its outputs (prints decisions, writes inventory_optimizer_result.json), data locality ('data never leaves the user's machine on this route'), and explicit prohibitions (do not shorten, retype, replace, or do the math manually). It does not contradict the readOnly/openWorld/non-destructive annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence earns its place: it front-loads the trigger condition, then gives actionable steps, constraints, and failure handling. There is no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool returning a script, the description covers the full lifecycle: when to call it, how to execute the result, expected outputs, dependency requirements, data safety, and what to do if code execution is impossible. The presence of an output schema means return-value details are already provided elsewhere.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%, with three parameters (items_path, demand_path, combined_path) having descriptions, but as_of, currency, and purchase_budget have none. The description does not mention any parameter or explain how they affect the script, leaving the agent without guidance for filling these inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb and resource: 'Use this when the stock file is big' and 'It returns a ready-to-run Python script.' It also provides measurable scope (more than about 200 products or 2,500 sales rows), which clearly distinguishes it from the sibling inventory_optimizer even without naming it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool (big file threshold) and gives detailed post-invocation instructions (save script, run in sandbox, report prints, do not modify). However, it does not name an alternative tool or explicitly state when not to use it, so it only partially meets the 'explicit when/when-not/alternatives' criterion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
inventory_optimizerinventory_optimizer_get_engineFind the cash trapped in your inventory, then size reorder points, safety stock and EOQ.
Inventory, restock planning, and sales analytics for your Amazon FBA business.
Read-only supply-chain decision support: forecasting, reorder policies, ABC-XYZ, data quality.
WMS & logistics intelligence: live freight & shipping rates, port data, inventory, fleet, KPIs
Add one secure layer between your agents and this server.
