Which integrations are available for this server?

Integrates with Codecov for test coverage reporting and monitoring as part of the project's CI/CD pipeline, though this appears to be a development/testing integration rather than a core MCP server capability. Hosts the project repository and provides CI/CD workflows for testing and publishing the MCP server, though this appears to be a development infrastructure integration rather than a core MCP server capability. Built on the ucon dimensional analysis engine for Python, providing unit-aware computation capabilities through Python's scientific computing ecosystem, though this is an implementation detail rather than a service integration.

de en es ja ko ru zh

ucon-mcp

by the-radiativity-company

Overview Schema Source Related Servers Discussions Admin

Python

Hybrid

ucon-tools

tests codecov publish

Hostable interfaces for the ucon dimensional analysis engine.

Documentation · MCP Server Guide · Tool Reference

What is ucon-tools?

ucon is a unit-aware computation library for Python. ucon-tools packages it into interfaces that other systems can consume — MCP servers for AI agents, REST APIs for web services, CLIs for humans at a terminal.

Each interface lives under ucon.tools.<interface> and is installable as an optional extra:

Interface	Package	Extra	Status
MCP server	`ucon.tools.mcp`	`ucon-tools[mcp]`	Available
REST API	`ucon.tools.rest`	`ucon-tools[rest]`	Planned
CLI	`ucon.tools.cli`	`ucon-tools[cli]`	Planned

Related MCP server: Touchstone MCP Server

MCP Server

The MCP server gives AI agents (Claude, Cursor, and other MCP clients) dimensionally-verified unit conversion and computation.

Agent: "Convert 5 mcg/kg/min for an 80 kg patient to mL/h. Drug is 400 mg in 250 mL."

  decompose → constraint solver places quantities, auto-bridges mcg→mg and min→h
  compute   → 5 × 80 kg × (60 min/h) × (1 mg/1000 mcg) × (250 mL/400 mg) = 15 mL/h
  validate  → result dimension matches expected unit ✓

Installation

pip install ucon-tools[mcp]

Requires Python 3.10+.

Configuration

Claude Desktop / Claude Code — add to your MCP configuration:

{
  "mcpServers": {
    "ucon": {
      "command": "uvx",
      "args": ["--from", "ucon-tools[mcp]", "ucon-mcp"]
    }
  }
}

Standalone:

ucon-mcp                    # stdio transport (default)
ucon-mcp --transport sse    # SSE transport for remote clients

Tools

Core — conversion and computation:

Tool	Description
`convert`	Convert a value between compatible units
`compute`	Multi-step factor-label calculation with dimensional tracking
`decompose`	Build a factor chain from natural-language or structured input
`check_dimensions`	Check if two units share the same dimension

Discovery — explore the unit system:

Tool	Description
`discover`	Unified discovery across topics: units, scales, dimensions, constants, formulas, quantity kinds, kind formulas, extended bases
`list_units`	Deprecated — use `discover(topic="units")`. List available units, optionally filtered by dimension
`list_scales`	Deprecated — use `discover(topic="scales")`. List SI decimal and binary prefixes
`list_dimensions`	Deprecated — use `discover(topic="dimensions")`. List available physical dimensions
`list_constants`	Deprecated — use `discover(topic="constants")`. List physical constants (CODATA 2022)
`list_formulas`	Deprecated — use `discover(topic="formulas")`. List registered domain formulas

Runtime extension — add units and conversions per session:

Tool	Description
`define`	Unified session definition: units, conversion edges, constants, quantity kinds, extended bases (`kind="unit"` \| `"conversion"` \| `"constant"` \| `"quantity_kind"` \| `"basis"`)
`define_unit`	Deprecated — use `define(kind="unit")`. Register a custom unit for the session
`define_conversion`	Deprecated — use `define(kind="conversion")`. Add a conversion edge (linear or affine)
`define_constant`	Deprecated — use `define(kind="constant")`. Define a custom physical constant
`call_formula`	Call a registered dimensionally-typed formula
`reset_session`	Clear all session-defined units, conversions, and constants

Kind-of-Quantity (KOQ) — semantic disambiguation:

Tool	Description
`define_quantity_kind`	Deprecated — use `define(kind="quantity_kind")`. Register a quantity kind, optionally placed in the kind hierarchy
`declare_computation`	Deprecated — use `validate_result(declared_kind=...)`. Declare expected quantity kind before computing
`validate_result`	Validate that a result matches the declared kind (dimension and kind)
`list_quantity_kinds`	Deprecated — use `discover(topic="quantity_kinds")`. List built-in and session-defined quantity kinds
`list_kind_formulas`	Deprecated — use `discover(topic="kind_formulas")`. List kind-arithmetic rules from the FormulaRegistry
`extend_basis`	Deprecated — use `define(kind="basis")`. Create an extended dimensional basis
`list_extended_bases`	Deprecated — use `discover(topic="extended_bases")`. List session-defined extended bases

Unit systems — inspect and scope the active system:

Tool	Description
`system`	Unified system operations: restrict, diff, compatibility check (`action="restrict"` \| `"diff"` \| `"check_compatibility"`)
`restrict_system`	Deprecated — use `system(action="restrict")`. Restrict the active system to named units/dimensions
`diff_systems`	Deprecated — use `system(action="diff")`. Compare the session system against the process-base system
`check_compatibility`	Deprecated — use `system(action="check_compatibility")`. Check if the session system composes with the process-base without conflict

