# MCP for OpenFilters (pypi · mcp-for-openfilters)

Design, simulate and optimize optical thin-film coatings with the OpenFilters engine.

- Trust score: 83/100 (high trust)
- Change this week: +19
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- pypi · `mcp-for-openfilters`: 83/100 (this document), [markdown](https://verifymcp.io/servers/bbrunoesteves-mcp-for-openfilters/mcp-for-openfilters.md), [page](https://verifymcp.io/servers/bbrunoesteves-mcp-for-openfilters/mcp-for-openfilters)

## Channel facts

- Registry: `pypi`
- Package: `mcp-for-openfilters`
- Version: `0.2.2`
- 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-11-21.

- **Supply Chain Security**: 94/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Declares code that runs automatically (setup.py, a custom setup.py cmdclass) and that we could not recognise. It may be perfectly ordinary, but we have not established what it does.
  - 2 of 40 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to BBrunoEsteves/mcp-for-openfilters).
  - Clear OSI-approved license (GPL-2.0-or-later).
  - Actively maintained (last published 14 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 66/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 15797 tokens (~426/item across 37 items; 28 tools + 9 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 50/100
  - Stability observed for 15 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 77/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 32% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 30 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the MCP for OpenFilters server?

MCP for OpenFilters runs locally as a PyPI package, launched with uvx mcp-for-openfilters. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add bbrunoesteves-mcp-for-openfilters -- uvx mcp-for-openfilters
```

### Cursor

```json
{
  "mcpServers": {
    "bbrunoesteves-mcp-for-openfilters": {
      "command": "uvx",
      "args": [
        "mcp-for-openfilters"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "bbrunoesteves-mcp-for-openfilters": {
      "command": "uvx",
      "args": [
        "mcp-for-openfilters"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add bbrunoesteves-mcp-for-openfilters -- uvx mcp-for-openfilters
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "bbrunoesteves-mcp-for-openfilters": {
      "type": "local",
      "command": [
        "uvx",
        "mcp-for-openfilters"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add bbrunoesteves-mcp-for-openfilters --command uvx --arg mcp-for-openfilters
```

### Hermes

```yaml
mcp_servers:
  bbrunoesteves-mcp-for-openfilters:
    command: "uvx"
    args: ["mcp-for-openfilters"]
```

### Netclaw

```json
{
  "McpServers": {
    "bbrunoesteves-mcp-for-openfilters": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "mcp-for-openfilters"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add bbrunoesteves-mcp-for-openfilters -t stdio -c uvx -a mcp-for-openfilters
```

### Other

```json
{
  "mcpServers": {
    "bbrunoesteves-mcp-for-openfilters": {
      "command": "uvx",
      "args": [
        "mcp-for-openfilters"
      ]
    }
  }
}
```

## 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-11-21 (score 83, +1)

No change was recorded against any check on this day. Stability & Change Management went from 47 to 50. That category is still filling its 30-day observation window: 14 days of observed history at the previous scan, 15 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-19 (score 82, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-18 (score 66, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-17 (score 81, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-16 (score 65, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-15 (score 80, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-14 (score 64, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-13 (score 79, +16)

- [security improvement] Malware scan: unverified → pass

## MCP tools (28)

### `server_info` (~61 tokens)

Server information

Version, build (git commit of a source checkout, and when this server started: a server started
before a code change still runs the old code until the app is restarted), data folder, worker count
and whether the compiled C++ core is in use.

### `list_materials` (~55 tokens)

List materials

List available materials (built-in OpenFilters library plus the user's own) with n,k at a few
wavelengths. Mixtures (variable composition) report their index range at 550 nm.

Input parameters:

- `name_filter`

### `get_material_index` (~172 tokens)

Material optical constants

Tabulate n and k of a regular material over wavelengths (default 300-2000 nm, 50 nm steps).
For a mixture (kind "mixture" in list_materials): its composition steps, the index of each step k at
each wavelength (default 550 nm; up to 10 wavelengths), as used by graded layers.

Input parameters:

- `name` (string, required)
- `plot` (boolean)
- `wavelengths`: {"from": 380, "to": 1100, "step": 1} or an explicit list of wavelengths (nm). Default: the design's wavelength_range if it has one (e.g. from a project), else 380-1100 nm (simulate_random_errors: Ope…

### `add_material` (~234 tokens)

Add a material

Add a material to the user's material folder.

model = "constant" (n, k) | "cauchy" (coefficients [A, B, C] with n = A + B/l^2 + C/l^4, l in um,
optionally + [Ak, exponent, edge_nm] Urbach absorption) | "sellmeier" ([B1, C1, B2, C2, B3, C3],
C in um^2, optional same 3 absorption terms) | "table" (rows [wavelength, n, k] in `table`, or a
CSV/whitespace text file `table_file` with columns wavelength, n, k; wavelength_unit nm|um|eV).
k is the positive extinction coefficient.

Input parameters:

- `coefficients`
- `description` (string)
- `k` (number)
- `model` (string, required)
- `n`
- `name` (string, required)
- `overwrite` (boolean)
- `table`
- `table_file`
- `wavelength_unit` (string)

### `remove_material` (~77 tokens)

Remove a material

Delete one of the user's own materials (from add_material or import_refractiveindex_material).
Built-in OpenFilters materials cannot be removed; if a user material had the same name as a
built-in one, the built-in one is used again. Designs and projects that use it will no longer load.

Input parameters:

- `name` (string, required)

### `search_refractiveindex` (~210 tokens)

Search refractiveindex.info

Search the refractiveindex.info database of optical constants (public domain) by material
name, formula or author, e.g. "Ta2O5", "silicon nitride", "HfO2 thin film", "N-BK7". Each result
gives a `page` id to pass to import_refractiveindex_material (pass it exactly, spaces included), the
source (author, year, range) and the database's category for it, e.g. "Thin film", "Amorphous thin
film" or "Experimental data: bulk, thick film": thin-film data usually suit coatings best. shelf limits the search: main (inorganic), organic, glass, other, specs (supplier data sheets),
popular_glass. The catalogue is downloaded once and cached for 30 days (refresh=true updates it).

Input parameters:

- `limit` (integer)
- `query` (string, required)
- `refresh` (boolean)
- `shelf`

### `import_refractiveindex_material` (~167 tokens)

Import a refractiveindex.info material

Download one refractiveindex.info entry (`page` from search_refractiveindex) and add it to the
user's materials as an n,k table, usable in designs like any other material. Tabulated data and
dispersion formulas are both converted; k = 0 when the entry gives none. name defaults to
\<book>_<page> (e.g. Ta2O5_Bright-amorphous); from_nm/to_nm crop the table. Returns the material,
its wavelength range, the references (cite them when using the data) and the web page.

Input parameters:

- `from_nm`
- `name`
- `overwrite` (boolean)
- `page` (string, required)
- `plot` (boolean)
- `to_nm`

### `describe_design` (~636 tokens)

Describe a design

Validate a design and list its layers (thickness, index and QWOT at the center wavelength; graded
layers: number of steps, index range, first and last index, optical thickness), total thickness, the
substrate and incident medium indices, and the normalized design JSON (e.g. a formula expanded into
layers; omitted for formulas of more than 20 layers, which can be passed as they are; written to a
design_file when graded layers have many steps). Two-sided designs also list back_layers (with a
warning if consider_backside is false). plot_index_profile draws n at the center wavelength versus
depth, graded layers step by step, with the substrate and the incident medium at the ends.

Input parameters:

- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `plot_index_profile` (boolean)

### `compute_spectrum` (~976 tokens)

Compute spectrum

Compute R, T, A, OD, phase, GD or GDD spectra (quantity names R, T, A, OD, R_phase, T_phase, R_GD,
T_GD, R_GDD, T_GDD) versus wavelength for one design at one or more
angles and polarizations. Returns, per series, min/max/mean and `sample_points` evenly spaced
samples (set sample_points=0 for statistics only); full data go to a CSV when save_csv=true.
reverse=true illuminates from the substrate side (R, T, A, OD only; the angle is then measured in the
substrate, or in the exit medium when consider_backside is true, as in OpenFilters). Quantity "OD" is optical density
(-log10 T), best for blocking specs; summary values have 8 significant figures. GD (fs) and GDD (fs^2) are
numerical derivatives over the wavelengths requested: use steps of 5 nm or less. Two-sided designs
(back_layers + consider_backside: true) are computed with both faces.

Input parameters:

- `angles` (array)
- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `plot` (boolean)
- `polarizations` (array)
- `quantities` (array)
- `reverse` (boolean)
- `sample_points` (integer)
- `save_csv` (boolean)
- `threshold`: {"above": 0.999} or {"below": 0.01}: ranges where each series is above/below the level, edges interpolated (e.g. the high-reflection band of a mirror); {"half_max": true}: FWHM, peak and half-maximum…
- `wavelengths`: {"from": 380, "to": 1100, "step": 1} or an explicit list of wavelengths (nm). Default: the design's wavelength_range if it has one (e.g. from a project), else 380-1100 nm (simulate_random_errors: Ope…

### `compute_angle_scan` (~620 tokens)

Angle scan

R/T/A (or phase) versus angle of incidence at a single wavelength. Per curve: min/max with the angle
where each occurs (e.g. Brewster's angle is at_deg_min of "R p"), mean, `sample_points` evenly spaced
samples (0 for statistics only) and optional threshold ranges.

Input parameters:

- `angles` (object): {"from": 0, "to": 85, "step": 1}
- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `plot` (boolean)
- `polarizations` (array)
- `quantities` (array)
- `sample_points` (integer)
- `threshold`: as in compute_spectrum, over angle
- `wavelength` (number, required)

### `compute_color` (~618 tokens)

Coating color

Color of the coating in reflection or transmission: XYZ, xy, L*a*b*, LCh, sRGB and hex, at each
angle (use several angles to see the color shift).

Input parameters:

- `angles` (array)
- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `illuminant` (string)
- `mode` (string)
- `observer` (string)
- `polarization`: "s", "p", "unpolarized", or a polarization angle psi in degrees from 0 to 90 (as in the OpenFilters dialogs: R = sin^2(psi) Rs + cos^2(psi) Rp; 0 = p, 90 = s, 45 = unpolarized)

### `compute_electric_field` (~638 tokens)

Electric field in the coating

Standing-wave |E|^2 inside the coating (relative to the incident wave), e.g. for laser-damage
analysis, sampled every 1 nm inside every layer (graded layers too). Returns the peak value and
position, its value at each interface and, for graded layers, the peak inside each one.

Input parameters:

- `angle` (number)
- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `plot` (boolean)
- `polarization`: "s", "p", "unpolarized", or a polarization angle psi in degrees from 0 to 90 (as in the OpenFilters dialogs: R = sin^2(psi) Rs + cos^2(psi) Rp; 0 = p, 90 = s, 45 = unpolarized)
- `wavelength` (number, required)

### `compute_monitoring_curves` (~803 tokens)

Optical monitoring curves

Optical monitoring signal (R or T) versus deposited thickness, as seen during deposition. Returns
the signal at the end of each layer (turning-point/level-cut planning). With many wavelengths
(spectroscopic monitoring) it returns the layer-end signals of the selected wavelength (the center
wavelength if it is on the grid, else the middle one, as OpenFilters selects), a CSV of the spectrum
at every layer end, a map of signal versus thickness and wavelength (save_map: the full map as CSV),
and the curve at the selected wavelength. direction "reverse": light from the substrate side (angle
measured in the substrate). The substrate backside is included unless the design sets
"consider_backside_on_monitoring": false.

Input parameters:

- `angle` (number)
- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `direction` (string)
- `mode` (string)
- `plot` (boolean)
- `polarization`: "s", "p", "unpolarized", or a polarization angle psi in degrees from 0 to 90 (as in the OpenFilters dialogs: R = sin^2(psi) Rs + cos^2(psi) Rp; 0 = p, 90 = s, 45 = unpolarized)
- `save_map` (boolean)
- `wavelengths` (required): Monitoring wavelengths: a list (e.g. [550]), a range {"from": 400, "to": 800, "step": 2}, or "spectroscopic" = every wavelength of the design's wavelength_range (OpenFilters' spectroscopic option: br…

### `thermal_sensitivity` (~791 tokens)

Thermal sensitivity of a peak

How the peak of R or T nearest `near` (default the center wavelength; e.g. a band-pass line) moves
when each material's index or thickness changes: d(lambda)/dn in nm per refractive-index unit and
d(lambda)/d(strain) in nm per unit relative thickness change, for all layers of that material
(half-maximum centre, central differences). These do not depend on any thermal property, so they can be
combined with measured dn/dT later. With `thermal`, also d(lambda)/dT in pm/K, each material's
contribution, kelvin per FWHM (the heating that moves the peak by its width) and, per material, the dn/dT
that would make the peak athermal.

Input parameters:

- `angle` (number)
- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `near`
- `polarization`: "s", "p", "unpolarized", or a polarization angle psi in degrees from 0 to 90 (as in the OpenFilters dialogs: R = sin^2(psi) Rs + cos^2(psi) Rp; 0 = p, 90 = s, 45 = unpolarized)
- `quantity` (string)
- `thermal`
- `window`: Where to look for the peak first, {"from": 507, "to": 557, "step": 0.05}; default near +/- 25 nm. It is widened if the peak does not fit and then refined to FWHM/500.

### `thermal_sweep` (~998 tokens)

Thermal tuning sweep

The peak of R or T nearest `near` at each temperature change delta_T (K, relative to the temperature the
design's materials and thicknesses describe), with every material's dn/dT, dk/dT and thickness strain
applied together: half-maximum centre, peak wavelength and value, FWHM; a linear fit gives
d(lambda)/dT in pm/K. The model is linear in temperature: check it against measurements over wide ranges.

Input parameters:

- `angle` (number)
- `delta_T` (array, required)
- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `near`
- `plot` (boolean)
- `polarization`: "s", "p", "unpolarized", or a polarization angle psi in degrees from 0 to 90 (as in the OpenFilters dialogs: R = sin^2(psi) Rs + cos^2(psi) Rp; 0 = p, 90 = s, 45 = unpolarized)
- `quantity` (string)
- `thermal` (object, required): Thermal properties: {"materials": {"TiO2": {"dn_dT": -1e-4, "cte": 5e-6, "poisson": 0.27, "dk_dT": 0}, "SiO2": {"dn_dT": 1e-5, "cte": 0.5e-6, "poisson": 0.17}}, "substrate_cte": 0.55e-6, "clamped": t…
- `window`: Where to look for the peak first, {"from": 507, "to": 557, "step": 0.05}; default near +/- 25 nm. It is widened if the peak does not fit and then refined to FWHM/500.

### `evaluate_design` (~765 tokens)

Evaluate a design

Merit (chi^2, OpenFilters' definition) of a design against targets, with per-target pass
fraction and maximum deviation. all_targets_met is true when every point meets its target (inequalities must hold;
"equal" targets must be within tolerance).

Input parameters:

- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `plot` (boolean)
- `targets` (array, required): Targets, each {"kind": "R"|"T"|"A"|"R_phase"|"T_phase"|"R_GD"|"T_GD"|"R_GDD"|"T_GDD", "angle": 0, "polarization": "unpolarized"|"s"|"p" or an angle psi in degrees (0 = p, 90 = s), then either "wavele…

### `layer_sensitivity` (~861 tokens)

Layer sensitivity

Change in merit (delta_chi2) and in worst margin when each layer thickness changes by +/- relative_step
(default 1 %; the worse direction), to find the layers that need the tightest deposition control.
worst_margin is the smallest distance to a limit over all target points in units of each point's
tolerance (positive = met; e.g. 0.5 with tolerance 0.001 means 0.0005 inside the limit). It ranks layers
of a design that meets its inequality targets with room to spare, where the merit stays 0.
A graded layer is scaled as a whole (every step by the same factor: a deposition-rate error).
most_sensitive lists the top layers.

Input parameters:

- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `relative_step` (number)
- `targets` (array, required): Targets, each {"kind": "R"|"T"|"A"|"R_phase"|"T_phase"|"R_GD"|"T_GD"|"R_GDD"|"T_GDD", "angle": 0, "polarization": "unpolarized"|"s"|"p" or an angle psi in degrees (0 = p, 90 = s), then either "wavele…

### `optimize_design` (~1149 tokens)

Optimize a design

Optimize a design with OpenFilters: method "refine" (thicknesses only), "needle" (refine and
insert new layers until no improvement) or "step" (graded/step index, needs a mixture material).
Waits up to wait_seconds (max 45); if not finished, returns a job_id to poll. Returns the best design found
(not merely the last), stop_reason with a plain stop_explanation, thinnest_layer_nm,
and an .ofp project (start + optimized) openable in OpenFilters. thin_layers_removed counts layers removed
while enforcing min_thickness (a layer held at the minimum is dropped when that does not worsen the merit;
removed_layers and a warning name them). Layers with "fixed": true (or a fixed formula symbol) are never
changed or removed: use it for functional layers such as electrodes. A warning flags a result that meets its targets on their grid but not between grid points. One run finds a local optimum; for
hard specifications use run_optimization_campaign (many starts). Only FRONT layers are optimized;
back_layers (if any) stay fixed and count in the merit when consider_backside is true.

Input parameters:

- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `method` (string)
- `options`: time_limit (s, default 300), max_iterations, min_thickness (nm; guaranteed in the result: thin layers are clamped or removed and the design re-refined with that bound; a clamped design that already m…
- `targets` (array, required): Targets, each {"kind": "R"|"T"|"A"|"R_phase"|"T_phase"|"R_GD"|"T_GD"|"R_GDD"|"T_GDD", "angle": 0, "polarization": "unpolarized"|"s"|"p" or an angle psi in degrees (0 = p, 90 = s), then either "wavele…
- `wait_seconds` (number)

### `run_batch` (~432 tokens)

Run a parameter sweep

Parameter sweep run in parallel on all cores as a background job.

operation: "spectrum" (args: design, quantities, wavelengths, angles, polarizations, metrics), "evaluate"
(design, target_specs), "optimize" (design, target_specs, method, options), "tolerance", "color".
For "spectrum", give `metrics` to reduce each spectrum to numbers, e.g.
[{"name": "Rmin_vis", "quantity": "R", "from": 400, "to": 700, "stat": "min"}, {"name": "T633",
"quantity": "T", "stat": "at", "wavelength": 633}] (stat: mean|min|max|std|at; optional angle/polarization).
Peak stats for a band-pass: peak_wavelength, peak_value, fwhm and center (middle of the half-maximum
edges), for the peak between from/to or the local peak nearest "near", e.g. {"name": "center", "quantity":
"T", "stat": "center", "near": 532}; fwhm is null when an edge is beyond the computed wavelengths.
To compare several designs, sweep the whole design: template {"design": "$design", ...} with parameters
{"design": [design1, design2, ...]}; rows show each design's "name" (or its position).
mode "grid" = all combinations, "zip" = parallel lists. Returns a job_id; then job_status/get_results
(one row per case with parameters and results; full table in summary.csv).

Input parameters:

- `label` (string)
- `mode` (string)
- `operation` (string, required)
- `parameters` (object, required): e.g. {"n_pairs": [4, 6, 8], "aoi": [0, 15, 30]}
- `template` (object, required): Arguments of the operation, where any value written "$name" (or "${name}" inside a string) is replaced by the swept parameter `name`.

### `run_optimization_campaign` (~529 tokens)

Run an optimization campaign

Many optimizations from different starting designs, in parallel; ranks distinct results (by yield
first when a tolerance stage is requested, then targets met, merit, layer count, total thickness) and
saves the top_n designs as an .ofp project. Starts that converge to the same design are marked
duplicate_of. Pass options min_thickness to avoid unmanufacturable sub-nanometre layers. Returns a job_id.

Input parameters:

- `label` (string)
- `methods` (array)
- `options`: Same as optimize_design options, applied to every optimization (e.g. max_layers, min_thickness, time_limit).
- `random_starts`: Generate starts: {"count": 50, "materials": ["TiO2", "SiO2"], "n_layers": [5, 25], "thickness": [20, 200], "substrate": "BK7", "seed": 1, ...other design keys}. n_layers only sizes the starting desig…
- `starts`: Explicit starting designs.
- `targets` (array, required): Targets, each {"kind": "R"|"T"|"A"|"R_phase"|"T_phase"|"R_GD"|"T_GD"|"R_GDD"|"T_GDD", "angle": 0, "polarization": "unpolarized"|"s"|"p" or an angle psi in degrees (0 = p, 90 = s), then either "wavele…
- `tolerance`: Optional yield stage on the top_n designs: {"n_trials": 200, "thickness_error": {"type": "relative", "sigma": 0.01}, "index_error": {"sigma": 0.005}, "seed": 0}
- `top_n` (integer)

### `tolerance_analysis` (~885 tokens)

Tolerance (yield) analysis

Monte Carlo yield: random thickness (and optional index) errors; a trial passes when every target
is met. Runs in parallel; returns yield with 95 % interval, merit statistics and the failure rate
of each target. Both faces of a two-sided design are perturbed. A graded layer is scaled as a whole
(all its steps by one factor: a deposition-rate error); index_error does not perturb mixtures.

Input parameters:

- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `index_error`: {"sigma": 0.005} relative index error, drawn per material per trial
- `n_trials` (integer)
- `seed` (integer)
- `targets` (array, required): Targets, each {"kind": "R"|"T"|"A"|"R_phase"|"T_phase"|"R_GD"|"T_GD"|"R_GDD"|"T_GDD", "angle": 0, "polarization": "unpolarized"|"s"|"p" or an angle psi in degrees (0 = p, 90 = s), then either "wavele…
- `thickness_error`: {"type": "relative"|"absolute", "sigma": 0.01 (fraction) or nm, "distribution": "normal"|"uniform", "systematic": 0.0 (common relative offset)}
- `wait_seconds` (number)

### `simulate_random_errors` (~1023 tokens)

Simulate random errors

OpenFilters' Preproduction > Simulate random errors: the spread of R, T, A, phase, GD, GDD (and colour)
curves when every layer thickness is off by a random error, without targets (tolerance_analysis gives the
yield against targets instead). Runs OpenFilters' own analysis: front layers only, graded layers shifted
step by step, nb_tests designs. Per quantity: the largest standard deviation and the worst deviation from
the design (where they occur) and samples of design/mean/std_dev/min/max; colour (quantity "color"):
design, mean and worst Lab with the spread in Delta E 2000. Statistics are saved to a CSV (every test too
with save_all_results). Phase, GD and GDD need s or p polarization. Runs within about 50 s: reduce
nb_tests or the wavelengths if it stops.

Input parameters:

- `angle` (number)
- `design` (object, required): Design: {"substrate": "BK7", "incident_medium": "void", "center_wavelength": 550, "substrate_thickness_mm": 1, "layers": [{"material": "TiO2", "thickness": 58.6}, {"material": "SiO2", "qwot": 1}]} wi…
- `illuminant` (string)
- `nb_tests` (integer)
- `observer` (string)
- `plot` (boolean)
- `polarization`: "s", "p", "unpolarized", or a polarization angle psi in degrees from 0 to 90 (as in the OpenFilters dialogs: R = sin^2(psi) Rs + cos^2(psi) Rp; 0 = p, 90 = s, 45 = unpolarized)
- `quantities` (array)
- `sample_points` (integer)
- `save_all_results` (boolean)
- `seed` (integer)
- `show`: What the plots draw, as the dialog's Show boxes: {"all_results": false, "mean": false, "std_devs": null (e.g. 3 for mean +/- 3 sigma), "worst_case": true, "design": true, "targets": false}
- `targets`
- `thickness_error`: {"type": "relative" (value a fraction, 0.01 = 1 %) | "absolute" (value in nm), "value": 0.01 ("sigma" is accepted too), "distribution": "uniform" (within +/- value) | "normal" (sigma = value)}; defau…
- `wavelengths`: {"from": 380, "to": 1100, "step": 1} or an explicit list of wavelengths (nm). Default: the design's wavelength_range if it has one (e.g. from a project), else 380-1100 nm (simulate_random_errors: Ope…

### `job_status` (~36 tokens)

Job status

Progress of a background job (tasks done/total, failures, ETA, output files when done).

Input parameters:

- `job_id` (string, required)

### `list_jobs` (~23 tokens)

List jobs

Most recent background jobs, newest first.

Input parameters:

- `limit` (integer)

### `get_results` (~115 tokens)

Get job results

Result rows of a job (campaigns are ranked best first; batches in task order unless sort_by is
given). Works on partial results while the job is running. include_designs adds the optimized
design JSON of the returned rows. For finished campaigns, plots the top 3 designs against the targets.

Input parameters:

- `descending` (boolean)
- `include_designs` (boolean)
- `job_id` (string, required)
- `plot` (boolean)
- `sort_by`
- `top_n` (integer)

### `cancel_job` (~59 tokens)

Cancel a job

Cancel the pending tasks of a running background job. Reports tasks_done, tasks_still_running
(they finish on their own) and tasks_cancelled (never started); a finished job is left as it is.

Input parameters:

- `job_id` (string, required)

### `load_project` (~192 tokens)

Load an OpenFilters project

Read an OpenFilters .ofp project: returns its designs (as design JSON) and targets.
A relative path or bare name (e.g. "my_ar") is looked up in the data folder's projects directory,
where save_project writes; give the full path for projects elsewhere.
OpenFilters' example projects load as "examples/<name>": examples/AR, examples/Beamsplitter,
examples/Color, examples/Edge, examples/Fourier, examples/Ramp, examples/Rugate.
A design whose graded layers have many steps (rugate filters: thousands) is summarized (steps, index
range, optical thickness per graded layer) and written whole to a design_file: pass
{"design_file": path} as the design to any tool. full_graded_arrays=true returns the arrays instead.

Input parameters:

- `full_graded_arrays` (boolean)
- `path` (string, required)

### `save_project` (~186 tokens)

Save an OpenFilters project

Write designs and their targets to an .ofp project that opens in the OpenFilters GUI.
ALWAYS pass the targets the designs were optimized or evaluated against: the GUI's Design/Optimize
menu stays disabled in a project without targets, so the user could not continue the work there.
Each design becomes ONE filter in the project; a part coated on both faces must be a single design
with back_layers and consider_backside: true (written as BackLayer lines), not two designs.
Keep the fields optimize_design returns in each design (description, needle_materials, layer flags)
and put anything else worth keeping (method, settings, yield) in comment or a design's description.
A relative path is placed in the data folder's projects directory.

Input parameters:

- `comment` (string)
- `designs` (array, required)
- `path` (string, required)
- `targets`

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/bbrunoesteves-mcp-for-openfilters/mcp-for-openfilters#diagnostics

## Score history

- 2026-11-21: 83
- 2026-11-20: 82
- 2026-11-19: 82
- 2026-11-18: 66
- 2026-11-17: 81
- 2026-11-16: 65
- 2026-11-15: 80
- 2026-11-14: 64
- 2026-11-13: 79
- 2026-11-12: 63
- 2026-11-11: 78
- 2026-11-10: 61
- 2026-11-09: 61
- 2026-11-08: 61
- 2026-11-07: 61
- 2026-11-06: 61

## Common questions

### What is the MCP for OpenFilters server?

MCP for OpenFilters is listed in the public MCP registry as io.github.BBrunoEsteves/mcp-for-openfilters. Design, simulate and optimize optical thin-film coatings with the OpenFilters engine. This page covers its PyPI package (mcp-for-openfilters).

### Is the MCP for OpenFilters server safe to use?

MCP for OpenFilters scores 83 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the MCP for OpenFilters server expose?

MCP for OpenFilters exposes 28 tools: server_info, list_materials, get_material_index, add_material, remove_material, and 23 more. Their descriptions and schemas cost roughly 13,311 tokens of context every time the server is loaded.

### Is the MCP for OpenFilters server still maintained?

MCP for OpenFilters is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the MCP for OpenFilters server under?

MCP for OpenFilters declares the GPL-2.0-or-later licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the MCP for OpenFilters server?

VerifyMCP ran 16 checks on MCP for OpenFilters, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/mcp-for-openfilters/
- Socket report: https://socket.dev/pypi/package/mcp-for-openfilters
- Repository: https://github.com/BBrunoEsteves/mcp-for-openfilters
- Changelog RSS feed: https://verifymcp.io/servers/bbrunoesteves-mcp-for-openfilters/mcp-for-openfilters.xml
- Changelog JSON feed: https://verifymcp.io/servers/bbrunoesteves-mcp-for-openfilters/mcp-for-openfilters/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/bbrunoesteves-mcp-for-openfilters/mcp-for-openfilters.json
- HTML version of this page: https://verifymcp.io/servers/bbrunoesteves-mcp-for-openfilters/mcp-for-openfilters
