User guide

SupliiChain: Operator Manual

Everything you need to connect, run your first audit, wire up live store data, and understand what the gateway hands back. No dashboard required.

Quick start

Three steps, three minutes.

Connecting

Claude Code / Cursor / Windsurf / VS Code

These all read the same underlying MCP config, so one command covers all of them:

claude mcp add --transport http dpx https://dpx-mcp.vercel.app/api/mcp \
  --header "Authorization: Bearer <your-token>"

claude mcp list   # confirm it shows "Connected"

Claude Desktop

Add this to claude_desktop_config.json (Windows: %APPDATA%\Claude\claude_desktop_config.json), then restart:

{
  "mcpServers": {
    "dpx": {
      "type": "http",
      "url": "https://dpx-mcp.vercel.app/api/mcp",
      "headers": { "Authorization": "Bearer <your-token>" }
    }
  }
}

Look for the plug/tools icon in the chat bar to confirm SupliiChain's tools loaded.

Older Claude Desktop builds

"type": "http" only works on recent Claude Desktop versions. If the tools don't appear after a restart, your build may only speak stdio — use this mcp-remote bridge config instead (requires Node.js installed):

{
  "mcpServers": {
    "dpx": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://dpx-mcp.vercel.app/api/mcp",
               "--header", "Authorization: Bearer <your-token>"]
    }
  }
}

After any config change: fully quit Claude Desktop from the system tray (not just the window), reopen, and check for the plug icon. Still stuck? The logs live in %APPDATA%\Claude\logs\mcp*.log (Windows) or ~/Library/Logs/Claude/mcp*.log (Mac).

Any other MCP client

SupliiChain runs a standard MCP server over Streamable HTTP, not a Claude-only integration. Any client that speaks MCP connects the same way: point it at the URL below with your token as a Bearer header. That includes OpenAI's MCP tool connector today, and Gemini, Grok, Perplexity, or anything else as each platform adds MCP client support, since it's an open, published protocol.

Server URL:  https://dpx-mcp.vercel.app/api/mcp
Transport:   Streamable HTTP
Auth header: Authorization: Bearer <your-token>

Check your specific client's docs for the exact config syntax; this URL/header pair is all any of them need.

Edit the variables, add your own ask, copy, run.

Every playbook below is a real template: adjust the numbers to your business, fold in a custom request, and Claude runs the whole chain autonomously, calling every tool in sequence without stopping to ask permission between steps.

You'll see 4 starter workflows here, not 47. "The 47-Point Predictor" is the name of Playbook 1 specifically, named for the depth of its diagnostic, dozens of checks across ABC/XYZ classification, forecasting, lead-time variance, safety stock, and dead stock, layered with the 47-signal external demand model (economic indicators, weather, competitor pricing, social sentiment, seasonality). It's one deep workflow, not 47 separate prompts to run.

Work through this autonomously: call each tool in sequence without stopping to ask permission between steps. Only pause once, at the end, to present the results.

Execute a comprehensive supply chain diagnostic across our active SKU catalog:
1. Call run_abc_xyz_classification (lookbackDays: 90) to find our high-margin revenue drivers.
2. For all 'A' class SKUs, call run_time_series_forecast with modelType "AutoML_Ensemble", horizonDays 90.
3. Call calculate_forecast_error (metric "WMAPE", historicalPeriodDays 90) to validate confidence.
4. Call get_purchase_orders and calculate_lead_time_variance for the relevant supplier IDs.
5. Call calculate_safety_stock_drift (serviceLevelTarget 0.95) for the same SKUs.
6. Call identify_dead_stock (daysOfSupplyThreshold: 180).
Output a single "Operational Risk Matrix" table: SKU | Class | Stockout ETA | Safety Stock Drift | Trapped Capital ($) | Recommended Action.

Work through this autonomously: call each tool in sequence without stopping to ask permission between steps. Only pause once, at the end, to present the results.

Using today's safety stock drift results, for every SKU with a negative drift:
1. Calculate the deficit needed to reach 95% service level over the supplier's actual lead time.
2. Call draft_purchase_order with dryRun: true for the matching supplier.
Present line items, unit costs, and arrival windows for my review before I ask you to submit anything live.

Work through this autonomously: call each tool in sequence without stopping to ask permission between steps. Only pause once, at the end, to present the results.

Run a marketing-to-demand correlation check:
1. Call get_marketing_performance (lookbackDays: 30) across all channels.
2. Call calculate_demand_elasticity for our top 2 SKUs by revenue, independentVariable "ad_spend".
3. Call run_time_series_forecast with modelType "AutoML_Ensemble", horizonDays 30, includePromotions: true
   for the same SKUs, to see whether current spend trajectory is already priced into the forecast.
Render a Mermaid bar chart of spend vs. revenueAttributed by channel, then a markdown table with columns:
Channel | Spend | ROAS | CAC | Elasticity Read | Recommendation. Close with one paragraph: which channel
is under-invested relative to its demand lift, and which is past the point of diminishing returns.

Work through this autonomously: call each tool in sequence without stopping to ask permission between steps. Only pause once, at the end, to present the results.

