# Neumann

> Neumann is a freemium MCP server for analytics and data. Run Monte Carlo simulations on uncertain plans from inside your AI chat. It runs as a hosted remote server, so there is nothing to install locally.

- **Kind:** MCP server
- **Pricing:** Freemium
- **Platforms:** Web, API
- **Website:** https://kromatic.com/mcp/neumann
- **MCP Registry name:** io.github.Kromatic-Innovation/neumann
- **Categories:** analytics and data
- **Listing updated:** 2026-11-15

## About

Instead of asking an assistant for one best guess, you describe a plan as a small graph. Root nodes hold inputs drawn from a distribution, calc nodes hold formulas over those inputs, and edges name the flows between them. Neumann samples the roots thousands of times and returns percentiles and summary statistics for every node.

Two of its tools cost nothing to call: one checks a graph for structural problems and another estimates size and credit cost before you run anything. Other tools convert a plain "between X and Y, N% confident" estimate into distribution parameters, rank inputs by impact in a tornado-style sensitivity pass, and summarise best, median and worst scenarios.

Use is tiered. Anonymous callers get 3 runs per UTC day, up to 1,000 trials and 20 nodes per run. Signing in with a free Kromatic account raises that to 10 runs, 10,000 trials and 50 nodes, and a credit balance covers larger runs. It pairs with Kromatic's companion estimation server, Fermi, which can supply the input ranges.

## Features

- **Graph-based simulation:** Model a plan as root nodes, calc nodes and edges, then sample it thousands of times.
- **Free pre-flight checks:** Validate a graph and estimate its size and credit cost before spending anything.
- **Range to distribution:** Turn a human range with a confidence level into engine-ready distribution parameters.
- **Sensitivity ranking:** Sweep each input and rank the drivers that move a target node most.
- **Scenario summaries:** Get best, median and worst outcomes for any node.
- **HTTP twin endpoints:** Every tool is also callable over plain HTTP for clients that do not speak MCP.

## Good for

- Stress-test a revenue forecast with uncertain units and price
- Estimate runway under uncertain monthly burn
- Put a range on project delivery dates from uncertain task durations
- Find which input drives the spread of an NPV or payback result

## Install

### Claude Code (Terminal)

```sh
claude mcp add --transport http neumann https://neumann.kromatic.com/mcp
```

### Claude Desktop (Settings → Connectors → Add custom connector)

```sh
https://neumann.kromatic.com/mcp
```

### Cursor (~/.cursor/mcp.json)

```json
{
  "mcpServers": {
    "neumann": {
      "url": "https://neumann.kromatic.com/mcp"
    }
  }
}
```

### VS Code (.vscode/mcp.json)

```json
{
  "servers": {
    "neumann": {
      "type": "http",
      "url": "https://neumann.kromatic.com/mcp"
    }
  }
}
```

### Windsurf (~/.codeium/windsurf/mcp_config.json)

```json
{
  "mcpServers": {
    "neumann": {
      "serverUrl": "https://neumann.kromatic.com/mcp"
    }
  }
}
```

### Other clients (your client's MCP settings (most use this shape))

```json
{
  "mcpServers": {
    "neumann": {
      "type": "http",
      "url": "https://neumann.kromatic.com/mcp"
    }
  }
}
```

## Tools

