# RASON (npm · @frontlinesystems/rason-mcp-server)

Build, solve, and analyze RASON optimization, simulation, data science, and decision models

- Trust score: 62/100 (medium)
- Change this week: +18
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- mcpb · `rason-mcp-server.mcpb`: 39/100, [markdown](https://verifymcp.io/servers/frontlinesystems-rason-mcp-server/https-github-com-frontlinesystems-rason-mcp-server-releases-download-v2026-5-5-r.md), [page](https://verifymcp.io/servers/frontlinesystems-rason-mcp-server/https-github-com-frontlinesystems-rason-mcp-server-releases-download-v2026-5-5-r)
- npm · `@frontlinesystems/rason-mcp-server`: 62/100 (this document), [markdown](https://verifymcp.io/servers/frontlinesystems-rason-mcp-server/frontlinesystems-rason-mcp-server.md), [page](https://verifymcp.io/servers/frontlinesystems-rason-mcp-server/frontlinesystems-rason-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `@frontlinesystems/rason-mcp-server`
- Version: `2026.5.5`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 87/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (108 of 109), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (108 of 109), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 6/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: the license (SEE LICENSE IN LICENSE) isn't a recognized OSI-approved license.
  - Actively maintained (last published 67 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 76/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4659 tokens (~211/item across 22 items; 20 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add frontlinesystems-rason-mcp-server -- npx -y @frontlinesystems/rason-mcp-server
```

### Codex

```bash
codex mcp add frontlinesystems-rason-mcp-server -- npx -y @frontlinesystems/rason-mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "frontlinesystems-rason-mcp-server": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@frontlinesystems/rason-mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add frontlinesystems-rason-mcp-server --command npx --arg -y --arg @frontlinesystems/rason-mcp-server
```

### Hermes

```yaml
mcp_servers:
  frontlinesystems-rason-mcp-server:
    command: "npx"
    args: ["-y", "@frontlinesystems/rason-mcp-server"]
```

### Other

```json
{
  "mcpServers": {
    "frontlinesystems-rason-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@frontlinesystems/rason-mcp-server"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 62, +4)

- [functional improvement] Stability: unverified → 0.27

### 2026-08-02 (score 58, +24)

- [security regression] Provenance: unverified → fail
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Install scripts: unverified → pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional regression] License: unverified → fail
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Schema quality: unverified → excellent
- [functional improvement] Dependency health: unverified → partial
- [functional] Licence: SEE LICENSE IN LICENSE

### 2026-08-01 (score 34, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-07-31 (score 19, −25)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 44, +26)

- [functional improvement] Schema quality: unverified → 100
- [functional improvement] Tool coverage: unverified → 100

### 2026-07-28 (score 18, −26)

- [functional regression] Schema quality: 100 → unverified
- [functional regression] Tool coverage: 100 → unverified

### 2026-07-27 (score 44)

First indexed and scored.

## MCP tools (20)

### `about_rason` (~197 tokens)

About RASON

IMPORTANT: Use this tool to answer ANY questions about what RASON is, what it can do, who makes it (Frontline Systems), its capabilities, or where to find RASON / Frontline Systems websites and URLs. Also use this tool when the user asks for RASON or Solver website URLs.

RASON (RESTful Analytic Solver Object Notation, https://rason.com) is a JSON-based modeling language by Frontline Systems (https://www.solver.com). RASON supports optimization (linear, nonlinear, mixed-integer, stochastic), Monte Carlo simulation, data science / machine learning, calculation (DMN decision tables, FEEL expressions, box functions), and multi-stage decision flows. Models use Excel-compatible formula syntax and are solved via REST API or locally through the RASON Desktop VS Code extension with first-class Power BI Desktop integration.

Do NOT answer questions about RASON from memory — always call this tool first.

### `list_models` (~265 tokens)

GET /model

Retrieve metadata for models in the user's RASON account. Returns a JSON array of model objects, each containing:
\- ModelId: unique identifier (format: userId+modelName+creationDate)
\- ModelName: short name
\- ModelDescr: human-readable description of what the model does
\- ModelType, ModelKind, and other metadata fields

Use this to discover available models. Optionally filter by model type and/or kind.

Tip: Check here first when the user references a model by name to see if it already exists on the account.

Input parameters:

- `kind` (string): Filter models by kind. 'fitted' = fitted Data Mining model in PMML/JSON format, 'rason' = models defined in RASON language, 'excel' = models defined in Excel language, 'lpmps' = models defined in LP/…
- `type` (string): Filter models by type. 'origin' = originally POSTed models, 'version' = created by PUTing models of the same name (different versions), 'instance' = created when a model is solved, 'all' = return all…

### `get_model` (~176 tokens)

GET /model/{name_or_id}

Retrieve the actual model definition for a specific model. Returns RASON JSON definition for RASON models.

Use this to inspect or modify a model's structure. To solve an existing model, submit_solve can work directly with the model name.

Note: Excel models are returned as binary files which cannot be processed by LLMs. Use list_models to inspect metadata for Excel models instead.

\- If a model name is provided, returns the champion (most recent) model with that name
\- If a model ID is provided (format: userId+modelName+creationDate), returns that specific resource

Input parameters:

- `name_or_id` (string, required): The model name or model ID. A model name returns the champion (most recent) version. A model ID (format: userId+modelName+creationDate) returns that specific resource.

### `post_model` (~100 tokens)

POST /model

Create a new model by posting a RASON JSON definition. Use this for RASON models (optimization, simulation, data science, calculation (DMN decision tables, FEEL, box functions), or decision flow). The model is saved to the user's account and can later be retrieved, solved, or managed.

For Excel models or RASON models with data files, use post_model_with_files instead.

Input parameters:

- `model` (object, required): The RASON model object

### `post_model_with_files` (~247 tokens)

POST /model (form-data)

Upload a model with file attachments using multipart form-data. Supports two scenarios:

1\. RASON model with data files: Provide rason_model (JSON string) or rason_model_path (file path) plus one or more file paths (e.g. CSV or Excel data sources referenced by the model)
2\. Excel model: Provide a single Excel file path (.xlsx) without rason_model. The server will recognize it as an Excel model based on the file extension

Returns the created model metadata on success.

Input parameters:

- `file_paths` (array, required): One or more absolute file paths to upload (e.g. 'C:/models/model.xlsx', '/home/user/data.csv')
- `rason_model` (string): The RASON model definition as a JSON string. Required when uploading a RASON model with attached data files. Omit when uploading a standalone Excel model. Mutually exclusive with rason_model_path.
- `rason_model_path` (string): Absolute path to a RASON model file (.json). The file will be read and sent as the model definition. Use this instead of rason_model to avoid passing large JSON strings. Mutually exclusive with rason…

### `put_model` (~130 tokens)

PUT /model/{name_or_id}

Update an existing model or create a new version with the specified name. If a model with the given name exists, creates a new version (becomes the champion). If no model exists, creates a new model (acts like POST).

For Excel models or RASON models with data files, use put_model_with_files instead.

Input parameters:

- `model` (object, required): The RASON model object
- `name_or_id` (string, required): The model name or model ID. A model name creates/updates the champion version. A model ID (format: userId+modelName+creationDate) updates that specific resource.

### `put_model_with_files` (~333 tokens)

PUT /model/{name_or_id} (form-data)

Update an existing model or create a new version with file attachments using multipart form-data. If a model with the given name exists, creates a new version (becomes the champion). If no model exists, creates a new model (acts like POST). Supports two scenarios:

1\. RASON model with data files: Provide rason_model (JSON string) or rason_model_path (file path) plus one or more file paths (e.g. CSV or Excel data sources referenced by the model)
2\. Excel model: Provide a single Excel file path (.xlsx) without rason_model. The server will recognize it as an Excel model based on the file extension

Returns the created/updated model metadata on success.

Input parameters:

- `file_paths` (array, required): One or more absolute file paths to upload (e.g. 'C:/models/model.xlsx', '/home/user/data.csv')
- `name_or_id` (string, required): The model name or model ID. A model name creates/updates the champion version. A model ID (format: userId+modelName+creationDate) updates that specific resource.
- `rason_model` (string): The RASON model definition as a JSON string. Required when uploading a RASON model with attached data files. Omit when uploading a standalone Excel model. Mutually exclusive with rason_model_path.
- `rason_model_path` (string): Absolute path to a RASON model file (.json). The file will be read and sent as the model definition. Use this instead of rason_model to avoid passing large JSON strings. Mutually exclusive with rason…

### `solve_model` (~325 tokens)

POST /solve

Submit a model for synchronous (quick) solving. Supports three input methods:

1\. Inline RASON model: Provide the model as a JSON object
2\. RASON model file: Provide rason_model_path pointing to a .json file
3\. Excel model file: Provide excel_model_path pointing to a .xlsx file

The server will solve the model (optimization, simulation, data science, calculation (DMN decision tables, FEEL, box functions), or decision flow) and return the results immediately in the response. Best suited for small to medium models that solve quickly.

Typically used for one-off solving of new models or local model files. For models already on the account, submit_solve is usually preferred for async solving.

Note: Synchronous solving does not support RASON models with external data files.

Input parameters:

- `excel_model_path` (string): Absolute path to an Excel model file (.xlsx). The file will be uploaded and solved. Mutually exclusive with model and rason_model_path.
- `include_full_results` (boolean): When true, returns the complete unsummarized result. By default (false), large arrays and dataFrames are summarized to reduce token usage. Use this only when the user explicitly needs raw data values.
- `model` (object): The RASON model object (inline JSON). Mutually exclusive with rason_model_path and excel_model_path.
- `rason_model_path` (string): Absolute path to a RASON model file (.json). The file will be read and sent for solving. Mutually exclusive with model and excel_model_path.

### `submit_solve` (~177 tokens)

POST /model/{name_or_id}/solve

Submit a previously uploaded model for asynchronous (long) solving. The model must already exist in the user's account (uploaded via post_model or put_model).

This places the model on the solving queue and returns immediately with the created model instance metadata (without waiting for the solve to complete).

After submitting, use get_solve_status to monitor progress, get_solve_result to retrieve results when complete, and stop_solve to cancel if needed.

This is the typical path for solving models already on the account. Can be called with just the model name if it exists on the account.

Best suited for large models or models that take a long time to solve.

Input parameters:

- `name_or_id` (string, required): The model name or model ID of an existing Origin or Version model. If a model name is provided, solves the champion (most recent) version.

### `get_solve_status` (~135 tokens)

GET /model/{name_or_id}/status

Check the solving status of a model. Returns a response with:
\- status: "Complete", "Incomplete", or "Canceled"
\- progress (optional): solving progress details including elapsed time, iterations, objective value, etc.

If a model name is provided, returns status for all instances under that name.
If a model ID is provided, returns status for that specific instance.

Use this after submit_solve to monitor when the solve finishes.

Input parameters:

- `name_or_id` (string, required): The model name or model ID. A model name returns status for all instances with that name. A model ID returns status for that specific instance.

### `get_solve_result` (~184 tokens)

GET /model/{name_or_id}/result

Retrieve the solving result for a model. If the model solve is complete, returns the full result (same format as synchronous solve_model). If the model solve is still incomplete, returns the incomplete status instead.

If a model name is provided, returns results for all instances under that name.
If a model ID is provided, returns the result for that specific instance.

Use get_solve_status first to confirm the solve is complete before retrieving results.

Input parameters:

- `include_full_results` (boolean): When true, returns the complete unsummarized result. By default (false), large arrays and dataFrames are summarized to reduce token usage. Use this only when the user explicitly needs raw data values.
- `name_or_id` (string, required): The model name or model ID. A model name returns results for all instances with that name. A model ID returns the result for that specific instance.

### `stop_solve` (~132 tokens)

POST /model/{name_or_id}/stop

Request to stop a running model solve. After stopping, the model status becomes 'Canceled'.

Depending on the model type, intermediate results may still be available (e.g. the best-so-far solution for an optimization problem). Use get_solve_result after stopping to check if partial results are available.

If a model name is provided, stops all running instances under that name.
If a model ID is provided, stops only that specific instance.

Input parameters:

- `name_or_id` (string, required): The model name or model ID. A model name stops all running instances with that name. A model ID stops only that specific instance.

### `diagnose_model` (~299 tokens)

POST /diagnose

Submit a model for synchronous (quick) diagnostics. Supports three input methods:

1\. Inline RASON model: Provide the model as a JSON object
2\. RASON model file: Provide rason_model_path pointing to a .json file
3\. Excel model file: Provide excel_model_path pointing to a .xlsx file

The server will analyze the model and return diagnostic information immediately in the response.

Note: Synchronous diagnostics do not support RASON models with external data files.

Diagnostics are most useful for optimization models (structural analysis) and multi-stage flow models (stage graph, pipelines, data sources). For simulation, data mining, and calculation models, results are limited.

Input parameters:

- `excel_model_path` (string): Absolute path to an Excel model file (.xlsx). The file will be uploaded and diagnosed. Mutually exclusive with model and rason_model_path.
- `include_full_results` (boolean): When true, returns the complete unsummarized diagnostic result. By default (false), large arrays and dataFrames are summarized to reduce token usage. Use this only when the user explicitly needs raw…
- `model` (object): The RASON model object (inline JSON). Mutually exclusive with rason_model_path and excel_model_path.
- `rason_model_path` (string): Absolute path to a RASON model file (.json). The file will be read and sent for diagnostics. Mutually exclusive with model and excel_model_path.

### `submit_diagnose` (~175 tokens)

POST /model/{name_or_id}/diagnose

Submit a previously uploaded model for asynchronous (long) diagnostics. The model must already exist in the user's account (uploaded via post_model or put_model).

This places the model on the diagnostics queue and returns immediately with the created model instance metadata (without waiting for diagnostics to complete).

After submitting, use get_solve_status to monitor progress, get_solve_result to retrieve diagnostic results when complete, and stop_solve to cancel if needed.

Diagnostics are most useful for optimization models (structural analysis) and multi-stage flow models (stage graph, pipelines, data sources). For simulation, data mining, and calculation models, results are limited.

Input parameters:

- `name_or_id` (string, required): The model name or model ID of an existing Origin or Version model. If a model name is provided, diagnoses the champion (most recent) version.

### `set_champion` (~185 tokens)

PATCH /model/{name_or_id}

Set or unset the champion flag on a model version. The champion version is the one returned by default when a model is referenced by name.

When setting a new champion, the previous champion for that model name is automatically unmarked. Only origin or version models can be marked as champion (not run instances).

\- If a model name is provided, targets the current champion (most recent) version
\- If a model ID is provided (format: userId+modelName+creationDate), targets that specific version

Input parameters:

- `champion` (boolean, required): Set to true to mark this model as the champion, or false to remove the champion designation.
- `name_or_id` (string, required): The model name or model ID. A model name targets the current champion (most recent) version. A model ID (format: userId+modelName+creationDate) targets that specific version.

### `delete_model` (~378 tokens)

DELETE /model/{name_or_id}

Delete models from the user's RASON account. Supports flexible filtering:

Behavior based on name_or_id:
\- Model name: Deletes all versions/instances/fitted models/attached files/results for that name
\- Model ID (userId+modelName+creationDate): Deletes that specific model and its attached files/results

Optional filters:
\- kind: Delete only specific model kinds (fitted, excel, rason). Can specify multiple kinds.
\- type: Delete only specific model types (origin, version, instance). Can specify multiple types.
\- force: Set to true to delete models that are currently executing (default: false)

Returns:
\- status: Descriptive status message
\- deletedModels: Array of successfully deleted model info objects
\- nonDeletedModels: Array of models not deleted because they are executing
\- invalidModels: Array of invalid resource identifiers

Input parameters:

- `force` (boolean): Force deletion of models that are currently executing. Default: false (models in execution will not be deleted).
- `kind` (array): Filter deletion by model kind. 'fitted' = fitted Data Mining model in PMML/JSON format, 'excel' = models defined in Excel language, 'rason' = models defined in RASON language. Can specify multiple ki…
- `name_or_id` (string, required): The model name or model ID. A model name affects all models with that name. A model ID (format: userId+modelName+creationDate) affects only that specific resource.
- `type` (array): Filter deletion by model type. 'origin' = originally POSTed models, 'version' = created by PUTing models of the same name, 'instance' = created when a model is solved. Can specify multiple types to d…

### `search_examples` (~263 tokens)

Search Example Models

Search ~200 RASON example models by keyword or model type. Returns up to 8 best matches with descriptions and metadata.

Model types: optimization, simulation, datamining (data science/ML), calculation (DMN decision tables, FEEL, box functions), flow (multi-stage decision pipelines)

Problem domains covered: portfolio optimization, production planning, supply chain, vehicle routing, scheduling, workforce allocation, blending, cutting stock, Monte Carlo risk analysis, demand forecasting, customer churn prediction, classification, regression, clustering, time series forecasting, text mining, business rules, decision tables, decision automation, multi-stage decision flows.

Focus on RASON's core strengths: optimization, simulation, and decision models. IMPORTANT: Do not pre-filter by model_type unless the user explicitly requests a specific type. Present results and let scoring surface the best matches.

Input parameters:

- `feature_demo` (boolean): If true, only return feature demo examples. If false, exclude them.
- `model_type` (string): Filter by RASON model type
- `query` (string): Search query — keywords describing what you're looking for. Examples: 'portfolio optimization', 'decision tree classification', 'monte carlo simulation', 'scheduling constraints', 'neural network', '…

### `get_example` (~89 tokens)

Get Example Model

Retrieve the full RASON JSON definition of a specific example model. Use this after search_examples to get the complete model source code as a reference for building new models. Do NOT solve, POST, or run the model unless the user explicitly asks to.

Input parameters:

- `file_path` (string, required): The file path of the example model (as returned by search_examples). Example: 'Optimization/Linear/ProductMix.json'

### `get_model_template` (~167 tokens)

Get RASON Model Template

Get a RASON model template — a bare JSON scaffold for a specific model type. Use as a structural reference or starting point.

Available templates:
\- blank: Minimal model with name and description
\- optimization: Variables, constraints, objective (linear, nonlinear, etc.)
\- simulation: Uncertain variables, output functions (Monte Carlo)
\- sim-optimization: Stochastic programming (optimization + uncertainty)
\- data-science: Datasources, datasets, estimator, actions
\- workflow: Multi-stage decision flow connecting models
\- decision-table: DMN 1.6 decision tables, box functions, Excel/FEEL formulas
\- power-bi: Model with Power BI Desktop datasource bindings (first-class integration)

Input parameters:

- `template_id` (string, required): The model type to get a template for.

### `describe_model` (~250 tokens)

Analyze RASON Model

Analyze and classify a RASON model: reliably detect model type and subtype (optimization — LP, QP, MIP, stochastic, chance-constrained; simulation; datamining — classification, regression, clustering; calculation — decision tables, box functions; multi-stage flow), inventory and classify components (variable types, constraint types, distribution families, ML pipelines, inter-stage data flow), and identify issues (missing result requests, absent validation data, empty output sections). Provides deterministic RASON-specific analysis beyond what raw JSON inspection reveals. Call whenever the user asks about, discusses, or works with a RASON model — whether open in the editor, referenced as a file, provided inline, or stored on the RASON server.

Input parameters:

- `model` (object): The RASON model as a JSON object. Mutually exclusive with rason_model_path and name_or_id.
- `name_or_id` (string): Name or ID of an existing model on the RASON account. The model will be fetched and analyzed. Mutually exclusive with model and rason_model_path.
- `rason_model_path` (string): Path to a file containing a RASON model. Mutually exclusive with model and name_or_id.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/frontlinesystems-rason-mcp-server/frontlinesystems-rason-mcp-server#diagnostics

## Score history

- 2026-08-03: 62
- 2026-08-02: 58
- 2026-08-01: 34
- 2026-07-31: 19
- 2026-07-30: 44
- 2026-07-28: 18
- 2026-07-27: 44

## Links

- npm package: https://www.npmjs.com/package/@frontlinesystems/rason-mcp-server
- Socket report: https://socket.dev/npm/package/@frontlinesystems/rason-mcp-server
- Website: https://www.solver.com/rason
- Changelog RSS feed: https://verifymcp.io/servers/frontlinesystems-rason-mcp-server/frontlinesystems-rason-mcp-server/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/frontlinesystems-rason-mcp-server/frontlinesystems-rason-mcp-server/changelog.json
- HTML version of this page: https://verifymcp.io/servers/frontlinesystems-rason-mcp-server/frontlinesystems-rason-mcp-server