ModelRisk MCP
OfficialModelRisk MCP is an open MCP server that turns any MCP client (Claude Desktop/Code, Cursor, Zed) into a methodology-aware co-pilot for building, running, analyzing, auditing, and reporting on Vose ModelRisk Monte Carlo models in Excel from a conversation.
Read/inspect workbooks — list open/active workbooks, open/close/save workbooks, read cells and ranges, summarize workbook structure, list VoseInputs, VoseOutputs, distributions, and find hard-coded candidate inputs.
Build models — insert validated Vose distribution formulas, wrap cells as inputs/outputs, replace constants with distributions, write arbitrary formulas, set named ranges, and build aggregates (FFT/Panjer/MC), risk events, time series, and copulas.
Fit from data — fit and rank distributions, copulas, and time-series models by AIC/SIC/HQIC; fit extreme-value/GPD tails; and wire fitted marginals + copula into a correlated, simulation-ready model in one pass.
Run simulations — trigger classic or Turbo ModelRisk simulation runs with fixed seed and iteration control, save
.vmrsresults, and sweep a single input across scenario values (what-if analysis).Analyze results — read per-output statistics and percentiles, raw per-iteration samples, correlation matrices, tornado/sensitivity rankings, VaR/CVaR tail risk, distribution comparisons, backtests against actuals, epistemic/aleatory uncertainty decomposition, and reverse stress tests.
Compute analytically — evaluate distribution properties (pdf/cdf/exceedance/quantile/moments/summary) without running a simulation.
Audit and plan — run the Vose methodology + spreadsheet-integrity audit rules, diagnose workbook health, and generate an ordered risk-model conversion plan.
Report and chart — generate executive summaries, build executive and uncertainty-driver reports, and persist tornado, histogram, and CDF charts as native Excel sheets.
Manage VMRS files — list variables, read results directly from a
.vmrs, and pin a specific file as the active results source.Recover safely — restore cells from the audit log, and restore a workbook left in a frozen-sample state.
Stay safe by design — every write defaults to
dry_run=True, lands in Excel's undo stack, is logged, refuses to overwrite non-Vose formulas (except by design), guards bulk writes, supports--read-only, uses a single-writer mutex, and never auto-saves.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ModelRisk MCP Run a Monte Carlo simulation on Sheet1 and show me the 95th percentile of profit."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ModelRisk MCP
An open Model Context Protocol server for Vose Software's ModelRisk.
Use it with Claude Desktop, Claude Code, Cursor, Zed, or any MCP-compliant client to read, build, fit, and run Monte Carlo risk models in Excel from a conversation.
ModelRisk MCP is an open MCP server on the standard Anthropic Model Context Protocol. No proprietary layer, no lock-in. The 1417-entry function catalogue, the Vose methodology principles, and the audit rule set are all included in the package — and editable.
Stable: 0.4.5 — on the mcp 2.0 SDK; the server starts ModelRisk itself when no Excel is running (auto-launch + add-in activation); programmatic simulation via run_simulation (XLL command surface, no fragile COM dispatch); .vmrs results read via the official ModelRisk SDK, with an automatic in-session fallback when MRService.dll is absent; activation ships bundled so no environment configuration is required. 59 tools across reading, building, fitting, simulation, scenario-sweep, restore, charting, audit, a quantitative analysis & decision layer (distribution calculator, tail risk, fit-and-rank, fast aggregates, correlation matrix, copula & time-series fitting, distribution comparison, backtest, uncertainty decomposition, reverse stress test), and workflow surfaces.
Purpose
Monte Carlo risk modelling is the right way to reason about an uncertain future — and almost nobody does it.
The mathematics has been settled for decades: when your inputs are uncertain, you don't reason with a single "best guess" number, you reason with the distribution of outcomes. A point estimate ("Q3 revenue will be $4.2M") hides exactly the thing a decision-maker needs to know — how wrong could it be, how bad is the downside, which assumption is driving the risk. ModelRisk has given Excel users a rigorous, validated engine for this for years.
The barrier was never the maths. It was the friction:
The discipline carries a real skill curve — 1,400+ functions, the right distribution family for each input, the methodology traps (fit without parameter uncertainty, correlations ignored, risk events modelled as
p × impact) that quietly produce confident-but-wrong answers.Setting a model up by hand is slow and fiddly — wrapping inputs, naming outputs, wiring copulas and time-series, formatting the report.
So under deadline pressure, most teams fall back to a single-point spreadsheet and a gut-feel range. The rigorous tool sits unused.
This server removes that friction. Large language models can now drive domain tools through the open Model Context Protocol. ModelRisk MCP puts the whole ModelRisk surface — build, fit, simulate, audit, interpret — behind a conversation. You describe the problem in plain language; Claude proposes the right distributions, wires the structure, runs the simulation, reads the tail, and writes the report. The expertise moves into the loop; the friction drops to a sentence.
It is built on five deliberate principles:
Open, not locked-in. A server on the standard Anthropic MCP — works with Claude Desktop, Claude Code, Claude for Excel, Cursor, Zed, and any compliant client. MIT-licensed. The function catalogue, methodology, and audit rules ship in the package and are editable. No proprietary connector, no vendor cage.
Methodology-grounded, not just mechanically capable. The server is opinionated about correct practice. Fits default to
uncertainty=TRUE; risk events use the bimodalVoseRiskEvent; the 13-rule audit encodes the mistakes Vose practitioners have seen across decades of consulting. It won't just do what you ask — it'll steer you toward what's right.Local-only, no telemetry. Everything runs on your machine against your Excel and your ModelRisk install. No data leaves your computer; the activation key is bundled and offline.
Excel stays the model. No re-platforming, no shadow tooling. The workbook is the model — versionable in Git, openable by anyone with Excel + ModelRisk, reproducible by re-running one tool call.
Safe by design. Every write previews first (
dry_run=True), lands in Excel's undo stack, and is logged. The server can modify your workbook — and does so under nine layered safeguards (see Safety by design).
The goal is simple: make defensible, quantitative risk analysis something you reach for by default — because it's now no harder than asking.
Related MCP server: excel-mcp-server
What this does
This server turns Claude (or any MCP client) into a methodology-aware co-pilot for ModelRisk. It can:
Build new Monte Carlo models from a description — insert distributions, fit families to data, build aggregates, copulas, time-series, risk events.
Run simulations from the conversation.
run_simulationtriggers the same XLL command the ribbon "Simulate" button uses, blocks until the run finishes, saves a.vmrsnext to the workbook, and auto-pins it as the results source.engine="turbo"runs ModelRisk's Turbo engine instead, after the engine's own check of the workbook, and falls back to the classic engine when Turbo cannot run it.Read model structure and per-iteration results — inputs, outputs, percentiles, correlation matrices, tornado rankings — directly from
.vmrsfiles via ModelRisk's official SDK (MRService.dll). No COM dispatch fragility.Audit a workbook against Vose's methodology rules and propose fixes.
Interpret results into structured executive summaries with contingency analysis.
Every formula written to Excel is validated against the ModelRisk function catalogue first — there's no path to a hallucinated function name reaching your workbook.
See the user manual for a walkthrough of the nine things you can do, a realistic end-to-end example, and what the server explicitly does and doesn't do. New to Monte Carlo or to the ModelRisk MCP toolchain? Start with the 15-minute quick-start tutorial, then pick a walk-through scenario matching your problem (budgets, data fitting, loss aggregation, correlated inputs, stress tests, model audits); unfamiliar with a term, see the glossary.
Feature comparison
Capability | ModelRisk MCP | Closed alternatives |
Read model structure (inputs, outputs, distributions) | ✓ | ✓ |
Read simulation results, percentiles, sensitivity | ✓ | ✓ |
Insert distributions into cells | ✓ | — |
Fit distributions from data | ✓ | — |
Build aggregate (frequency × severity) models | ✓ | — |
Build copulas / correlated inputs | ✓ | — |
Build time-series stochastic processes | ✓ | — |
Run simulations from the conversation | ✓ | — |
Audit model for common methodology mistakes | ✓ | — |
Works with Claude Desktop / Code / Cursor / Zed / any MCP client | ✓ | — |
Open source, MIT licensed | ✓ | — |
Local-only, no telemetry | ✓ | varies |
Default-safe (dry-run preview before every write) | ✓ | n/a |
Install
Prerequisites
Windows 10 or 11, 64-bit
Excel 2019 or newer with the ModelRisk add-in installed and loaded — the latest ModelRisk from vosesoftware.com is recommended: the current release includes MRService.dll, which the results-reading tools need (installers up to 9.1.x did not ship it)
One of:
Python 3.11+ (recommended via
uv)Or the standalone
modelrisk-mcp.exefrom the latest release — no Python knowledge required
Activation (results reading): None required — MRService.dll (the SDK that reads .vmrs files) ships with the current ModelRisk release and is activated automatically by a bundled offline key. If the server reports "MRService.dll not found", update ModelRisk to the latest version from vosesoftware.com — installers up to 9.1.x did not include the DLL. Two env overrides exist for non-standard setups (both only affect reading .vmrs results; simulations run regardless):
MRSERVICE_DLL_PATH— full path to an MRService.dll if it isn't in the standard ModelRisk folder. Must be version 7.3.2.1 or newer (the bundled key covers 7.3.2.1–9.2.2.1); older copies shipped with other Vose products (e.g. Tamara's 7.1.x) are too old and are rejected with a version diagnosis. Its sibling DLLs resolve from that folder, so point at it in place.MRSERVICE_ACTIVATION_KEY— your own activation key, to override the bundled one for any MRService version.
Recommended: auto-wire from PyPI
pip install modelrisk-mcp
modelrisk-mcp install # adds the server to every MCP app it findsThen restart the apps it lists. modelrisk-mcp install finds Claude Desktop (including the Microsoft Store build), Claude Code, Cursor, VS Code, Windsurf, Gemini CLI and LM Studio, backs up each settings file and adds the server beside anything already there. modelrisk-mcp status shows where each app stands; --client cursor (repeatable) limits install or uninstall to the apps you name. (Excel + a licensed ModelRisk add-in are still required — that's the product itself.)
One-click .mcpb (Claude Desktop Extension)
Download modelrisk-mcp.mcpb from the latest release, open it (Claude Desktop → Settings → Extensions → Install Extension…), then restart Claude. The bundle ships the server as a standalone exe — no Python, no config edit.
⚠️ Known issue (Claude Desktop, latest Windows MSIX builds, e.g. 1.12603.x): the Extensions installer can silently do nothing when you pick a
.mcpb— no error, no install. This is a Claude Desktop installer bug (it fails before logging), not a problem with the bundle (it validates withmcpband installs fine once the client is fixed). Until Anthropic patches it, use thepip install+modelrisk-mcp installpath above — it bypasses the Extensions UI entirely.
From PyPI
pip install modelrisk-mcpFrom source
git clone https://github.com/vosesoftware/modelrisk-mcp
cd modelrisk-mcp
uv sync
uv run python -m modelrisk_mcp # speaks MCP over stdioStandalone .exe
Download modelrisk-mcp.exe from Releases, drop it where you want to keep it, then run .\modelrisk-mcp.exe install from a terminal in that folder. It registers that exe, at that path, with Claude Desktop and Claude Code (0.4.1 and later; older exes wrote an entry that could not start). To wire it by hand instead, see docs/claude-desktop.md.
Wire into Claude Desktop
Three options, simplest first.
One-command auto-wire (recommended)
pip install modelrisk-mcp
modelrisk-mcp installmodelrisk-mcp install detects every installed MCP client (Claude Desktop, Claude Code), backs up its existing config, and adds the modelrisk server entry — preserving any other servers you already have configured. Output looks like:
+ Claude Desktop added C:\Users\you\AppData\Roaming\Claude\claude_desktop_config.json
Registered 'modelrisk' -> {'command': 'C:\\...\\Scripts\\modelrisk-mcp.exe'}
backup: ...claude_desktop_config.json.bak.20260521-153000
Restart Claude Desktop / Claude Code to pick up the new server.To undo: modelrisk-mcp uninstall. To register a second instance with a different name (e.g. dev and prod side-by-side): modelrisk-mcp install --name=modelrisk-dev.
Zero-install via uvx (if you already use uv)
If you have uv installed, you can skip the pip install step entirely. Just add to %APPDATA%\Claude\claude_desktop_config.json directly:
{
"mcpServers": {
"modelrisk": {
"command": "uvx",
"args": ["modelrisk-mcp"]
}
}
}uvx downloads modelrisk-mcp into an ephemeral cache on first run and updates automatically when new versions hit PyPI.
Manual JSON edit (if you must)
Open %APPDATA%\Claude\claude_desktop_config.json and add the entry by hand:
{
"mcpServers": {
"modelrisk": {
"command": "C:/path/to/modelrisk-mcp.exe"
}
}
}Use the absolute path to the .exe you downloaded from the latest release, or "command": "python", "args": ["-m", "modelrisk_mcp"] if you pip installed.
After any of the three, restart Claude Desktop so it spawns the MCP server subprocess. The ModelRisk tools appear under the connections icon. Full guide: docs/claude-desktop.md. Claude Code setup: docs/claude-code.md.
Claude for Excel — not currently reachable (read this before trying)
Current Claude for Excel builds cannot connect to this server, and no local workaround exists. Earlier versions of this README described a Settings → Connectors flow; that was wrong for shipping builds and has been withdrawn (verified against a 2026-07 build; independently confirmed by a field report).
What we verified:
The Claude for Excel add-in has no local Connectors panel. It resolves connectors from your claude.ai account, and claude.ai custom connectors are remote MCP servers fetched by Anthropic's infrastructure — not by your device. A loopback URL (
http://127.0.0.1:…) is therefore unreachable by construction, and the dialog's OAuth fields don't match this server's bearer-token auth.Local stdio servers (the Claude Desktop kind) never appear in the claude.ai / Claude Desktop "Connectors" panel. Their absence there is normal, not a failed install — Claude Desktop lists them separately under local MCP servers.
Do not expose this server through a public tunnel to work around this. It can write formulas into, simulate, and save your workbooks; putting that behind a single bearer token on a public URL is a materially different risk posture than the loopback bind these docs describe, and we don't support it.
Use Claude Desktop or Claude Code instead (local stdio — the supported,
tested path; modelrisk-mcp install wires both). The HTTP transport below
remains useful for LAN/self-hosted setups with MCP clients that genuinely
run on your machine:
$env:MODELRISK_MCP_TOKEN = [Guid]::NewGuid().ToString("N") * 2
modelrisk-mcp --transport=streamable-http --port=8000 --token=$env:MODELRISK_MCP_TOKENDetails and the full analysis: docs/claude-for-excel.md.
First conversation
Open a workbook in Excel that has at least one Vose function — even a single =VoseNormal(0,1). Then in Claude:
Summarise the active workbook's risk model — inputs, outputs, distributions.
Or jump straight into building:
/build-risk-model
This walks through 9 steps, from identifying outputs through running the simulation and interpreting results. See the slash-command catalogue for the other workflows.
Demo gallery
Prefer a guided tour? examples/demos contains fifteen hands-on demo
workbooks — one per feature area, each a simple real-life use case (store-expansion NPV,
bakery demand fitting, correlated construction costs, insurance aggregate loss, reverse
stress testing, board reporting…). Every workbook's README sheet gives the exact prompts
to type to Claude, step by step. Start with 00_START_HERE.xlsx.
Safety by design
The server can both read and modify your workbook — that's the central differentiator. We make that safe with nine layered mechanisms (spec §11):
dry_run=Trueis the default on every building tool. Claude must explicitly passdry_run=Falseto commit. Previewing comes free; a forgotten flag becomes a preview, never an overwrite.Every write lands in Excel's native undo stack.
Ctrl+Zworks exactly as you'd expect.Bulk-write guard. Tools writing >50 cells in one call require explicit
confirm_bulk=True. Time-series and copula tools — which write contiguous ranges by design — are exempt.No automatic saves. The server never calls
Workbook.Save(). You controlCtrl+S.No overwriting non-Vose formulas. A formula-tokenised detector (not a substring check) refuses to overwrite a cell whose existing formula uses non-Vose functions. The one tool explicitly allowed to do this is
replace_constant_with_distribution, by design.Audit log of every write in
%LOCALAPPDATA%\VoseSoftware\modelrisk-mcp\writes.log— timestamp, cell, before/after formulas, before value. JSONL, append-only.Read-only mode. Launch with
--read-onlyto disable every building/simulation tool.Single-writer mutex. Two MCP server instances can't drive the same Excel concurrently — the second instance raises
ConcurrentWriterErroron any building tool call.Restore from audit log. The
restore_celltool reads writes.log and rewrites the pre-write formula — even after Excel's undo stack has been cleared.
What's inside
57 tools — 12 reading, 14 building (incl.
create_aggregatefor FFT / Panjer / MC frequency-severity methods), 5 simulation (incl.run_simulation,run_scenarios,get_samples,restore_cell,restore_deterministic_state), 11 analysis (compute_distribution,fit_and_rank_distributions,fit_time_series,fit_copula_to_data,reverse_stress_test,get_tail_risk,fit_tail,compute_correlation_matrix,compare_distributions,backtest_output,decompose_uncertainty), 12 workflow / reporting (incl.plan_risk_model,build_model_from_brief,fit_all_data_and_wire,audit_model,diagnose_workbook,create_tornado_chart,create_histogram_chart,create_cdf_chart,build_drivers_report,build_executive_report,generate_executive_summary,save_workbook_as), 3 VMRS (read_vmrs,set_active_vmrs,list_vmrs_variables)5 resources —
modelrisk://functions,modelrisk://distributions,modelrisk://methodology,modelrisk://workbook/current,modelrisk://audit-rules5 slash-command prompts —
/build-risk-model,/audit-model,/interpret-results,/add-uncertainty,/import-legacy-model1417-entry function catalogue extracted directly from the ModelRisk IDL + XLL header
17 audit rules — 13 Monte-Carlo-methodology (VOSE-001 … VOSE-013) + 4 spreadsheet-integrity (SS-001 … SS-004) — with editable severity in
data/audit_rules.yaml; add your own withdocs/authoring-audit-rules.mdMethodology-grounded distribution selection guide in
data/distributions.yaml
Methodology
The server is opinionated about Monte Carlo methodology — fetch modelrisk://methodology from any MCP client to read the 8 core principles. Highlights:
Every uncertain input is a distribution. Treating a noisy input as deterministic understates total uncertainty by exactly the amount it could swing.
Distribution fits use
uncertainty=TRUE. Carry parameter uncertainty through the simulation; don't pretend the best-fit parameters are exact.Risk events use
VoseRiskEvent, notprobability * impact. The bimodal nature matters.Correlated inputs use copulas. Independent inputs that are actually correlated produce artificially tight outputs.
Architecture
Three internal layers plus two external integration paths:
┌──────────────────────────────────┐
│ MCP client │
│ (Claude Desktop, Code, etc.) │
└────────────────┬─────────────────┘
│ JSON-RPC / stdio (or HTTP)
▼
┌──────────────────────────────────┐
│ MCP server layer (tools, │
│ prompts) │
├──────────────────────────────────┤
│ ModelRiskBridge (domain) │
│ + SimulationController │
│ + ResultsReader │
├──────────────────────────────────┤
│ ExcelBridge MrServiceBridge│
│ (xlwings) (ctypes) │
└──────┬───────────────────┬───────┘
│ Application.Run │ MRLIB_*
│ + cell I/O │ (read .vmrs)
▼ ▼
┌──────────────┐ ┌──────────────────┐
│ Excel + │ │ MRService.dll │
│ ModelRisk XLL│ │ (SDK) │
└──────────────┘ └──────────────────┘Two integration paths, each chosen for what it does best:
Builds + simulation trigger → Excel COM via xlwings, plus
Application.Run("VoseStartSimulCustom12", …)for the simulation kickoff. Mirrors what the ModelRisk ATL does internally; bypasses the fragile ATL CoClass Dispatch surface that doesn't expose IDispatch.Results read → MRService.dll directly via ctypes. Vose's official SDK opens
.vmrsfiles, returns sample arrays, computes statistics. No COM round-trips per output; per-iteration sample arrays available for arbitrary downstream analysis.
More: docs/architecture.md, docs/com-surface.md.
Known caveats
Starting ModelRisk is automatic (since 0.3.2). If no Excel is running when a tool is called, the server starts an attachable Excel and registers the ModelRisk XLL into it, so Vose functions resolve and simulations run. If Excel is already up but the add-in isn't live (e.g. ModelRisk's "Start with Excel" is off), the server auto-activates it before simulating, or returns a clear instruction if it can't. Disable auto-launch with
MODELRISK_AUTO_LAUNCH=0if you'd rather manage Excel yourself. (Earlier versions required you to open Excel + ModelRisk by hand first and could fail with an opaque "macro may not be available".)OneDrive-hosted workbooks: xlwings can fail to resolve the workbook's full path without
ONEDRIVE_COMMERCIAL_WINset. The bridge degrades gracefully — name-based operations still work, andrun_simulationdefaults the.vmrssave location to the user's Desktop when the workbook folder can't be resolved.Active simulation results:
get_simulation_resultsreads from the.vmrsfile produced by the most recentrun_simulationcall, or the most recent sibling.vmrsnext to the workbook. Useset_active_vmrs(path)orread_vmrs(path)to point at a specific file.Results reading on older ModelRisk installs: re-opening a saved
.vmrsfile requires MRService.dll, which ships with the current ModelRisk release but was not included in installers up to 9.1.x — update ModelRisk from vosesoftware.com for the full experience. Without the DLL, the results tools fall back automatically to reading the live Excel session (via temporaryVoseSimValuescratch formulas, sample-identical to the.vmrs,source: "in-session"in the response). The fallback is session-bound: it serves the most recent run in the Excel session that ran it, can't re-open.vmrsfiles after Excel closes, and is refused in--read-onlymode (it needs scratch-cell writes; the DLL path is the write-free reader).
License
MIT. See LICENSE.
Documentation
Doc | What it's for |
15 minutes, zero to your first simulation | |
Six problem-shaped recipes — budgets, data fitting, loss aggregation, correlated inputs, stress tests, audits | |
The nine things you can do, in depth; what the server does and doesn't do | |
The principles behind every model, each tied to the audit rule that enforces it | |
Risk-analysis guidance distilled from the ModelRisk Help — served to the LLM at build time ( | |
Which distribution for which uncertain quantity | |
Techniques — frequency-severity, correlation, common random numbers, time-series choice | |
Monte Carlo + MCP vocabulary for non-statisticians | |
Full install + activation detail | |
Claude Desktop setup · Claude Code setup · Claude for Excel setup | Per-client wiring |
The native-Excel-chart styling ruleset the reports follow | |
Extend the 13-rule audit set with your own | |
Internal layers + the two integration paths |
Links
Vose Software: https://www.vosesoftware.com
ModelRisk product page: https://www.vosesoftware.com/products/modelrisk/
Releases: https://github.com/vosesoftware/modelrisk-mcp/releases
Issues: https://github.com/vosesoftware/modelrisk-mcp/issues
Changelog: CHANGELOG.md
MCP spec: https://modelcontextprotocol.io
Available Tools
59 toolsaudit_modelB
ModelRisk: Run the model audit against the workbook. Each rule's detector lives in modelrisk_mcp.audit.rules; the rule set is editable in data/audit_rules.yaml. Returns an AuditReport with severity-tagged findings (error/warning/info) and suggested fixes.
Inputs: workbook_name (required). Returns: findings
backtest_outputA
ModelRisk: Backtest a simulation output against realised actuals — does the model's predicted distribution match what actually happened? Reports the Probability Integral Transform (PIT, ~0.5 mean and uniform if calibrated), the empirical coverage of central prediction intervals (e.g. ~90% of actuals should fall in the 90% interval), and bias. Pass the historical actuals you want to validate against. Reads the output's per-iteration samples — run the simulation first.
Inputs: actuals (required), output_name (required), max_n, intervals, +1 more. Returns: Validation of a simulation output against realised actuals.
build_drivers_reportA
ModelRisk: Build a single-sheet drivers report — a sensitivity analysis presented for a decision-maker. Drops onto a new sheet: title band; auto-generated KEY FINDINGS in plain English ('The dominant driver of NPV is widget cost, r = -0.65; higher widget cost lowers NPV'); a prominent tornado chart; a driver-ranking table with correlation + |r| + approximate variance share; a HOW TO READ THIS CHART panel for stakeholders who don't know what Spearman correlation means; and tiered RECOMMENDED ACTIONS (focus / monitor / deprioritise) grouping inputs by strength. Use this when the user asks for an uncertainty-drivers report rather than the broader executive dashboard.
Inputs: output_name (required), title, subtitle, sheet_name, +1 more. Returns: object
build_executive_reportA
ModelRisk: Build a single-sheet executive report for a decision-maker. Drops a curated dashboard onto a new sheet with: title band, headline numbers (mean / P5 / P50 / P95 / stdev — colored by volatility), histogram + cumulative chart of the primary output, tornado of top N sensitivity drivers, a stats table for the primary plus any secondary outputs, and auto-generated risk callouts framed in plain English ('90% confident X lands between A and B', 'tail risk Y% above mean', 'primary driver is Z'). Idempotent — re-running replaces the sheet. Use this when the user asks for a decision-maker-facing summary rather than raw stats.
Inputs: primary_output (required), title, subtitle, sheet_name, +4 more. Returns: object
build_model_from_briefA
ModelRisk: Turn a deterministic workbook into a simulation-ready Monte Carlo model in one atomic, reversible pass. Given the output cells to track and the uncertain inputs to add (each with a Vose distribution family + parameters you choose from the brief), it wraps the outputs with VoseOutput, replaces the input cells with VoseInput-wrapped distributions, optionally runs a validating simulation, and returns the headline percentiles. Every write goes through the audit-logged safe-write path and is tracked in a change-set: if any step fails, the ENTIRE build is rolled back so the workbook is never left half-converted. Defaults to dry_run=True. This end-to-end build+simulate is exactly what an advisory agent cannot do.
Inputs: sheet (required), inputs (required), workbook (required), run, +4 more. Returns: Outcome of turning a deterministic workbook into a simulation-ready Monte Carlo…
close_workbookA
ModelRisk: Close an open workbook by file name. By DEFAULT unsaved changes are DISCARDED (save=False) — pass save=True to write them first. Returns the closed name and the workbooks still open. Raises if the named workbook isn't open.
Inputs: workbook_name (required), save. Returns: object
compare_distributionsA
ModelRisk: Compare two simulation outputs head-to-head from their per-iteration samples — mean/stdev/percentile differences, P(A > B), and first- and second-order stochastic dominance (under the convention that larger outcomes are preferred). First-order dominance means one option is better at every probability level; second-order adds risk-aversion. Use it to decide between strategies. Run a simulation that records both outputs first.
Inputs: output_a (required), output_b (required), max_n, workbook_name. Returns: Head-to-head comparison of two simulation outputs from their per-iteration samp…
compute_correlation_matrixA
ModelRisk: Compute the rank-order (Spearman) correlation matrix of a data range via VoseCorrMatrix, and its nearest valid (positive-semidefinite) form via VoseValidCorrmat. Use this to turn historical data into the correlation matrix you feed to create_copula for correlated inputs. Variables are columns by default (set data_in_rows=True if each row is a variable). Read-only: runs on a transient scratch sheet that is always deleted.
Inputs: sheet (required), workbook (required), data_range (required), data_in_rows. Returns: Rank-order correlation matrix of a data range, plus its nearest valid (positive…
compute_distributionA
ModelRisk: Analytic distribution calculator — compute a property of a distribution WITHOUT running a simulation. Give a family (e.g. 'Normal', 'Lognormal', 'PERT') and its parameters, OR point at an object_cell that already holds a Vose distribution object (e.g. a fitted distribution). metric is one of: 'pdf' (density f(x)), 'cdf' (P(X<=x)), 'exceedance' (P(X>x)), 'quantile' (the x at cumulative probability u), 'mean', 'stdev', 'variance', 'skewness', 'kurtosis', 'cov', or 'summary' (all moments + a percentile ladder in one call). at is x for pdf/cdf/exceedance and u (0-1) for quantile. Exact, read-only: nothing is written and no simulation is run.
Inputs: metric (required), at, family, parameters, +2 more. Returns: result
create_aggregateA
ModelRisk: Build a frequency-severity aggregate using the chosen method — 'FFT' (Fast Fourier Transform) or 'Panjer' (Panjer recursion) for the fast analytic methods, or 'MC' for Monte Carlo. frequency_object_cell and severity_object_cell are references to distribution-object cells (built with VoseObject). FFT and Panjer support as_object=True, which writes the ...Object form whose mean and percentiles can be read directly with compute_distribution / get_tail_risk — the aggregate loss distribution WITHOUT running a simulation. Method-specific options: density (FFT), intervals / max_p (Panjer), min_limit / max_limit / distribution_shift (MC). For plain MC sampling, create_aggregate_mc is the dedicated shortcut.
Inputs: sheet (required), workbook (required), target_cell (required), severity_object_cell (required), +10 more. Returns: Tool output for `insert_distribution` and friends.
create_aggregate_mcC
ModelRisk: Build a VoseAggregateMC(n, distribution, ...) formula that simulates the aggregate of a (possibly random) number n of i.i.d. severity draws. n and distribution are cell references — n points at a frequency cell, distribution at a severity object cell (built with a VoseObject function).
Inputs: sheet (required), workbook (required), target_cell (required), severity_object_cell (required), +5 more. Returns: Tool output for `insert_distribution` and friends.
create_cdf_chartA
ModelRisk: Render the ascending cumulative-probability curve (CDF) of one output's simulation result distribution as a new sheet in the workbook. The sheet has a binned data table plus a native Excel line chart of cumulative probability (0-100%) against the output value — the 'what's the chance the output is below X' view. Requires a completed simulation (reads samples from the active .vmrs). Idempotent — a sheet with the target name is replaced.
Inputs: output_name (required), sheet_name, workbook_name. Returns: object
create_copulaB
ModelRisk: Build a copula formula (e.g. VoseCopulaMultiNormal) that produces a correlated u-array for downstream distribution calls. Copula tools are exempt from the bulk-write guard.
Inputs: sheet (required), workbook (required), parameters (required), function_name (required), +2 more. Returns: Tool output for `insert_distribution` and friends.
create_histogram_chartA
ModelRisk: Render a histogram of one output's simulation result distribution as a new sheet in the workbook. The sheet has a binned data table (bin centre / frequency / cumulative %) plus a native Excel chart: frequency columns with the cumulative-probability curve overlaid on a secondary % axis and the central-80% (P10-P90) band highlighted — the same view as ModelRisk's Results Viewer, persisted into the workbook. Requires a completed simulation (reads samples from the active .vmrs). Idempotent — a sheet with the target name is replaced.
Inputs: output_name (required), sheet_name, workbook_name. Returns: object
create_risk_eventC
ModelRisk: Build a VoseRiskEvent(probability, impact_object) formula. The impact_function_name must be a distribution-object function (category 'object') — typically a VoseObject variant.
Inputs: sheet (required), workbook (required), probability (required), target_cell (required), +3 more. Returns: Tool output for `insert_distribution` and friends.
create_time_seriesA
ModelRisk: Build a time-series formula (VoseTimeGBM, VoseTimeAR1, etc.) and write it into the target_range. Time-series tools are exempt from the >50-cell bulk-write guard because the dimension of the time series is the whole point.
Inputs: sheet (required), workbook (required), parameters (required), target_range (required), +2 more. Returns: Tool output for `insert_distribution` and friends.
create_tornado_chartA
ModelRisk: Render a tornado chart of input sensitivity for a single output as a new sheet in the workbook. The sheet has a sorted data table (Spearman rank correlation + regression coefficient per input) plus a native Excel BarClustered chart with the largest-magnitude input at the top. Idempotent — if a sheet with the target name already exists, it's replaced. Useful when the user wants the visualization persisted in the workbook, not just returned over MCP.
Inputs: output_name (required), sheet_name, workbook_name. Returns: object
decompose_uncertaintyA
ModelRisk: Split an output's uncertainty into EPISTEMIC (parameter / knowledge uncertainty — reducible with more data) and ALEATORY (natural variability — irreducible), via the law of total variance. ModelRisk has no two-dimensional-simulation worksheet function, so this approximates it from two runs you provide as two outputs: total_output from a full run (everything varying), and conditional_output from a run with the epistemic/parameter inputs FROZEN at point estimates (only natural variability left). Epistemic variance = total - aleatory. Tells you whether collecting more data (cuts epistemic) or hedging variability (aleatory) is the lever.
Inputs: total_output (required), conditional_output (required), max_n, workbook_name. Returns: Epistemic-vs-aleatory variance split of an output, via the law of total varianc…
diagnose_workbookA
ModelRisk: One-call workbook health check. Returns everything an MCP client typically wants at the start of a session: whether Excel is reachable, whether the ModelRisk SDK is activated, the active workbook's name + sheets, counts of inputs / outputs / distributions, whether a sibling .vmrs exists and when it was last modified, and the audit-log location. Use this as the first call instead of orchestrating 4-5 individual reading tools.
Inputs: workbook_name. Returns: object
discover_inputsA
ModelRisk: Discover candidate input cells — numeric cells referenced by formulas — and rank them by how likely they are to be uncertain model inputs (vs. constants like 12 months per year). The ranking weighs reference count and number magnitude. Pair with propose_distributions_for_inputs.
Inputs: workbook_name (required), limit. Returns: object
find_hard_coded_inputsA
ModelRisk: Heuristic discovery of cells that look like deterministic numeric inputs — i.e. a plain number, referenced by at least one formula. These are candidates for replacing with a distribution + VoseInput wrapper.
Inputs: workbook_name (required). Returns: object
fit_all_data_and_wireA
ModelRisk: Fit BOTH the marginal distributions and the copula dependence from a data block, then wire the whole correlated, simulation-ready model into the workbook in one reversible pass. For each variable column it fits+ranks the best marginal (AIC/SIC/HQIC); across the columns it fits the best copula (fit_copula_to_data) and writes the correlated-U block at copula_anchor; each marginal is wired to its copula U so the inputs are dependent, not independent — capturing the tail co-movement a single correlation coefficient discards. Optionally runs a validating simulation. Defaults to dry_run=True (returns the exact planned formulas without writing). On any mid-build failure the whole change-set is rolled back. This is the data→model step no advisory agent can perform.
Inputs: sheet (required), columns (required), workbook (required), data_range (required), +8 more. Returns: Outcome of fitting marginals + a copula from data and wiring them into the work…
fit_and_rank_distributionsA
ModelRisk: Fit several distribution families to a data range and rank them by goodness of fit. For each family it fits VoseFitObject and scores it with ModelRisk's information criteria — AIC, SIC (Schwarz/BIC) and HQIC — then ranks ascending (lower = better) by criterion. Families with no fit function, or that can't fit the data, are returned under skipped with a reason. Use this instead of guessing a single family for fit_distribution_to_data. Runs on a transient scratch sheet that is always deleted; the data is not modified.
Inputs: sheet (required), workbook (required), data_range (required), families, +2 more. Returns: Result of fitting and ranking several distribution families to a data range.
fit_copula_to_dataA
ModelRisk: Fit parametric copulas to a multi-column data range and rank them by goodness of fit — the DEPENDENCE STRUCTURE fitted from data, not merely constructed. Tries Normal, T, Clayton, Frank and Gumbel families (VoseFitObject), scores each with AIC / SIC / HQIC, and reports the winner plus its tail-dependence character (lower = crash-together, upper = boom-together, both = T, none = Normal/Frank) — the joint-tail risk a single correlation coefficient throws away. Runs on a transient scratch sheet that is always deleted; the data is not modified. Pair with fit_all_data_and_wire to insert the fitted copula into the model.
Inputs: sheet (required), workbook (required), data_range (required), families, +3 more. Returns: Result of fitting and ranking parametric copula families to a multi-column data…
fit_distribution_to_dataA
ModelRisk: Fit a distribution family to a data range and write the result. 'family' is e.g. 'Normal', 'Lognormal', 'Beta', 'Gamma', 'Weibull' — the tool maps it to the catalogue function (VoseFit). Set uncertainty=True (the default) to include parameter uncertainty in the fitted distribution.
Inputs: sheet (required), family (required), workbook (required), data_range (required), +4 more. Returns: Tool output for `insert_distribution` and friends.
fit_tailA
ModelRisk: Fit an extreme-value / Generalised-Pareto tail to data and read its risk. family is 'GPD' (peaks-over-threshold, the standard tail model), 'GEV' (block maxima), 'ExtValueMax', or 'ExtValueMin'. For GPD peaks-over-threshold, pass the range of exceedances above your threshold as data_range. Writes a VoseFitObject (dry_run previews) and returns the fitted tail's mean and high percentiles (P95 / P99 / P99.5 / P99.9) computed analytically — the tail risk without a simulation. Feed the written object cell to compute_distribution / get_tail_risk for more.
Inputs: sheet (required), workbook (required), data_range (required), target_cell (required), +3 more. Returns: A fitted extreme-value / GPD tail and its analytic risk metrics.
fit_time_seriesA
ModelRisk: Fit TIME-SERIES models to a historical data range and rank them by goodness of fit — GBM (plus mean-reverting / jump-diffusion / seasonal variants), AR1/AR2, MA1/MA2, ARMA, ARCH/GARCH/EGARCH. Each family's VoseTimeFitObject is scored with AIC / SIC / HQIC on a transient scratch sheet (nothing in the workbook is modified by the ranking). Optionally pass target_range (+ dry_run=False) to write the best model's projection — a VoseTimeFit(...) ARRAY formula, one period per cell, CSE-entered — so each simulated path carries the fitted dynamics (autocorrelation, volatility clustering) period to period. Note: unlike distribution fitting, parameter uncertainty is not supported here.
Inputs: sheet (required), workbook (required), data_range (required), dry_run, +4 more. Returns: Result of fitting time-series models to history and (optionally) writing the be…
generate_executive_summaryA
ModelRisk: Generate an executive-audience summary of the most recent simulation results for a workbook. Returns markdown ready to paste into a deck/report — covers deterministic vs P50 vs mean comparisons, P80 contingency, and the top sensitivity drivers.
Inputs: workbook_name (required), deterministic_values. Returns: object
get_active_workbookA
ModelRisk: Get the name and path of the active workbook.
Inputs: no named parameters. Returns: name, path, sheets, active_sheet
get_cellB
ModelRisk: Read a single cell's formula, value, and number format.
Inputs: cell (required), sheet (required), workbook_name (required). Returns: Snapshot of a single cell as read from Excel.
get_correlation_matrixA
ModelRisk: Pearson and Spearman rank correlation between the named simulation inputs and outputs. Computed from the per-iteration samples ModelRisk records. Pass a name list to restrict; otherwise all variables are included.
Inputs: workbook_name (required), name_list. Returns: Result of `get_correlation_matrix`. `names` is the ordered list of variables; `…
get_samplesA
ModelRisk: Return raw per-iteration sample values for a single output or input. Useful for custom histograms, arbitrary percentiles, downstream analysis. Caps at 10 000 samples by default to keep the MCP response small; raise max_n if you need more (a 100 000-iteration sim returns ~100 KB of JSON at max_n=100000).
Inputs: output_name (required), max_n, workbook_name. Returns: object
get_sensitivity_rankingA
ModelRisk: Tornado / sensitivity ranking for a single output. Returns each input ranked by its Spearman rank correlation with the output, plus the standardised regression coefficient.
Inputs: output_name (required), workbook_name (required). Returns: Tornado data for one output. Entries sorted by abs(correlation) desc.
get_simulation_resultsA
ModelRisk: Read simulation result statistics for the workbook's outputs. Returns per-output mean, stdev, variance, skewness, kurtosis, min, max, and P5/P10/P25/P50/P75/P90/P95 percentiles. Requires a simulation to have been run; pass output_names to filter.
Inputs: workbook_name (required), output_names. Returns: object
get_tail_riskA
ModelRisk: Tail-risk profile of a simulation output from its per-iteration samples — Value-at-Risk (VaR) and Conditional VaR / expected shortfall (CVaR) at each confidence level, plus optional threshold probabilities P(X>t) / P(X<=t). tail='upper' (default) treats large values as the loss (e.g. cost, claims); tail='lower' treats small values as the loss (e.g. NPV, profit). VaR is the alpha-quantile; CVaR is the mean of the worst (1-alpha) tail beyond it. Reads the samples ModelRisk recorded in the .vmrs — run a simulation first.
Inputs: output_name (required), tail, max_n, alphas, +2 more. Returns: Tail-risk profile of a simulation output, computed from its per-iteration sampl…
get_workbook_summaryA
ModelRisk: Aggregated summary of a workbook — sheet names plus counts of VoseInput, VoseOutput, distribution, formula, and numeric cells. One-shot alternative to running the individual list tools.
Inputs: workbook_name (required). Returns: Aggregated counts for a workbook — output of `get_workbook_summary`.
insert_distributionA
ModelRisk: Write a Vose distribution formula (e.g. =VoseModPERT(...)) into a cell. Validates the function name against the ModelRisk catalogue. Defaults to dry_run=True — Claude must explicitly pass dry_run=False to commit.
Inputs: cell (required), sheet (required), workbook (required), parameters (required), +2 more. Returns: Tool output for `insert_distribution` and friends.
list_distributionsA
ModelRisk: List every cell containing a Vose distribution / aggregate / copula / time-series / fitting function. Includes flags for whether each cell is also wrapped with VoseInput or VoseOutput. Optional sheet restricts the scan to one sheet.
Inputs: workbook_name (required), sheet. Returns: object
list_modelrisk_inputsA
ModelRisk: List every cell wrapped with VoseInput() in the workbook. Returns each cell's reference, the input name, the full formula, and the current calculated value.
Inputs: workbook_name (required). Returns: object
list_modelrisk_outputsA
ModelRisk: List every cell wrapped with VoseOutput() in the workbook.
Inputs: workbook_name (required). Returns: object
list_open_workbooksA
ModelRisk: List all Excel workbooks currently open.
Inputs: no named parameters. Returns: object
list_vmrs_variablesA
ModelRisk: List every variable in the active simulation results (.vmrs) that's also declared as a VoseInput or VoseOutput in the workbook. Each entry: {name, kind, var_id, iterations}. Use this before get_samples or read_vmrs when you don't already know which outputs / inputs exist in the file.
Inputs: workbook_name. Returns: object
open_workbookA
ModelRisk: Open a workbook (.xlsx/.xlsm) from disk in the running Excel so the other tools can act on it. Pass an absolute file path. If a workbook with the same file name is already open, returns that one (Excel won't open two with the same name). Requires Excel running.
Inputs: path (required). Returns: name, path, sheets, active_sheet
plan_risk_modelA
ModelRisk: One-call blueprint for turning a deterministic workbook into a Monte Carlo risk model. Reports what's already there (declared outputs, existing distributions), the ranked hard-coded cells that look like uncertain inputs, and an ordered, state-aware checklist of next actions (wrap outputs, fit/propose distributions, correlate, audit, simulate, interpret). Read-only — it plans, it doesn't modify. Run this first when asked to 'add uncertainty' or 'make this a risk model'.
Inputs: workbook_name (required). Returns: A blueprint for converting a deterministic workbook into a Monte Carlo risk mod…
propose_distributions_for_inputsA
ModelRisk: Propose distribution families for a list of uncertain inputs. Each input gets a ranked list of recommendations from the methodology-grounded selection guide. The tool does NOT write to Excel — it returns suggestions for the LLM to walk through with the user before committing via replace_constant_with_distribution.
Inputs: inputs (required). Returns: object
read_rangeA
ModelRisk: Read a contiguous range as a 2D array of values and formulas. Use ranges like 'A1:C10'.
Inputs: sheet (required), range_ref (required), workbook_name (required). Returns: Snapshot of a contiguous range.
read_vmrsA
ModelRisk: Read simulation results directly from a .vmrs file. Convenience wrapper for set_active_vmrs + get_simulation_results that doesn't need an open workbook. Pass output_names to filter; leave empty to attempt enumeration of all known outputs.
Inputs: path (required), output_names. Returns: object
replace_constant_with_distributionA
ModelRisk: Replace a hard-coded number in a cell with a Vose distribution wrapped by VoseInput. Use after find_hard_coded_inputs identifies candidates. This is the only tool that overwrites a non-Vose cell — it does so by design.
Inputs: cell (required), sheet (required), workbook (required), input_name (required), +3 more. Returns: Tool output for `insert_distribution` and friends.
restore_cellA
ModelRisk: Restore a cell to its pre-write state from the audit log. Reads %LOCALAPPDATA%\VoseSoftware\modelrisk-mcp\writes.log and rewrites the oldest captured before-formula for the cell. Pass since (ISO timestamp) to restrict the window.
Inputs: cell (required), sheet (required), workbook (required), since. Returns: Tool output for `insert_distribution` and friends.
restore_deterministic_stateA
ModelRisk: Recover a workbook that's been left in a 'frozen sample' state — VoseOutput cells stuck on per-iteration sample values instead of their deterministic baseline. Triggers a full Excel recalculation (Application.CalculateFull) which re-evaluates every formula and restores the deterministic values. Use this after run_simulation raises a post-condition error, or whenever list_modelrisk_outputs shows nonsense current_values that look like a single sample draw rather than the model's deterministic answer.
Inputs: workbook_name. Returns: object
reverse_stress_testA
ModelRisk: Reverse stress test — start from a BAD output outcome and work back to the joint input state that produces it. Partitions the simulation's iterations into breach / no-breach (output above/below a threshold, given directly or as a percentile), then for each input reports how far its mean shifts inside the breach set (in its own standard deviations) and how concentrated breaches are in its tail — a breach-driver tornado — plus the mean input vector as a concrete named stress scenario. This is the Solvency II / PRA 'reverse stress test' and is only possible with the engine's recorded per-iteration joint sample matrix (requires a completed simulation).
Inputs: output_name (required), max_n, direction, threshold, +2 more. Returns: Reverse stress test: from a bad output outcome back to the joint input state th…
run_scenariosA
ModelRisk: Sweep a single input cell across multiple deterministic values, running a full simulation at each. Returns per-output P5 / P50 / P95 / mean for every scenario value. Useful for what-if analysis: 'what if widget cost is $50 vs $75 vs $100'. The cell's original formula is captured before the sweep and restored afterwards (even on error), so the workbook ends in its pre-call state. Each scenario takes roughly the same time as one run_simulation call, so keep the values list short — 3-7 scenarios is a normal range.
Inputs: cell (required), sheet (required), values (required), seed, +2 more. Returns: Full output of a `run_scenarios` sweep.
run_simulationA
ModelRisk: Run a Monte Carlo simulation on the active (or named) workbook and save the results to a .vmrs file. Defaults to 1000 iterations with a fixed seed for reproducibility, and saves the .vmrs next to the workbook as <book>.vmrs. The simulation is run via the same XLL commands ModelRisk's own ribbon uses (VoseStartSimulCustom12 + VoseGetDataSZ12 with the SaveResultsToFile session), so behaviour matches what you'd see clicking 'Simulate' manually. ModelRisk simulates the active workbook, so a named workbook is made active first. The saved .vmrs is checked to hold this run (workbook, start time, iterations) before success is reported. Blocks until the simulation completes. After this returns, call get_simulation_results — the produced .vmrs is automatically pinned as the active results source. engine='turbo' runs ModelRisk's Turbo engine (its 'Fast Simulation'), often much faster. Turbo cannot evaluate every function: the engine's own check runs first, and the classic engine runs instead (see note and engine in the result) when Turbo cannot run the workbook or returns NaN outputs. Turbo can still give results that differ from the classic engine's for some functions, so confirm figures that matter with the classic engine. A Turbo run shows ModelRisk's progress window and opens its results in the Results Viewer.
Inputs: seed, engine, samples, save_to, +2 more. Returns: Compact JSON shape returned by the run_simulation tool.
save_workbook_asA
ModelRisk: Save the workbook to a specific path on disk. Distinct from the user's Ctrl+S — the MCP server never calls Workbook.Save() implicitly. Use only when the caller explicitly named a target file. Refuses to overwrite an existing file unless overwrite=True. Returns the resolved absolute path that was written.
Inputs: path (required), workbook (required), overwrite. Returns: object
set_active_vmrsA
ModelRisk: Pin a specific .vmrs file as the source of simulation results. Pass the absolute path of the file; subsequent calls to get_simulation_results / get_correlation_matrix / get_sensitivity_ranking will read from it instead of trying to locate a sibling file next to the workbook. Pass an empty string to clear the override.
Inputs: path (required). Returns: object
set_named_rangeA
ModelRisk: Create or overwrite a workbook-level named range. Useful for giving cells clear identities the LLM can reference by name later. The reference must be A1-style (e.g. 'Sheet1!$A$1:$A$10').
Inputs: name (required), workbook (required), range_ref (required), dry_run. Returns: object
wrap_with_inputC
ModelRisk: Wrap an existing distribution cell with VoseInput("name")+ so it appears in the input list and the Results Viewer.
Inputs: cell (required), name (required), sheet (required), workbook (required), +1 more. Returns: Tool output for `wrap_with_input` / `wrap_with_output`.
wrap_with_outputC
ModelRisk: Wrap an existing output cell with VoseOutput("name")+ so it appears in the output list and Results Viewer.
Inputs: cell (required), name (required), sheet (required), workbook (required), +1 more. Returns: Tool output for `wrap_with_input` / `wrap_with_output`.
write_formulaA
ModelRisk: Write an arbitrary formula or value into a single cell. Use this for wiring cells (e.g. =A1*B1, =SUM(...), =IF(...), or links to other sheets) that aren't covered by the Vose-specific tools. Safety: refuses to overwrite a cell containing an existing formula unless allow_overwrite=True — that protects user-written formulas AND prior Vose distributions. Empty cells write freely. Defaults to dry_run=True; pass dry_run=False to commit. Every commit appends to the audit log so restore_cell can roll back.
Inputs: cell (required), sheet (required), formula (required), workbook (required), +2 more. Returns: Tool output for `insert_distribution` and friends.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 59 tools
Descriptions are unusually rich and differentiate most tools, but several near-duplicate clusters create real selection risk: find_hard_coded_inputs vs discover_inputs (both surface candidate inputs), create_aggregate vs create_aggregate_mc, and a reporting cluster (build_executive_report vs build_drivers_report vs generate_executive_summary vs create_tornado_chart) that all touch sensitivity/dashboards. An agent will frequently have to read the full descriptions to pick correctly.
Names are overwhelmingly consistent snake_case verb_noun (list_modelrisk_inputs, run_simulation, fit_copula_to_data, get_tail_risk). Minor deviations like reverse_stress_test (no leading verb) and descriptive compounds (fit_all_data_and_wire, build_model_from_brief) break the pattern slightly but remain readable and predictable.
59 tools is far beyond the well-scoped 3-15 range and above the 25+ 'too many' threshold, creating a heavy selection burden for an agent. The domain is genuinely broad (fitting, simulation, aggregation, copulas, reporting, auditing), so it is not trivially over-provisioned, but the overlap clusters show meaningful consolidation opportunities.
Lifecycle coverage is extensive: workbook open/close/list/save, read/write cells, input/output wrapping, distribution/copula/tail/time-series fitting, simulation, results and sample retrieval, sensitivity/tail-risk/backtest analysis, charting, auditing, and audit-log rollback. Minor gaps remain — no explicit unwrap/delete for VoseInput/VoseOutput or distribution nodes (only restore_cell via the audit log) and no tool to create a brand-new workbook from scratch.
Maintenance
Related MCP Connectors
The Excel engine for AI agents: read, check and edit Excel models over MCP.
Explain and analyse Excel workbooks: formulas, dependencies, issues and what-if scenarios.
Financial models as graphs of named rows, checked by an engine: build, read, propose changes.
Monte Carlo ranges for uncertain plans: project cost, budget, timeline, capacity, NPV/IRR/payback.
Related MCP Servers
- FlicenseBqualityDmaintenanceEnables Excel automation via natural language, providing session-based workbook management, data manipulation, formulas, charts, and formatting through the Model Context Protocol.29-
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to automate Microsoft Excel tasks such as reading/writing cells, formatting, creating charts, and managing sheets through natural language using the Model Context Protocol.1Apache 2.0
- AlicenseNot gradedqualityDmaintenanceProvides quantitative analytics and statistical inference for financial data, including Monte Carlo DCF valuation, risk metrics, and trend regression diagnostics, enabling natural language-driven financial analysis via Claude Desktop.MIT
- AlicenseAqualityCmaintenanceAudits Excel workbooks by tracing cell dependencies and detecting circular references, volatile functions, and other formula risks, enabling natural-language audit queries on local files.4MIT