- `run_monte_carlo_simulation`: Runs a Monte Carlo simulation of a model and returns the full range of possible outcomes, not one guessed number. A model is a set of uncertain inputs, the formulas that combine them, and the links between them. The simulation draws random values for every input many times; each draw is a trial, and one call is one run. Use this when you need to know how likely different outcomes are for a plan bu
- `rank_inputs_by_impact`: Ranks a model's uncertain inputs by how much each one moves a chosen outcome, and returns the data for a tornado chart. A tornado chart is a bar chart with one horizontal bar per input, sorted with the biggest swing at the top. This is a one-at-a-time (OAT) sensitivity analysis. Every input is held at its median while one input at a time is set to low, middle and high values from its own distribut
- `summarize_outcome_scenarios`: Runs a model once and reports one outcome's worst, median and best values. By default, worst is the lowest value in any trial, median is the middle value, and best is the highest value. Those labels assume higher is better. For a cost or a duration, where lower is better, swap them when you tell the user: the scenario labelled worst is the cheapest or fastest case, which is the good outcome, and t
- `check_simulation_model`: Checks a model for mistakes before you run it and lists every problem it finds. It looks for loops with no delay, nodes that are not connected, unknown distributions, missing or invalid distribution parameters, and broken formulas. A loop, including an edge from a node to itself, is allowed and is not an error when at least one edge in it has delay 1 or more. Use this when you have built or edited
- `estimate_simulation_size_and_cost`: Predicts how large a run of a model will be and how many credits it will cost, without running it. Use this before running a large or unfamiliar model, or to check that an account can afford it. It does not look for mistakes; use check_simulation_model for that. It returns the number of trials, time periods, nodes and edges, the estimated peak memory in MB, a complexity score, the size tier (small
- `convert_range_to_distribution`: Turns a low-to-high guess, such as "between 80 and 120, 90% sure", into the exact parameters a model input needs. A distribution is the shape of the uncertainty, for example normal (a bell curve), log_normal (skewed and never negative), triangle or uniform. The low and high values are the edges of the range you are that sure of, not hard limits. Use this when you have a rough estimate and need dis
- `convert_distribution_to_range`: Turns a distribution's parameters into the low and high ends of the range that holds a chosen share of outcomes, by default the middle 90%. It also gives the mean, median, mode, standard deviation and any percentiles you ask for. If you give a threshold, it gives the chance of landing below and above it. Use this when you have distribution parameters, from a model or from fermi (a companion foreca
- `get_simulation_results`: Checks on, and reads, a run you started with run_monte_carlo_simulation, rank_inputs_by_impact or summarize_outcome_scenarios, using its run_id. Use this when a run tool returned status running or queued: it waits up to 30 seconds for the run to finish, then returns its status and percent done, or the finished result, so call it again until status is completed. Use it also to get specific numbers 
- `check_account_and_credits`: Shows who Neumann thinks you are and what you can still do: your free runs left today and when they reset, and your credit balance if you have an account. Use this when you need to know, before or after a run, whether the next call will be free or spend credits, how much is left, or whether you are signed in -- and when a run was refused for want of runs or credits, so you can tell the user which 
- `send_feedback`: Sends a short report about Neumann to the team that builds it. They read every report and use it to fix problems and decide what to build, so honest feedback, good or bad, is useful. Use this when: - a Neumann tool returned an error (send it right away), behaved unexpectedly or gave a result that looks wrong; - the user needs something no Neumann tool can do, or an option that is missing; - a desc
- `buy_credits`: Buys Neumann credits by charging the payment card already saved on your account. Credits pay for runs once the free runs for the day are used up, or for a model too large to run free. Use this when an account is low on credits and the user has agreed to the purchase; to see the balance and the live price first, call check_account_and_credits. No saved card is needed to call it: if none is saved ye
- `create_result_share_link`: Creates a public web link to one of your results, so you can hand the numbers to someone who has no Neumann account. Use this when the user wants to send, publish or show a result to another person; to put the numbers in the conversation instead, call get_simulation_results. It works for any run you own: a run from run_monte_carlo_simulation, rank_inputs_by_impact or summarize_outcome_scenarios, a
- `save_graph`: Saves a model to your Neumann account so you can come back to it instead of describing it again. A saved model is called a graph: its uncertain inputs, the formulas that combine them, and the links between them. Use this when the user will revisit this model -- a budget, a plan, a business case they will update -- or when you want to re-analyse it later without resending it; for a one-off question
- `list_graphs`: Lists the graphs saved on your Neumann account, the most recently updated first. Use this when the user refers to a saved model that is not among the newest ones check_account_and_credits shows, or to page through all of them; it is how you find the id that get_graph, rank_inputs_by_impact, summarize_outcome_scenarios and delete_graph need. It does not list runs or results -- it lists the models t
- `get_graph`: Reads one graph you saved earlier, by its graph_id, and returns the whole model in the same shape the run tools accept. Use this when you want to show the user what is in a saved model, edit it before running it again, or run it with run_monte_carlo_simulation, which takes the model inline and not a graph_id. To find a graph_id first, call list_graphs. It returns the graph_id, the name, when it wa
- `delete_graph`: Deletes one graph you saved, together with the runs of it. Use this when the user has explicitly asked for that model to be removed, and not otherwise. Confirm which one first with list_graphs or get_graph, because the graph_id is the only thing that says which model goes. Neumann purges it for good after 30 days, and until then nothing on this connector can restore it -- no tool here can put it b
- `delete_run`: Deletes one of your own runs -- one result -- and its share link, leaving the model it came from alone. It works on any run_id you can read, whether the run came from a model you passed inline or from one you saved; afterwards get_simulation_results can no longer read it. Use this when the user has explicitly asked for that result to be removed, and not otherwise. To remove a saved model and all o

## FAQ

### Do I need an account?

No. Anonymous use allows 3 runs per UTC day, with up to 1,000 trials and 20 nodes per run.

### What does signing in change?

A free Kromatic account allows 10 runs a day, up to 10,000 trials and 50 nodes per run.

### Which clients can connect?

Any client that supports Streamable HTTP MCP, including Claude, ChatGPT, Grok, Cursor and VS Code.

### Can I use it from a script?

Yes. Each tool has a plain HTTP twin, and runs can also be submitted to a REST endpoint with streaming progress.

### Is Neumann free?

Neumann has a free plan, with paid plans for more usage or features.

### How do I add Neumann to Claude Code?

Run this command in your terminal: claude mcp add --transport http neumann https://neumann.kromatic.com/mcp

### What are the best alternatives to Neumann?

The closest alternatives to Neumann are Agent-Native Analytics, Google Ads + Meta Ads + SEO/GEO MCP, Tapetide - Indian Stock Market MCP, World Monitor and CompanyData.

## Alternatives

- [Agent-Native Analytics](https://ai-powered.com/mcp/agent-native-analytics): Agent-Native Analytics is an open-source MCP server for analytics and data.
- [Google Ads + Meta Ads + SEO/GEO MCP](https://ai-powered.com/mcp/google-ads-meta-ads-seo-geo-mcp): Google Ads + Meta Ads + SEO/GEO MCP is a freemium MCP server for marketing and seo.
- [Tapetide - Indian Stock Market MCP](https://ai-powered.com/mcp/tapetide-indian-stock-market-mcp): Tapetide - Indian Stock Market MCP is a freemium MCP server for finance and payments.
- [World Monitor](https://ai-powered.com/mcp/world-monitor): World Monitor is a freemium MCP server for analytics and data.
- [CompanyData](https://ai-powered.com/mcp/companydata): CompanyData is a paid MCP server for analytics and data.
- [ChartAnt](https://ai-powered.com/mcp/chartant): ChartAnt is a freemium MCP server for design and media.
- [Quantivex Research](https://ai-powered.com/mcp/quantivex-research): Quantivex Research is a free MCP server for finance and payments.
- [Provyan](https://ai-powered.com/mcp/provyan): Provyan is a free MCP server for finance and payments.

---
Source: https://ai-powered.com/mcp/neumann