All deprecated tools remain functional until v1.0.0 and return identical payloads to their replacements, leaving a ten-tool surface: convert, compute, decompose, check_dimensions, discover, define, system, call_formula, validate_result, reset_session. See ROADMAP.md for the migration table and what lands before then.

Architecture

The MCP server is embeddable: create_server(ServerConfig(...)) builds an independent server with your own base unit system, per-call instrumentation, and transport settings — see the embedding guide.

ucon-tools is an interface layer. It does not reimplement dimensional analysis — it delegates to ucon for all unit resolution, conversion, and dimensional algebra. What it adds is interface-specific logic: session state, protocol handling, error suggestions, and agent-oriented features like the decompose constraint solver and KOQ disambiguation.

┌───────────────────────────────────────────────────────┐
│                     Clients                           │
│   MCP (Claude, Cursor)  ·  HTTP  ·  Terminal          │
└──────────┬──────────────────┬──────────────┬──────────┘
           │                  │              │
┌──────────▼───┐   ┌──────────▼───┐  ┌───────▼──────┐
│ ucon.tools   │   │ ucon.tools   │  │ ucon.tools   │
│     .mcp     │   │     .rest    │  │     .cli     │
│              │   │              │  │              │
│  sessions    │   │  (planned)   │  │  (planned)   │
│  decompose   │   │              │  │              │
│  KOQ         │   │              │  │              │
│  suggestions │   │              │  │              │
└──────┬───────┘   └──────┬───────┘  └──────┬───────┘
       │                  │                 │
       └──────────────────┼─────────────────┘
                          │ Python imports
               ┌──────────▼──────────┐
               │        ucon         │
               │                     │
               │  Units, Dimensions  │
               │  ConversionGraph    │
               │  Scales, Constants  │
               └─────────────────────┘

UnitSafe Benchmark

UnitSafe is a 500-problem metrological reasoning benchmark for evaluating how well AI models handle unit conversion, dimensional analysis, and kind-of-quantity discrimination. It ships with a runner that can evaluate any model with or without MCP tool augmentation.

pip install ucon-tools[benchmark]

# Bare evaluation (model solves from memory)
python benchmarks/unitsafe/run.py -m claude:claude-haiku-4-5-20251001

# Tool-augmented evaluation (model uses MCP tools)
python benchmarks/unitsafe/run.py -m claude:claude-haiku-4-5-20251001 \
  --tools --mcp-url https://mcp.ucon.dev/mcp/<instance>/mcp

See benchmarks/unitsafe/ for the full dataset, runner, and evaluation protocol.

Development

make venv                               # Create virtual environment
source .ucon-tools-3.12/bin/activate    # Activate
make test                               # Run tests
make test-all                           # Run across all supported Python versions

Running the MCP server locally

make mcp-server                         # Foreground (stdio)
make mcp-server-bg                      # Background
make mcp-server-stop                    # Stop background server

License

AGPL-3.0. See LICENSE.

This server cannot be deployed

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Maintenance

ActivityMaintained

ResponsivenessResponsive

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

Unit & Currency Converter A
io.github.guptaprakhariitr
60+ units, live FX, timezones, and date arithmetic for AI agents.
Finance Location Services
621
arithym AOAuth
xyz.arithym
Precision math engine for AI agents. 203 exact methods. Zero hallucination.
Developer Tools Code Execution Autonomous Agents
12
TinyFn C
io.tinyfn
500+ deterministic tools for AI agents: math, conversion, validation, hashing, encoding, date/time.
Developer Tools
57221
metamodel A
io.github.joegra2003
AI-callable calculators and engineering models with real formulas. No hallucinated math.
Developer Tools AI & Machine Learning
42

Related MCP Servers

mcp-gnu-units
Developer Tools
laszlopere
A
license
A
quality
C
maintenance
Unit converter for AI agents, powered by the GNU units database — convert 3000+ units of measurement, evaluate compound unit expressions, reduce to SI base units, dimensional analysis. Offline, deterministic.
Updated 3 months ago (2026-07-03 07:35 UTC)
6
1
GPL 3.0
Touchstone MCP Server
Developer Tools Code Analysis
savecharlie
A
license
Not graded
quality
C
maintenance
Provides deterministic, verifiable text/code/measurement utilities for AI agents, enabling tasks like unit conversion, citation formatting, diffing, proofreading, readability scoring, and syntax checking with re-executable proof.
Updated 3 months ago (2026-06-29 18:55 UTC)
MIT
unit-converter
Developer Tools
Br0ski777
A
license
Not graded
quality
B
maintenance
Enables AI agents to convert between measurement units across length, weight, temperature, volume, speed, and data storage, with formulas included. Supports pay-per-call access via x402 micropayments without API keys or signup.
Updated 19 days ago (2026-09-02 19:57 UTC)
MIT
leftbrain
Developer Tools
Lazy-Coder-03
A
license
Not graded
quality
A
maintenance
Provides exact, deterministic tools for math, dates, units, validation, and more to AI agents, returning precise answers with explicit assumptions and warnings instead of model guesses.
Updated 10 days ago (2026-09-11 11:33 UTC)
MIT