Skip to main content
Glama
rnv-color-mcp

rnv-color-mcp

Official

title: RNV Color MCP emoji: 🎨 colorFrom: gray colorTo: yellow sdk: docker app_port: 7860 pinned: false short_description: Color workflow MCP server

RNV Color MCP

rnv-color-mcp MCP server Mentioned in Awesome MCP Servers tests

A remote MCP server for a complete color workflow: mix, convert, harmonize, and remember palettes, called in plain language by Claude (or any MCP client), and by anything else that speaks MCP.

Related MCP server: MCP Color Server

Why this exists

The color logic already lived in my desktop suite: a mixer, a palette manager, a picker. Instead of rebuilding it for every new project, I lifted the engine out once and exposed it as a single server. A Claude conversation calls it today; a fashion design app will call the same backend tomorrow. Build the engine once, let both consume it.

Underneath, it's a small thesis about working with LLMs: a model is great at deciding what you want and terrible at exact arithmetic. So the model picks the tool and the intent, and the tool owns the precise values. The server resolves or it refuses; it never guesses a color.

What it does

Tool

What it does

mix_colors

Blend up to 12 colors. Modes: rgb, hsv, lab (digital) and paint (Kubelka-Munk pigment physics), ryb (artist's wheel), cmy (subtractive).

convert_color

Convert between hex, rgb, hsv, hsl, lab.

place_lightness

Hold a color's hue and chroma; set its lightness. One hue at two L* values is a light/dark pair. Refuses out-of-gamut rather than clamping, and reports the 8-bit quantization error.

generate_harmony

complementary, analogous, triadic, split-complementary, tetradic/square, monochromatic, compound.

color_difference

Perceptual difference (Delta-E, CIEDE2000 or CIE76) between two colors.

contrast_check

WCAG contrast ratio plus AA/AAA pass/fail for accessible text.

transform_text

11 exact case transforms (UPPERCASE, camelCase, snake_case, …).

save_palette / list_palettes / get_palette

Name a palette, recall it later. Persists across restarts.

Every color input accepts a hex (#d2bc93), a CSS name (red), an RNV brand name (brand gold, near-black), or a saved-palette reference (Spring line, or Spring line:2 for its second swatch). Brand names win over CSS names on collision (gold, blue, teal); css:blue forces the universal one.

Connect in 30 seconds

This is a hosted server, so there's nothing to install. In Claude: Settings → Connectors → Add custom connector, then paste:

https://rnvizion-rnv-color-mcp.hf.space/mcp

Leave auth blank, add it, then toggle it on in a chat with the + menu.

Try it

Once connected, just talk:

"Save a palette named Spring line: near-black and brand gold." "Pull my Spring line palette and give me three complementary accents for outerwear." "Mix crimson and royalblue like real pigment."

The first call saves; the second composes get_palette → generate_harmony; the third runs the Kubelka-Munk paint model, so the blend darkens the way mixed pigment actually does, not the way averaged light does.

Authentication

The server implements OAuth 2.1 resource-server authentication with enforced per-tool scopes; the public endpoint runs with it disabled, so connecting by URL works with no setup.

When enabled (RNV_AUTH=1 plus a key source), the server validates bearer tokens against issuer, audience, expiry, and signature; serves RFC 9728 protected resource metadata at /.well-known/oauth-protected-resource/mcp; returns a spec-compliant WWW-Authenticate challenge on 401; and enforces two scopes: read covers every read-only tool, write covers save_palette, the only tool that mutates anything. A token without the write scope does not see save_palette in its tool list at all; out-of-scope tools are hidden rather than refused, so nothing leaks about what exists behind a scope you lack.

Enforcement is covered by the test suite, run in CI on every push (status badge at the top of this file), spanning the token-validation matrix (missing, malformed, wrong issuer, wrong audience, expired, valid) and end-to-end scope enforcement over real HTTP. The suite mints its own keys and requires no credentials. Beyond auth, it pins parts of the engine: the brand vocabulary mirror; the contrast, difference and placement contract; selector and input refusals; color-name resolution; what the mix modes compute; the hsv and hsl conversions; the palette write path; store durability. Harmony and text outputs are exercised by the smoke scripts and are not yet under regression test.

Moving from the self-issued development key to a real identity provider is configuration, not code: point RNV_AUTH_JWKS_URI at the provider's JWKS endpoint and set the issuer and audience to match.

Variable

Purpose

RNV_AUTH

The switch. 1 / true / yes / on enables auth; unset means off.

RNV_AUTH_JWKS_URI

A provider's JWKS endpoint. Use this or RNV_AUTH_PUBLIC_KEY.

RNV_AUTH_PUBLIC_KEY

A static PEM public key, for development against a self-issued keypair.

RNV_AUTH_ISSUER

Expected token issuer; also advertised as the authorization server.

RNV_AUTH_AUDIENCE

Expected token audience. Bound to the /mcp path.

RNV_AUTH_BASE_URL

Server base URL, without /mcp.

With RNV_AUTH on and no key source set, the server refuses to start rather than coming up unprotected.

Run it yourself

pip install -r requirements.txt
python server.py                  # Streamable HTTP on $PORT (default 7860)

pip install -r tests/requirements-dev.txt
python -m pytest                  # the suite; needs no credentials
python tests/server_test.py       # smoke: exercises every tool in-process

Set HF_TOKEN to write palettes through to a private Hugging Face Dataset for durable storage. The suite and both smoke scripts ignore HF_TOKEN and use a throwaway store, so they can never write to a real Dataset.

Running a copy?

The code is MIT-licensed; you're free to rebuild, host, and modify it, and I'd rather you did than didn't. What a license can't carry is the environment.

Some capabilities depend on how a deployment is configured, not on the code alone:

  • Palette persistence needs HF_TOKEN and a writable Dataset. Without it, saves land in the container's local working copy and vanish with it; save_palette returns durable: false with a durable_reason naming the step that stopped it.

  • Scoped authorization needs RNV_AUTH and a configured issuer. Unset, the server runs open — which is correct for a public demo and wrong for anything else.

  • Anything that fetches needs outbound network access.

A rebuild missing one of those usually doesn't fail loudly; it returns success and drops the result. That is worse than an outage, because an outage tells you.

So: if you're running a copy and something behaves oddly, check the environment before you check the code, and check against the canonical deployment before you file anything.

Canonical endpoint: https://rnvizion-rnv-color-mcp.hf.space/mcp Canonical source: https://github.com/RNVizion/rnv-color-mcp

A copy served from another URL may be older, modified, or differently configured. That's fine and allowed; it just isn't this.

The tools resolve or refuse; they don't guess. A copy can only keep that promise if the ground under it was checked first.

Notes

  • Brand colors are mirrored, not owned. The vocabulary lives in engine/brand_vocab.py, mirrored from engine/brand.py in RNVizion/rnv-brand and corrected when drift is detected against it. It is carried locally on purpose: resolve_color is the hot path, and a fetch there would have to answer what happens when it fails — fail closed and the server refuses every color, fall back and the local copy is needed anyway, guess and the promise above is already broken. Identifiers match upstream's since the register retired local names on 2026-08-17; the check compares values. A scheduled job compares the mirror with upstream daily and gates nothing. The register and its reasoning live in BRAND_COLORS.md, in rnv-brand.

  • Engine is dependency-free. The color math, harmony, and text logic are pure standard library, lifted Qt-free from the desktop apps. Only the server layer needs fastmcp.

  • Honest by design. An unknown color name is refused, not guessed. An unverifiable token is refused, with a reason. Same principle at both layers.

Stack

Python · FastMCP (Streamable HTTP) · Hugging Face Spaces (Docker) · huggingface_hub for durable palette storage.


Built by Christian "RNVizion" Smith.

Available Tools

9 tools
color_differenceAInspect

Perceptual difference (Delta-E) between two colors. color1 and color2 accept a hex, CSS name, RNV brand name, or saved-palette reference. method is 'ciede2000' (default, modern standard) or 'cie76'. A value near 1.0 is the threshold the eye can just notice; larger means more different. Returns the value and a plain-language interpretation.

Inputs: color1 (required), color2 (required), method. Returns: object

contrast_checkAInspect

WCAG contrast ratio between a foreground and background color, for accessibility. Both accept a hex, CSS name, RNV brand name, or saved-palette reference. Returns the ratio (1.0-21.0) plus pass/fail for AA and AAA at normal and large text sizes and for UI components. Use this to check if text will be readable on a background.

Inputs: background (required), foreground (required). Returns: object

convert_colorAInspect

Convert a color between formats. Input accepts a hex, CSS name, RNV brand name, or saved-palette reference. With to set to one of hex/rgb/hsv/hsl/lab, returns just that format; otherwise returns all of them.

Inputs: color (required), to. Returns: object

generate_harmonyAInspect

Generate a color harmony from a base color. base accepts a hex, CSS name, RNV brand name, or saved-palette reference (e.g. 'Spring line:2'). scheme is one of: complementary, analogous, triadic, split-complementary, tetradic (a.k.a. square), monochromatic, compound. Returns a list of hex colors.

Inputs: base (required), scheme (required). Returns: result

get_paletteAInspect

Retrieve one saved palette by name, returning its colors and metadata. Returns null if no palette by that name exists.

Inputs: name (required). Returns: result

list_palettesAInspect

List every saved palette as name + colors.

Inputs: no named parameters. Returns: result

mix_colorsAInspect

Blend up to 12 colors into one. Each color may be a hex (#d2bc93), a CSS name (red), an RNV brand name (brand gold, near-black), or a saved-palette reference (Spring line, or 'Spring line:2' for its 2nd swatch). Optional integer weights bias the blend (defaults to equal). mode selects the model: rgb/hsv/lab are digital blends (lab is perceptual and the default); paint mixes pigments via Kubelka-Munk physics (colors darken like real paint); ryb is the artist's color wheel; cmy is subtractive like printer inks. Returns hex and rgb.

Inputs: colors (required), mode, weights. Returns: object

save_paletteAInspect

Save (or update) a named palette for later reuse, e.g. a launch line. colors is a list of hex values; optional notes are stored as the palette's description. Author is recorded as RNVizion.

Inputs: name (required), colors (required), notes. Returns: object

transform_textAInspect

Apply an exact, deterministic text transformation. operation is one of: UPPERCASE, lowercase, 'Title Case', 'Sentence case', camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, dot.case, 'iNVERTED cASE'. Use this rather than converting case by hand.

Inputs: text (required), operation (required). Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 9 tools

    Disambiguation3/5

    Most tools have clear, distinct purposes related to color operations. However, the inclusion of 'transform_text' is unrelated to color and could confuse agents about the server's domain. Palette retrieval tools (get_palette, list_palettes) are similar but distinct.

    Naming Consistency4/5

    All tool names consistently use the verb_noun pattern in snake_case (e.g., 'convert_color', 'list_palettes'). The exception is 'transform_text', which breaks the pattern both in verb domain and object, but the naming style is still consistent.

    Tool Count4/5

    With 9 tools, the server covers a reasonable scope of color operations plus palette management. The count is slightly elevated due to the unrelated 'transform_text' tool, but overall it's well-scoped for a color utility server.

    Completeness3/5

    The server provides core color functionalities (difference, contrast, conversion, harmony, mixing) and palette CRUD with save/update and get/list, but lacks a delete palette operation. The inclusion of 'transform_text' is a significant gap as it is outside the color domain and does not contribute to completeness.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol server that provides color conversion between multiple color spaces including RGB, RGBA, HEX, HSL, OKLCH, LAB, and CMYK.
      547 npm
      2
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Enables comprehensive color manipulation, conversion between 22+ formats (HEX, RGB, HSL, CMYK, LAB, etc.), palette generation, gradient creation, and accessibility compliance checking. Supports framework-specific outputs for CSS, Swift, Android, Flutter, and Tailwind with high-precision conversions and visualization capabilities.
      25
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides comprehensive color conversion, manipulation, analysis, and WCAG accessibility tools supporting multiple formats (hex, rgb, hsl, oklch, oklab) for design systems and web development.
      23 npm
      2
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A comprehensive toolkit for color conversion, manipulation, and accessibility analysis supporting formats like OkLCH and WCAG compliance. It enables AI agents to manage design systems by generating harmonious palettes, transforming color spaces, and performing contrast checks.
      2
      MIT