Build a board-ready P&L snapshot:
1. Call calculate_pnl_impact_summary (stockoutHorizonDays: 30, daysOfSupplyThreshold: 180).
2. Call get_external_demand_signals (lookbackDays: 30) for seasonality_event and economic_indicator types,
   and flag anything landing inside the next 30 days.
Render a Mermaid pie chart of totalTrappedCapital vs. totalRevenueAtRisk, then a one-paragraph executive
summary a COO could read in 30 seconds: net exposure, the single biggest liquidation candidate, the single
biggest reorder priority, and any upcoming external signal that changes the picture. End with a markdown
table of the top 5 liquidation and top 5 reorder candidates so it can be copy-pasted straight into a
spreadsheet.

Playbooks 3 and 4 ask Claude to render a Mermaid chart (native inline rendering in Claude Desktop/claude.ai) alongside a markdown table, legible at a glance, and the table copy-pastes straight into a spreadsheet. For interactive charting and raw JSON/CSV export, use the console instead.

Reading the output

What the risk matrix columns mean.

Every tool response also carries a dataSource field ("live" or "synthetic") plus a plain-language note explaining which one answered. Claude is instructed to always say which one you're looking at rather than leave it buried in the JSON, and to attribute verified figures to the specific tool that produced them, separate from its own analysis and recommendations.

Live data

Connect your store. Same tools, your numbers.

Every tier starts on the deterministic sandbox catalog so you can prove the workflow risk-free. Connecting a real store swaps the numbers, not the tools: the schemas, playbooks, and prompts you already use stay identical.

Live today: get_stock_levels (real per-location on-hand, committed, available, and incoming quantities) and get_velocity_metrics (computed from your actual order history). In live mode, node names are your store's real locations. Analytics and forecasting tools continue running on the sandbox catalog and switch over as live coverage expands. Velocity windows are currently limited to your last 60 days of orders. Amazon Seller Central is next; other sources follow.

Advanced

Projects, Artifacts, and writing your own prompts.

Everything above runs in any regular chat. If you want a standing setup instead of ad-hoc conversations, everything below builds on the exact same connector and tools already documented on this page — nothing new to install.

Claude.ai Projects: a saved instance instead of ad-hoc chats

Add SupliiChain as a connector to a Project (Project settings → Connectors → Add custom connector), the same URL/token pair as any other client:

Server URL:  https://dpx-mcp.vercel.app/api/mcp
Auth header: Authorization: Bearer <your-token>

Then set the Project's own custom instructions to shape how Claude behaves every time inside it, without retyping anything. A starting template to copy and fill in:

You are our inventory intelligence copilot for <company name>.
Call get_started at the start of every conversation and report progress briefly.
Default service level target: 0.95. Default lead time buffer: <days>.
When asked about SKU health, run Playbook 1 (see /guide#playbooks) unless told otherwise.
Always separate verified tool output from your own recommendations.

SupliiChain has no way to detect it's running inside a Project specifically (no such context comes through per call) — anything Project-specific has to live in the Project's own instructions, not in the server.

Artifacts: a custom live view, where your account supports it

claude.ai's Artifacts can render an interactive page (a chart, a calculator, a small dashboard) inside a conversation. Some claude.ai environments let a published Artifact call your own connected MCP tools directly, so you can ask Claude to build one wired to live SupliiChain data instead of a static mockup. Example prompt:

Build an artifact: a bar chart of days-of-supply per SKU from get_stock_levels,
color-coded red under 14 days, with a refresh button that re-calls the tool.

Whether this works depends on your claude.ai environment supporting that capability, and needs SupliiChain already added as a connector on that account — same connector as above, no separate setup.

Writing your own prompt, not just the 4 built-in playbooks

The master playbooks above are starting points, not the ceiling. A custom prompt is just: pick which tools to chain, in what order, and how you want the output shaped. Skeleton:

Call <tool A> for <scope>.
Then call <tool B> using <tool A>'s output as input.
<Repeat as needed.>
Output as <a markdown table with columns ... / a Mermaid chart / plain text>.
Flag anything where <your specific threshold or condition>.

See /commands for the full tool list and what each one needs as input.

Autonomous agents, scripts, and multi-agent workflows

Console, Copilot, and Commands are all human-facing wrappers around one thing: the MCP endpoint at https://dpx-mcp.vercel.app/api/mcp, authenticated with your Bearer token. A script or an autonomous agent doesn't need any of them — connect directly with @modelcontextprotocol/sdk (or any MCP client), the exact same way Claude Desktop, Cursor, and Windsurf already do per the setup above.

Running more than one agent (say, a demand-planning agent and a separate marketing agent)? Give each its own token rather than sharing one. Tokens are the only thing tier-gating and usage tracking key off, so separate tokens mean separate usage counters and a clean way to tell which agent asked for what later.

One thing that's a permanent design decision, not a current limitation: the two write-capable tools (draft_purchase_order, reallocate_node_inventory) never auto-execute. Every call returns a costed preview, not a completed action, no matter who or what is calling. SupliiChain is built as a co-pilot that hands a human a fully-reasoned recommendation to approve in one click — not a black-box agent quietly cutting POs or moving inventory on its own. If your workflow needs the write to actually happen, that approval step belongs in your own orchestration layer; nothing here will skip it for you.

Security

What SupliiChain will and won't do.

Troubleshooting

Common issues.