# Ottoref — Standards MCP Server (npm · standards-mcp-server)

ISO 286 limits and fits, ISO 2768 tolerances, material properties, and process limits.

- Trust score: 81/100 (high trust)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-04

## Components

- npm · `standards-mcp-server`: 81/100 (this document), [markdown](https://verifymcp.io/servers/ottonic-standards-mcp-server/standards-mcp-server.md), [page](https://verifymcp.io/servers/ottonic-standards-mcp-server/standards-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `standards-mcp-server`
- Version: `0.3.0`
- 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-04.

- **Supply Chain Security**: 99/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 4 of 16 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to ottonic/standards-mcp-server).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 4 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 76/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 1664 tokens (~138/item across 12 items; 12 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **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.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 12 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 13 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).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Ottoref — Standards MCP Server server?

Ottoref — Standards MCP Server runs locally as an npm package, launched with npx -y standards-mcp-server. 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 ottonic-standards-mcp-server -- npx -y standards-mcp-server
```

### Cursor

```json
{
  "mcpServers": {
    "ottonic-standards-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "standards-mcp-server"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ottonic-standards-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "standards-mcp-server"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add ottonic-standards-mcp-server -- npx -y standards-mcp-server
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add ottonic-standards-mcp-server --command npx --arg -y --arg standards-mcp-server
```

### Hermes

```yaml
mcp_servers:
  ottonic-standards-mcp-server:
    command: "npx"
    args: ["-y", "standards-mcp-server"]
```

### Netclaw

```json
{
  "McpServers": {
    "ottonic-standards-mcp-server": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "standards-mcp-server"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add ottonic-standards-mcp-server -t stdio -c npx -a -y standards-mcp-server
```

### Other

```json
{
  "mcpServers": {
    "ottonic-standards-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "standards-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-11-01 (score 81, +10)

- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → 0.90

### 2026-10-31 (score 71)

First indexed and scored.

## MCP tools (12)

### `list_standards` (~89 tokens)

List Standards Coverage

List the standards this server implements, and what within each one is not covered. Call this first when a question mentions a standard, so you know whether the value you need is available before you promise an answer. Coverage is partial by design: unimplemented values are refused with a stated reason rather than approximated. Use iso286_applicability for exact size intervals of an ISO 286 class.

### `limits_of_size` (~119 tokens)

Limits of Size for a Tolerance Class

Return the upper and lower deviations, and the resulting limits, for one tolerance class at one nominal size, such as 36H7 or 36g6. Uppercase is a hole, lowercase a shaft. Values are millimetres and are deviations from the nominal size. Use this to interpret a toleranced dimension; whether the resulting limits suit a joint is an engineering decision.

Input parameters:

- `designation` (string, required): Tolerance class, e.g. H7 or g6.
- `nominal` (number, required): Nominal size in millimetres.

### `iso286_applicability` (~81 tokens)

Check ISO 286 Class Applicability

List the exact nominal-size intervals where one ISO 286 tolerance class is supported, such as H7, j5 or N9. Use this before relying on a class across a size range; omitted intervals are not inferred.

Input parameters:

- `designation` (string, required): Tolerance class in standard notation, e.g. H7, j5 or N9.

### `fit` (~157 tokens)

Fit Between a Hole and a Shaft

Return the resulting fit between one hole class and one shaft class at the same nominal size, such as 12 H7/h6: the type (clearance, transition or interference), the minimum and maximum clearance, and the maximum interference. Values are millimetres. A negative minimum clearance means the fit can interfere. This reports the geometry of the fit, not whether it is the right choice for a joint, which depends on function and is the caller's decision.

Input parameters:

- `hole` (string, required): Hole tolerance class, e.g. H7.
- `nominal` (number, required): Nominal size in millimetres, shared by the hole and shaft.
- `shaft` (string, required): Shaft tolerance class, e.g. g6 or n6.

### `it_grade` (~103 tokens)

Standard Tolerance Grade Value

Return the standard tolerance value for one IT grade at one nominal size, in micrometres and millimetres, with the size step it came from. Use this when a drawing or a calculation needs the tolerance width itself, rather than the limits of a specific class.

Input parameters:

- `grade` (string, required): Standard tolerance grade in ISO notation: IT01, IT0, or IT1 to IT18.
- `nominal` (number, required): Nominal size in millimetres.

### `general_tolerance` (~173 tokens)

ISO 2768-1 General Tolerance

Return the deviation that a general-tolerance note such as ISO 2768-m implies for one dimension, so an unmarked dimension can be checked. The tables differ by what they cover: linear dimensions, broken edges (external radii and chamfer heights), and angular dimensions, which are keyed by the shorter side of the angle rather than the nominal size. A general tolerance applies only where the drawing gives no individual tolerance, so check for one first.

Input parameters:

- `kind` (string): Which table to read: linear dimensions (default), broken edges such as chamfers and external radii, or angular dimensions. They have different values.
- `nominal` (number, required): Nominal size, or the shorter side of an angle.
- `tolerance_class` (string, required): Class letter from the drawing note, e.g. m.

### `general_tolerance_complies` (~158 tokens)

Check a Deviation Against an ISO 2768-1 Note

Compare a stated deviation numerically against the ISO 2768-1 general-tolerance value for one dimension. This is only a numeric comparison: first establish that the dimension has no individual tolerance indication, because the general tolerance applies only to unmarked dimensions. The result does not establish process capability.

Input parameters:

- `kind` (string): Which table applies. Default: linear.
- `nominal` (number, required): Nominal size, or the shorter side of an angle.
- `stated_deviation` (number, required): The deviation the drawing actually states for this dimension, in millimetres (or degrees for angular). Sign is ignored: the tables are symmetric.
- `tolerance_class` (string, required): Class letter from the drawing note, e.g. m.

### `material_properties` (~186 tokens)

Material Properties (Typical Values)

Look up indicative material properties for a common metal or plastic by designation, such as 6061-T6, 304 or Ti-6Al-4V. Returns density, yield and ultimate strength, Young's modulus, Poisson's ratio, elongation, thermal expansion and maximum service temperature, all in SI. These are TYPICAL handbook values, not design allowables: every value is tagged basis: typical. Use them to compare materials, estimate mass, or supply an indicative modulus to an analysis; obtain an allowable from a qualified source before relying on a strength margin. An unmatched designation means this reference does not hold it, not that the material does not exist.

Input parameters:

- `material` (string, required): Material designation, e.g. "6061-T6" or "304".
- `property` (string): Restrict the answer to one property, so the response stays small.

### `material_coverage` (~74 tokens)

What Material Data Is Held

List what the material reference holds and what it does not. Call this when a material was not found, or before promising a property, so a gap is visible rather than assumed. The reference is limited to typical values for common metals and plastics: it holds no design allowables, no fatigue data and no high-temperature data.

### `process_limits` (~99 tokens)

Manufacturing Process Limits

Describe what a manufacturing process can hold: minimum wall thickness, minimum hole-to-edge and hole-to-bend distances, minimum internal corner radius, bend radius, draft angle, pocket depth-to-width ratio. Call process_feasibility to test one measured feature against these. These are published rules of thumb for geometric feasibility, not a specific shop's capability, and they say nothing about cost or lead time.

Input parameters:

- `process` (string, required): Which process to describe.

### `process_feasibility` (~212 tokens)

Check a Feature Against Process Limits

Compare one measured feature against a manufacturing process's limits and report whether it is within, marginal, or beyond them. Some limits are expressed as a ratio of material thickness rather than an absolute size — a 1 mm hole is fine in thin sheet and difficult in thick plate — so supply the thickness when the limit needs it. A result inside the limits is not a promise that a shop can make the part, or an estimate of what it costs. Pair this with a measured wall or hole size from a CAD server to answer whether a part suits a process.

Input parameters:

- `feature` (string, required): Which limit to check.
- `measured` (number, required): The measured value for the feature, in millimetres (or degrees for draft).
- `process` (string, required): Which process the feature is being made by.
- `thickness` (number): Material thickness in millimetres. Required when the limit is expressed as a ratio of thickness, which is common for sheet metal — the error says so if it is missing.

### `process_list` (~46 tokens)

List Manufacturing Processes

List the manufacturing processes this server has limits for, and which features each one covers. Call this first when a question names a process, so an unsupported process is visible before a check fails.

## Diagnostics

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

## Score history

- 2026-11-04: 81
- 2026-11-03: 81
- 2026-11-02: 81
- 2026-11-01: 81
- 2026-10-31: 71

## Common questions

### What is the Ottoref — Standards MCP Server server?

Ottoref — Standards MCP Server is listed in the public MCP registry as io.github.ottonic/standards-mcp-server. ISO 286 limits and fits, ISO 2768 tolerances, material properties, and process limits. This page covers its npm package (standards-mcp-server).

### Is the Ottoref — Standards MCP Server server safe to use?

Ottoref — Standards MCP Server scores 81 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 4 November 2026. It declares no install or post-install scripts. 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 Ottoref — Standards MCP Server server expose?

Ottoref — Standards MCP Server exposes 12 tools: list_standards, limits_of_size, iso286_applicability, fit, it_grade, and 7 more. Their descriptions and schemas cost roughly 1,497 tokens of context every time the server is loaded.

### Is the Ottoref — Standards MCP Server server still maintained?

Ottoref — Standards MCP Server is still listed as active in the MCP registry. We last reached this channel on 4 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 Ottoref — Standards MCP Server server under?

Ottoref — Standards MCP Server declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/standards-mcp-server
- Socket report: https://socket.dev/npm/package/standards-mcp-server
- Repository: https://github.com/ottonic/standards-mcp-server
- Changelog RSS feed: https://verifymcp.io/servers/ottonic-standards-mcp-server/standards-mcp-server.xml
- Changelog JSON feed: https://verifymcp.io/servers/ottonic-standards-mcp-server/standards-mcp-server.json
- HTML version of this page: https://verifymcp.io/servers/ottonic-standards-mcp-server/standards-mcp-server