# Colour Memory (remote · colour-memory-api-production.up.railway.app)

Cultural color intelligence. Every colour anchored to a person, a year, and a consequence.

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

## Components

- remote · `colour-memory-api-production.up.railway.app`: 76/100 (this document), [markdown](https://verifymcp.io/servers/digbyo-colour-memory/colour-memory-api-production.md), [page](https://verifymcp.io/servers/digbyo-colour-memory/colour-memory-api-production)

## Channel facts

- Endpoint: `https://colour-memory-api-production.up.railway.app/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `2.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, 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.

- **Endpoint Security**: 83/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation is enforced on tool calls, but the challenge carries no valid RFC 9728 metadata, so a client cannot discover where to get a token.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 69/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 12799 tokens (~180/item across 71 items; 71 tools + 0 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.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http digbyo-colour-memory https://colour-memory-api-production.up.railway.app/mcp
```

### Codex

```toml
[mcp_servers.digbyo-colour-memory]
url = "https://colour-memory-api-production.up.railway.app/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "digbyo-colour-memory": {
      "type": "remote",
      "url": "https://colour-memory-api-production.up.railway.app/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add digbyo-colour-memory --url https://colour-memory-api-production.up.railway.app/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  digbyo-colour-memory:
    url: "https://colour-memory-api-production.up.railway.app/mcp"
```

### Other

```json
{
  "mcpServers": {
    "digbyo-colour-memory": {
      "type": "http",
      "url": "https://colour-memory-api-production.up.railway.app/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## 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 76, 0)

- [security] Tool “palette_pdf” rewrote its description, which is the text the model reads
- [security] Tool “agent_brief” rewrote its description, which is the text the model reads
- [cosmetic] “palette_pdf” added an optional parameter “delivery”
- [cosmetic] “archive_report_brief” added an optional parameter “max_family_card_share”
- [cosmetic] “archive_report_brief” added an optional parameter “output_format”
- [cosmetic] “archive_report_brief” added an optional parameter “period_end”
- [cosmetic] “archive_report_brief” added an optional parameter “period_start”
- [cosmetic] “agent_brief” added an optional parameter “avoid”
- [cosmetic] “agent_brief” added an optional parameter “minimum_claim_strength”
- [cosmetic] “archive_report_brief” added an optional parameter “allow_partial”
- [cosmetic] “archive_report_brief” added an optional parameter “confidence_threshold”
- [cosmetic] “archive_report_brief” added an optional parameter “family_card_mode”
- [cosmetic] “palette_pdf” reworded the description of “entries”
- [cosmetic] “agent_brief” reworded the description of “concept”
- [cosmetic] “agent_brief” reworded the description of “locked_palette”

### 2026-08-02 (score 76, +1)

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

### 2026-07-31 (score 75, +5)

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

### 2026-07-30 (score 70, +1)

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

### 2026-07-28 (score 69, +1)

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

### 2026-07-27 (score 68, +1)

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

### 2026-07-26 (score 67)

First indexed and scored.

## MCP tools (71)

### `query_conceptual` (~117 tokens)

Search Colours by Concept or Culture

Ask a cultural, historical, or material colour question. Returns named archive colours with provenance and cultural context. Works for abstract queries like 'grief', 'Ottoman luxury', 'toxic Victorian pigments', or 'the sea at dusk'.

Input parameters:

- `archive` (string): Optional: restrict to a named archive e.g. 'Japan', 'Pigment', 'OttomanEmpire'
- `n_results` (integer): Number of results (default 5)
- `query` (string, required): The colour concept or cultural question to search for

### `query_hex` (~78 tokens)

Find Named Colours by Hex Code

Find the closest named archive colours to a hex value using CIEDE2000 perceptual distance.

Input parameters:

- `archive` (string): Optional: restrict to a named archive
- `hex` (string, required): Hex value with or without # e.g. '#8B4513'
- `n_results` (integer): Number of results (default 5)

### `palette_specify` (~101 tokens)

Specify Colour Palette for a Room

Generate a complete interior specification from 2-8 hex values. Returns surface assignments, 60-30-10 proportions, lighting behaviour, and archive colour names.

Input parameters:

- `colours` (array, required): List of 2-8 hex values
- `room_type` (string): e.g. 'living', 'bedroom', 'kitchen', 'study'
- `style` (string): e.g. 'heritage', 'contemporary', 'minimal'

### `colour_metrics` (~82 tokens)

Get Colour Metrics and Properties

Returns raw perceptual metrics (LRV, chroma, hue angle, warmth, undertone) for a single colour. This is one component of colour_passport. Use colour_passport for a general colour profile; use this only when the user explicitly wants isolated numeric values.

Input parameters:

- `hex_val` (string, required): Hex value e.g. '#8B4513'

### `colour_harmonies` (~62 tokens)

Get Colour Harmonies

Return complementary, triadic, analogous, and split-complementary harmonies matched to named archive colours.

Input parameters:

- `harmony_types` (array): Harmony types to include
- `hex` (string, required): Hex value e.g. '#3A5C8C'

### `accessibility_check` (~64 tokens)

Check WCAG Accessibility

Evaluates contrast for a single foreground/background pair. For palettes or multiple colours, use accessibility_matrix instead, it replaces multiple accessibility_check calls in one response.

Input parameters:

- `background` (string): Background hex (default 'FFFFFF')
- `hex_val` (string, required): Foreground hex value

### `accessibility_matrix` (~99 tokens)

Full Palette Accessibility Matrix

Accept a palette array and return every foreground/background combination with contrast ratio, AA normal, AA large, AAA normal, AAA large pass/fail grades, and a summary. Use this instead of calling accessibility_check multiple times for a palette.

Input parameters:

- `palette` (array, required): Array of hex values e.g. ['#D4A829', '#1A5C6E', '#0F2D6B', '#0A0A0B']

### `accessibility_rules` (~68 tokens)

Accessibility Usage Rules

Convert a palette WCAG matrix into actionable design-system rules. Returns safe pairs, AA-only pairs, large-text-only pairs, decorative-only pairs, best text colour per background, and component usage rules. Deterministic, no LLM cost.

Input parameters:

- `palette` (array, required): Array of hex values

### `colour_slugs` (~83 tokens)

Colour Name Developer Tokens

Return every developer token format for a hex value: CSS variable, kebab-case, camelCase, PascalCase, Tailwind class, TypeScript const, SCSS variable. Archive-grounded name source with dE2000 distance.

Input parameters:

- `archive` (string): Optional archive filter
- `hex` (string, required): Hex value e.g. #D4A829

### `palette_light_dark` (~80 tokens)

Palette Light and Dark Mode Maps

Generate light-mode and dark-mode role maps from a palette. Analyses LRV, assigns background/surface/text/accent roles for each mode, checks body text contrast safety, and flags missing neutrals.

Input parameters:

- `palette` (array, required): Array of hex values
- `use_case` (string): Use case context e.g. UI, dashboard, report

### `accessibility_font` (~65 tokens)

Font Colour Advisor

Given a background hex and a palette of candidate foreground colours, return them ranked by contrast ratio with WCAG grades and specific recommendations for body text, large text, and UI components.

Input parameters:

- `background` (string, required): Background hex value
- `palette` (array, required): Candidate foreground hex values

### `archive_search` (~219 tokens)

Archive Keyword Search

Full-text keyword search across all archive colour names and notes. Find colours by name fragment, material, cultural reference, pigment type, or historical period. Complements conceptual embedding search with exact keyword matching.

Input parameters:

- `archive` (string): Optional archive filter e.g. oxfordshire, japan, pigment, keats, eic, racingsilks
- `include_full` (boolean): Return complete notes and source fields. Default false returns 150-char snippets. Set true for report workflows.
- `limit` (integer): Alias for n_results
- `n_results` (integer): Number of results (default 10, max 50)
- `query` (string, required): Search term e.g. cerulean, Prussian, Ottoman, ochre, medieval
- `year_from` (integer): Boost entries on or after this year e.g. 1400 for Renaissance, 1837 for Victorian
- `year_to` (integer): Boost entries on or before this year e.g. 1600 for Renaissance, 1901 for Victorian

### `colour_combination` (~94 tokens)

Colour Combination Check

Assess 2-5 colours as a combination for a given context (UI, data viz, fashion, interior, print, branding). Returns harmony type, clash warnings, contrast summary, and specific deployment rules for the context.

Input parameters:

- `colours` (array, required): 2-5 hex values to assess as a combination
- `context` (string): Usage context: UI | data viz | fashion | interior | print | branding

### `palette_strict` (~156 tokens)

Strict Archive-Filtered Palette from Concept

Like palette_concept but with archive filtering and relevance controls. Use allowed_archives to restrict results to specific cultural traditions e.g. ['Japan'] for Japanese only. Use min_relevance to filter weak concept matches. Fixes cross-archive drift when cultural specificity matters.

Input parameters:

- `allowed_archives` (array): Archive names to restrict results e.g. ['Japan', 'China']
- `concept` (string, required): Cultural concept e.g. Japanese wabi-sabi
- `include_neutrals` (boolean): Include neutral tones (default true)
- `min_relevance` (number): Minimum relevance score 0-1 (default 0.3)
- `n_colours` (integer): Number of colours (default 5)

### `palette_pdf` (~453 tokens)

Generate Palette PDF

Generate a premium branded PDF specification sheet from a palette of archive entries. Returns a downloadable PDF with full-bleed colour panels, archive names, provenance notes, RAL nearest match, LRV, chroma, WCAG contrast data, and Colour Memory branding. Use this to create client deliverables, specification sheets, and print assets. Two supported entry sources: (1) the flat entries array from query_hex or palette_from_concept -- each item needs name, hex, archive_source, colour_notes, primary_source, zone; or (2) archive_report_brief's output -- pass report['presented_cards'] as entries, NOT report['colour_cards'] (the legacy field is kept only for backward compatibility and does not carry family-card presentation). presented_cards may mix three card shapes, all rendered as exactly one page each regardless of how many underlying records they represent: single_cultivar (a normal flat card), colour_family (card_type='colour_family', many near-identical records summarised as one card with member_count/supported_by/family_delta_e_max), and conservative-mode hero cards (a single_cultivar card carrying family_grouping_suppressed=true and also_supported_by, representing a larger natural family that was folded into one promoted cultivar instead of shown as a group). delivery controls how the PDF is returned: 'url' (default) gives a signed, time-limited R2 download link; 'base64' returns the PDF bytes inline in the response for callers that need the file directly rather than a link.

Input parameters:

- `delivery` (string): 'url' (default): signed, time-limited R2 download link. 'base64': PDF bytes returned inline as pdf_base64 for callers that need the file directly.
- `entries` (array, required): Array of colour cards. Either the flat entries array from query_hex/palette_concept, or report['presented_cards'] from archive_report_brief (single_cultivar, colour_family, and conservative-mode hero…
- `query` (string): Optional title for the palette e.g. Ottoman imperial luxury
- `source` (string): Optional source label e.g. brand, conceptual

### `palette_audit` (~110 tokens)

Palette Quality Audit

Full palette quality audit. Scores on accessibility, cultural risk, tonal balance, colour diversity, and archive naming strength. Returns overall score 0-100, grade, and prioritised fix list. Enterprise quality gate -- use before shipping any palette. Deterministic, no LLM cost.

Input parameters:

- `market` (string): Target market
- `medium` (string): digital | print | both
- `palette` (array, required): Hex values to audit
- `use_case` (string): Use case context

### `brand_system` (~135 tokens)

Complete Brand Colour System

Complete brand colour system in one call. Returns colour roles with archive names, light and dark mode role maps, typography guidance, usage rules per colour, design tokens (CSS, Tailwind, Figma), and citation cards. Deterministic. No LLM cost.

Input parameters:

- `brand_category` (string): Optional e.g. developer tool, luxury, food
- `market` (string): Target market e.g. global, UK, Japan
- `medium` (string): digital | print | both
- `palette` (array, required): Hex values
- `use_case` (string): Use case e.g. brand identity, packaging

### `brand_asset_pack` (~106 tokens)

Brand Asset Pack Export

Complete brand asset pack. Returns CSS variables, Tailwind config, Figma tokens JSON, citation cards, and a Markdown brand guide. Everything a brand team needs to ship. Deterministic. No LLM cost.

Input parameters:

- `brand_category` (string): Optional brand name or category
- `market` (string): Target market
- `medium` (string): digital | print | both
- `palette` (array, required): Hex values
- `use_case` (string): Use case

### `accessibility_simulate` (~56 tokens)

Simulate Colour Blindness

Return simulated hex values for protanopia, deuteranopia, and tritanopia using the Brettel-Vienot-Mollon model.

Input parameters:

- `hex_val` (string, required): Hex value e.g. '#BE0032'

### `colour_match_paint` (~79 tokens)

Match to Commercial Paint System

Find the nearest named colour in commercial paint systems including Farrow and Ball and Little Greene.

Input parameters:

- `brand` (string): Optional brand filter: 'farrow' or 'little_greene'
- `hex_val` (string, required): Hex value e.g. '#003153'
- `n` (integer): Number of matches (default 3)

### `colour_card` (~82 tokens)

Get Colour Details by Name

Look up a named colour and return its hex, archive, provenance, and cultural notes.

Input parameters:

- `name` (string): Colour name e.g. 'Prussian Blue' or 'Ottoman Carbon Ink'
- `slug` (string): Stable colour slug from archive_search e.g. 'keats:keats-s-lung' -- preferred over name for reliable retrieval

### `meta_capabilities` (~60 tokens)

API Capabilities Inventory

Return a live inventory of all active endpoints and MCP tools. Use this first to discover what the API can do before making calls. Returns tool count, endpoint list, MCP-exposed tools, and usage notes. Deterministic -- no LLM cost.

### `colour_story` (~119 tokens)

Get the Cultural Story of a Colour

Given a hex value, returns a rich narrative about that colour's cultural journey — where it has appeared in history, what it has meant to different civilisations, and what archive names it carries. Essential for image generation prompts, brand storytelling, and creative briefs. Example: '#DC143C' returns the story of crimson from Byzantine imperial courts through Tudor England to modern sport.

Input parameters:

- `hex` (string, required): Hex value e.g. '#DC143C'
- `n_archives` (integer): Number of archive sources to draw from (default 5)

### `palette_concept` (~173 tokens)

Generate Heritage Palette from Cultural Concept

Generate a historically grounded colour palette from a cultural concept or theme. Returns 4-6 coordinated archive colours with hex values, proportions, and provenance. Examples: 'Victorian mourning', 'Ottoman court', 'Japanese wabi-sabi', 'Scandinavian winter', 'West African kente', 'Renaissance Florence'. Every colour returned is sourced from the archive with documented history.

Input parameters:

- `avoid` (array): Colours, pigments or topics to exclude e.g. ['arsenic green']. Applied before selection.
- `concept` (string, required): Cultural theme or historical period e.g. 'Victorian mourning' or 'Ottoman court'
- `include_neutrals` (boolean): Include neutral/background colours
- `n_colours` (integer): Number of colours to return (default 5, max 8)

### `colour_mix` (~152 tokens)

Mix Two Colours (Pigment Simulation)

Simulate perceptually modelled subtractive mixing of two colours in CIE Lab space (not RGB screen blending). Returns the resulting mixed hex value and its nearest archive match with cultural context. Uses CIE Lab subtractive model for perceptual accuracy. Example: mixing Prussian Blue and Yellow Ochre gives a muted green — the tool identifies which archive colour that green most closely matches.

Input parameters:

- `hex_a` (string, required): First colour hex e.g. '#003366'
- `hex_b` (string, required): Second colour hex e.g. '#C8A600'
- `ratio` (number): Mix ratio 0.0-1.0 where 0.5 is equal parts (default 0.5)

### `colour_timeline` (~143 tokens)

Trace a Colour Concept Through History

Given a concept or colour name, traces its documented appearances across cultures and centuries in chronological order. Returns a dated sequence of archive entries showing when and where the colour appeared, with primary sources. Use for historical research, provenance chains, and understanding why a colour carries the cultural weight it does. Example: 'indigo' traces from ancient Indian trade routes through Roman imports to Tudor sumptuary law to synthetic aniline displacement in 1897.

Input parameters:

- `concept` (string, required): Colour name or concept to trace e.g. indigo, imperial purple, mourning black
- `n` (integer): Number of timeline entries to return (default 10, max 20)

### `image_palette` (~183 tokens)

Extract and Name Colours from an Image

Upload an image (base64 encoded) and extract its dominant colour palette, with each colour matched to its nearest named archive entry with full cultural provenance. Uses K-means++ extraction plus Bradford chromatic adaptation for accuracy. Returns up to 5 dominant colours, each with archive name, cultural story, nearest RAL standard, and WCAG accessibility data. Works for product photography, interior photos, artwork, brand assets, and mood boards. The image is never stored — processed in memory only.

Input parameters:

- `archive` (string): Optional: restrict archive matching to a specific archive
- `image_base64` (string, required): Base64 encoded image (JPEG, PNG, WebP)
- `media_type` (string): Image MIME type e.g. 'image/jpeg'
- `n_colours` (integer): Number of dominant colours to extract (default 5, max 5)

### `colour_compare` (~136 tokens)

Compare Two Colours — Perceptual and Cultural

Deep perceptual and semantic comparison between any two hex values. Returns quantified differences in LRV, chroma, hue angle, warmth, and CIEDE2000 distance, plus cultural context on both — which is more authoritative, more saturated, more stable under different illuminants, and what each has historically signified. Use when choosing between two colours or explaining why one works better than another. Not a harmony tool — this is a decision and reasoning tool.

Input parameters:

- `hex_a` (string, required): First colour hex e.g. '#003366'
- `hex_b` (string, required): Second colour hex e.g. '#1877F2'

### `colour_cultural_risk` (~135 tokens)

Assess Cultural Risk of a Colour or Palette

Cultural risk assessment for a hex value or palette (symbolic weight, regional taboos, religious associations, market flags). This is one component of colour_passport for single colours. Use colour_passport for a general profile; call this directly for palette-level risk checks or when cultural risk is the only thing being asked about.

Input parameters:

- `hex` (string): Single hex value to assess e.g. '#FF9900'
- `markets` (array): Optional market focus e.g. ['China', 'Middle East', 'India']
- `palette` (array): Optional list of hex values to assess as a palette

### `design_session` (~269 tokens)

Full Design Session — Concept to Complete Palette

One-call compound tool. Submit a concept, medium, audience, and constraints — receive a complete design package: historically grounded palette, cultural narrative, commercial paint matches, WCAG accessibility check, illuminant behaviour, and a ready-made image generation prompt. Replaces chaining query_conceptual + palette_from_concept + colour_story + match_paint_system + accessibility_check + get_colour_metrics. Use when an AI agent or user needs a complete, deployable colour direction in a single call. Not for iterative refinement — use individual tools for that.

Input parameters:

- `avoid` (array): Archive names or colour terms to exclude e.g. ['neon', 'ScreenDigital']
- `concept` (string, required): Cultural theme, mood, or brief e.g. 'Victorian mourning', 'Ottoman court', 'Scandinavian minimal'
- `include_accessibility` (boolean): Include WCAG contrast check (default true)
- `include_paint_matches` (boolean): Include commercial paint matches (default true)
- `include_prompt` (boolean): Include image generation prompt (default true)
- `medium` (string): Application context e.g. 'interior', 'brand identity', 'fashion', 'digital', 'print'
- `n_colours` (integer): Palette size (default 5, max 8)

### `image_personal` (~239 tokens)

Personal Colour Analysis — Find Your Colours

Upload a portrait photo and receive a full personal colour analysis. Determines your seasonal type (Spring, Summer, Autumn, or Winter), colour depth (light, medium, or deep), and undertone (warm, cool, or neutral). Returns a curated palette of archive colours that genuinely suit you — each with full historical provenance and cultural context — plus colours to avoid. Uses Claude Vision for skin, hair, and eye analysis, then matches to the archive by CIEDE2000 perceptual distance. The photo is never stored. Example: a Deep Winter might wear Ottoman Carbon Ink while a True Spring suits Kogi Mango.

Input parameters:

- `image_base64` (string): Base64 encoded portrait photo (JPEG or PNG). Face should be clearly visible in natural light. Either image_base64 or image_url required.
- `image_url` (string): URL of a portrait photo hosted online. Easier than base64 for MCP use. Either image_url or image_base64 required.
- `media_type` (string): Image MIME type e.g. 'image/jpeg'
- `name` (string): Optional: person's name for the report e.g. 'Sarah'

### `style_match` (~222 tokens)

Style Match — Does This Go With That?

The colour question every stylist gets asked: does this bag go with this outfit? Submit your outfit items as hex values with labels (dress, bag, shoes, coat, belt, scarf, etc.) and receive a verdict on what works, what clashes, what is missing, and what to add. Every recommendation is backed by archive colour names and historical context — not generic colour theory, but documented cultural combinations. Also suggests one missing archive colour that would complete the look. Examples: 'I have a navy dress (#1C3A6E) and a tan bag (#C8A87A) — what shoes?' or 'Does this burgundy coat work with olive trousers?'

Input parameters:

- `ask` (string): Optional: specific question e.g. 'what bag colour works?' or 'do the shoes work?'
- `items` (array, required): List of outfit items with label and hex colour
- `occasion` (string): Optional: occasion context e.g. 'daytime', 'evening', 'office', 'casual', 'wedding guest'

### `interior_specify` (~341 tokens)

Interior Colour Specification — Full Room Brief

Generate a complete interior colour specification from a concept or brief. Input a room concept, type, and style — receive a professionally structured colour scheme with 60/30/10 surface assignments, archive colour names with full cultural provenance, Farrow and Ball and Little Greene paint matches, three-illuminant light behaviour (D65 daylight, F11 atrium, Illuminant A incandescent), WCAG accessibility for digital use, and a written cultural rationale explaining why each colour belongs in this room. Examples: 'bold maximalist living room', 'calm Scandi bedroom', 'Victorian study', 'coastal kitchen', 'gallery hallway'. Use /interior-specification/pdf for a downloadable branded PDF version. This is the tool that replaces a colour consultation.

Input parameters:

- `avoid` (array): Colours, pigments or topics to exclude e.g. ['arsenic green']. Applied before selection.
- `concept` (string, required): Room concept or brief e.g. 'bold maximalist living room' or 'calm Scandi bedroom'
- `n_colours` (integer): Number of colours in scheme (default 5, max 7)
- `orientation` (string): Room orientation e.g. 'north', 'south', 'east', 'west' — affects light advice
- `room_type` (string): Room type e.g. 'living', 'bedroom', 'kitchen', 'study', 'bathroom', 'hallway', 'dining'
- `style` (string): Style direction e.g. 'heritage', 'contemporary', 'maximalist', 'minimal', 'scandi', 'industrial', 'coastal'

### `palette_generate` (~170 tokens)

Lock-and-Fill Palette from Archive

Send a palette of up to 8 slots, locking some with hex values and leaving others empty. Empty slots are filled with the nearest CIEDE2000 archive match, interpolated from the locked anchors. Optional archive filter restricts fills to one archive. Returns full citation — name, archive, primary source, colour notes — for every filled slot. Example: lock a client's existing wall colour and fill a 5-colour scheme from Oxfordshire.

Input parameters:

- `archive` (string): Optional: restrict fills to one archive e.g. 'Oxfordshire', 'Shakespeare', 'Japan'
- `size` (integer): Total palette size 2-8 (default 5)
- `slots` (array, required): List of palette slots. Each has index (0-7), optional hex, and locked flag.

### `palette_gradient` (~247 tokens)

Archive Gradient — Lab-Interpolated Colour Journey

Generate a perceptually smooth gradient between 2-5 archive anchor colours. Each interpolated stop snaps to the nearest real archive colour by CIEDE2000. Anchor stops are kept true to their source. Choose linear (physically accurate Lab interpolation) or chroma_preserved (LCh interpolation, short-arc hue, avoids desaturated midpoints). Returns stop array, CSS linear-gradient string, or SVG swatch bar. Use for design briefs, colour journey visualisations, and gradient systems.

Input parameters:

- `anchors` (array, required): 2-5 hex values (#RRGGBB) or exact archive colour names
- `archive` (string): Restrict snapping to this archive name e.g. Victorian
- `output_format` (string): stops: array of colour objects. css: linear-gradient string. svg: swatch bar.
- `path` (string): linear: straight Lab lerp (may have neutral midpoint). chroma_preserved: LCh short-arc, saturation maintained.
- `snap_to_archive` (boolean): Snap each stop to nearest archive colour (default true)
- `steps` (integer): Total stops including anchors (default 7, max 20)

### `palette_translate` (~182 tokens)

Translate Any Palette into a Named Archive

Map any list of hex values into a target archive using CIEDE2000 nearest-neighbour matching. Each input hex is matched to the closest named colour in the chosen archive, with a delta-e relevance band (exact / close / approximate / loose) and full provenance. Use to translate a client's paint colours into Shakespeare language, map a brand palette into historical Japanese pigments, or find the nearest Oxfordshire equivalents to a French scheme.

Input parameters:

- `max_delta_e` (number): Max acceptable CIEDE2000 distance — above this is flagged out-of-threshold (default 40)
- `palette` (array, required): List of hex values to translate e.g. ['#F5F0E8', '#8B6B3D']
- `target_archive` (string, required): Archive to translate into e.g. 'Shakespeare', 'Japan', 'Oxfordshire'

### `archive_cliche` (~210 tokens)

Break a Colour Cliche

Find the most surprising archive colour for a concept and generate a memorable one-liner subverting the obvious expectation. Supply a concept (e.g. 'love', 'grief', 'luxury', 'power') and optionally the expected colour (e.g. 'red' for love). The archive finds the contradiction and Claude writes the one-liner, short story, and tweet. Example: love + red returns Shakespeare's dark green with 'Love is not red. It is the green of someone still waiting in a field.' Use this for public-facing demos, content, and brand storytelling.

Input parameters:

- `concept` (string, required): Colour concept to subvert e.g. 'love', 'grief', 'luxury', 'betrayal', 'power'
- `expected_colour` (string): Optional: the cliche colour to contradict e.g. 'red', '#FF0000'. Hex or colour name.
- `n_results` (integer): Number of archive entries to search (default 8)

### `colour_verdict` (~222 tokens)

Should I Use This Colour?

Evaluate a hex colour for a specific use case, market, and medium. Returns a decisive verdict: use_with_confidence, use_with_caution, or avoid. Includes strengths, risks, avoid-if scenarios, and better alternatives where needed. Backed by CIEDE2000 archive matching and Claude cultural intelligence. Examples: 'luxury hotel brand in Japan', 'ecommerce CTA button UK', 'heritage interior lime plaster wall', 'premium packaging Middle East'.

Input parameters:

- `audience` (string): Optional: target audience e.g. 'high net worth travellers', 'young professionals'
- `hex` (string, required): Hex colour to evaluate e.g. '#31559B'
- `markets` (array): Target markets e.g. ['UK', 'Japan', 'UAE']
- `medium` (string): Application medium e.g. 'digital', 'interior', 'print', 'fashion', 'packaging'
- `use_case` (string, required): What the colour will be used for e.g. 'luxury hotel brand', 'heritage interior wall'

### `palette_verdict` (~219 tokens)

Is This Palette Working?

Evaluate a palette of 2-8 hex values for a use case, market, and medium. Returns a verdict (strong / strong_with_adjustment / weak / avoid), a score 0-100, the role of each colour, the single biggest weakness, and a concrete suggestion for what to add to fix it. Each colour is matched to the nearest archive entry for cultural grounding. Examples: 'premium cushion collection UK ecommerce', 'hotel lobby interior', 'SaaS brand identity global digital'.

Input parameters:

- `market` (string): Optional: target market e.g. 'UK', 'Japan', 'global'
- `medium` (string): Application medium e.g. 'interior', 'digital', 'fashion', 'print'
- `palette` (array, required): List of 2-8 hex values e.g. ['#31559B', '#E8D898', '#4A2A50']
- `use_case` (string, required): What the palette will be used for e.g. 'luxury cushion collection', 'brand identity'

### `agent_brief` (~610 tokens)

Generate Colour Direction for Another AI

Generate a complete colour direction package for another AI agent or image generation model. Fetches a historically grounded archive palette from the concept, then produces: an agent brief (colour direction in prose), colour tokens with hex values and roles, a model-specific image generation prompt, a negative prompt, and lighting notes. Supports midjourney, flux, dalle, stable_diffusion. Example: task='luxury hotel bedroom', concept='Ottoman winter luxury', model='midjourney'. Use this to make Colour Memory the colour layer for other AI systems. Archive-grounded retrieval is evidence-filtered: entries with claim_role='reject' (no primary source and no period connection), stub entries, blank-source entries, and entries below minimum_claim_strength are never selected. If fewer than palette_size colours pass these filters, the call returns an honest incomplete result (ok:false, error_code:INSUFFICIENT_EVIDENCE_ELIGIBLE_PALETTE) rather than padding the palette with rejected or weak evidence. Negative constraints (from 'avoid' or negation phrases in concept like 'must never', 'without', 'not') are also applied to retrieval, not just flagged afterward -- a brief that says a wedding must never feel funereal will not surface mourning-themed colours in the first place. locked_palette calls skip evidence filtering entirely since the caller is supplying colours directly, not requesting archive evidence.

Input parameters:

- `allowed_archives` (array): Optional: list of allowed archive names. Query restricted to these archives only.
- `archive` (string): Optional: restrict palette query to this archive e.g. georgianpleasures, japan, china
- `avoid` (array): Optional: terms/associations to keep out of retrieval e.g. ['mourning', 'funeral black']. Affects retrieval directly, not just post-hoc flagging.
- `concept` (string, required): Colour concept to draw from e.g. 'Ottoman winter luxury', 'Victorian mourning'. Negation phrases ('must never', 'without', 'not X') are extracted and kept out of retrieval.
- `locked_palette` (array): Optional: list of hex values to use exclusively. When provided, no archive query is run and no evidence filtering applies — these exact colours are used as-is. Prevents palette drift.
- `minimum_claim_strength` (string): Evidence-grade floor for archive-grounded retrieval (default 'C'). Grade controls documentary strength; claim_role='reject' entries are excluded regardless of how low this is set. Not applied to lock…
- `model` (string): Target model: midjourney, flux, dalle, stable_diffusion
- `palette_size` (integer): Number of archive colours to include (default 5, max 8)
- `style_notes` (string): Optional: additional style direction e.g. 'matte surfaces only', 'no gold'
- `task` (string, required): What the other AI needs to generate e.g. 'luxury hotel bedroom image'

### `colour_strategy` (~235 tokens)

Complete Colour Strategy

Single-call commercial colour strategy report. Combines archive grounding, verdict, brand fit, market risk, category cliche check, material behaviour, copy hooks, and usage rules. Input: hex + brand_context (category, positioning, audience, channels) + constraints (avoid, must_work_on) + markets + medium. Output: verdict, strategy summary, archive anchor, commercial signal, category cliche risk level, market reading per market, material notes, usage rules (primary use, secondary use, avoid, pair_with), copy hooks (one_liner, social, brand_rationale), and alternatives. Examples: luxury fragrance brand UK/France/Japan, heritage interior specification, premium ecommerce packaging, SaaS brand identity.

Input parameters:

- `brand_context` (object): Brand context object
- `constraints` (object): Constraints object
- `hex` (string, required): Hex colour to evaluate e.g. '#4A2A50'
- `markets` (array): Target markets e.g. ['UK', 'France', 'Japan']
- `medium` (string): Primary medium e.g. 'packaging', 'interior', 'digital'

### `archive_report_brief` (~657 tokens)

Archive Report Brief

One-call complete archive research package for a document, PDF, or editorial brief. Input: title, audience, themes, archives to draw from, things to avoid, number of colours. Output: ranked colour cards with full provenance, story order, source confidence flags, pull quote, CTA line, CSS tokens, image prompt for Midjourney/Flux/DALLE, editorial argument, weakest and strongest entries identified. Replaces chaining archive_search + get_colour_card + cliche_breaker + agent_brief separately. Two Claude calls total. This is the endpoint for building premium archive documents, PDFs, briefs, and editorial content. Use this first for any document workflow.

Input parameters:

- `allow_partial` (boolean): If false (default), returning fewer cards than requested sets ok=false with error_code INSUFFICIENT_PALETTE_RESULTS instead of a silent short 'success'. Set true to accept a short result.
- `archives` (array): Archives to search e.g. ['RacingSilks', 'EIC', 'Keats', 'Dickens']
- `audience` (string): Target audience e.g. 'serious Georgian collector'
- `avoid` (array): Topics to suppress e.g. ['arsenic wallpaper', 'Wedgwood blue']
- `confidence_threshold` (number): Minimum confidence score (0.0-1.0) for an entry to be included. Default 0.5 filters out weakly-matched stubs.
- `family_card_mode` (string): How near-identical cultivars/records are presented. 'auto' (default): current behaviour, groups into family cards above the standard ΔE threshold. 'always': widens the clustering threshold so more ne…
- `max_family_card_share` (number): Conservative mode only: maximum fraction (0.0-1.0, default 0.5) of presented cards that may be family cards before excess families are suppressed to hero cards. Ignored in auto/always modes.
- `minimum_claim_strength` (string): Hard evidence-grade floor: A, B, C, D, or E. Never silently relaxed.
- `n_colours` (integer): Number of colours to return (default 8, max 16)
- `output_format` (string): Reserved for future use -- currently accepted but has no effect on the response shape (the endpoint always returns the full report).
- `period_end` (integer): Hard period gate: exclude entries dated after this year. Default 9999 (no upper bound).
- `period_start` (integer): Hard period gate: exclude entries dated before this year. Default 0 (no lower bound).
- `strict_sources` (boolean): Only return entries with named primary sources (default true)
- `themes` (array, required): Research themes e.g. ['racing silks', 'EIC trade', 'Keats']
- `title` (string): Document title e.g. 'The Colours of Georgian Power'

### `palette_heritage` (~137 tokens)

Heritage Palette Evolution

Given a legacy palette, generate an archive-grounded premium support system. For each existing colour: identifies its historical archive anchor, names it, and scores its provenance confidence. Detects palette gaps and fills them from the archive. Returns full palette with roles, confidence scores, CSS tokens, and production notes. Every addition has a named historical origin.

Input parameters:

- `brand_name` (string): Brand name for CSS tokens
- `context` (string): Brand context
- `market` (string): Target market
- `n_additions` (integer): Archive colours to add (default 3)
- `palette` (array, required): Existing hex values

### `archive_coverage_gap` (~163 tokens)

Coverage Gap Report

Given a list of themes, report which are well-evidenced in the archive and which are under-evidenced or missing. Returns a coverage matrix: for each theme, entries found, coverage grade (strong/moderate/weak/missing), best match with claim strength, and what source type would be needed to improve coverage. Use this BEFORE building an archive_report_brief or brief_forensic to know where the evidence is strong and where gaps will appear. Prevents building beautiful reports that quietly ignore half the brief.

Input parameters:

- `archives` (array): Optional archives to search e.g. ['EIC', 'Dickens']
- `themes` (array, required): Themes to check e.g. ['opium', 'gin', 'gambling', 'racing']

### `archive_cultural_anachronism` (~199 tokens)

Anachronism Guard

Check a list of colour entries for anachronism risk. Detects whether the primary source date falls outside the requested period, whether the archive is a known modern source (RacingSilks, FootballStrips), and returns a period_relevance score and safe phrasing. Essential for historical documents: prevents a 2011 Jockey Club racing silk registration being presented as Georgian evidence. Returns anachronism_risk (none/low/medium/elevated/high), period_relevance score 0-1, safe_phrasing, and unsafe_phrasing for each entry.

Input parameters:

- `entries` (array, required): Colour entries to check
- `period_end` (integer): End year e.g. 1830
- `period_start` (integer): Start year e.g. 1714
- `target_period` (string): Period description e.g. 'Georgian England 1714-1830'

### `session_brief` (~351 tokens)

Forensic Brief

Single-call forensic colour brief generator. Runs coverage gap analysis, pulls best archive colours, checks for anachronisms, scores claim roles (anchor/support/analogue/provocation/reject), auto-rejects stubs, generates editorial argument, act structure, pull quote, closing line, and image prompt via Claude. This replaces chaining coverage_gap + archive_report_brief + anachronism_guard + resonance_index + evidence_gap separately. Input: title, audience, themes, archives, period, tone. Output: complete deliverable package ready for PDF or editorial use. Tone options: forensic (default), editorial, clinical, narrative.

Input parameters:

- `archives` (array): Archives to draw from
- `audience` (string): Target audience e.g. 'serious collector'
- `avoid` (array): Themes to suppress
- `confidence_threshold` (number): Min confidence 0-1 (default 0.6)
- `minimum_claim_strength` (string): Hard evidence-grade floor: A, B, C, D, or E. Never silently relaxed.
- `n_colours` (integer): Number of colour cards (default 8)
- `period_end` (integer): End year e.g. 1830
- `period_start` (integer): Start year e.g. 1714
- `strict_sources` (boolean): Only include entries with named primary sources
- `target_period` (string): Historical period e.g. 'Georgian England 1714-1830'
- `themes` (array, required): Research themes
- `title` (string): Brief title e.g. 'The Colours of Pleasure'
- `tone` (string): forensic | editorial | clinical | narrative

### `index_resonance` (~178 tokens)

Resonance Index

Colour Memory's proprietary semantic metric. Score how tightly the material origin of a colour aligns with its social consequence. 1.00 = material and consequence are indistinguishable (blood as prognosis, ash as finality). 0.80 = institution mediates the colour (paint as deterrence, flag as authority). 0.50 = symbolic or associative only. Input: list of colour entries with name, hex, archive, source, notes. Output: resonance score, material origin, social function, alignment reason, confidence. Use for investigative reports, forensic briefs, museum content, editorial PDFs. This is the metric that separates Colour Memory from palette generators.

Input parameters:

- `entries` (array, required): List of colour entries to score for resonance
- `score_basis` (string): Scoring basis (default: material_origin_to_social_consequence)

### `archive_evidence_gap` (~220 tokens)

Evidence Gap Analysis

Given a hex value and a proposed claim about it, return whether the archive supports that claim, what is missing, what kind of source would be needed, and safe agent wording. This is Colour Memory's anti-hallucination endpoint. It turns the absence of evidence into a forensic finding rather than a gap to fill with invention. Example: hex #4A535C + proposed claim 'cyanosis in a death chamber' returns: nearest archive support, support level (supported/partial/unsupported), what source type is needed, and safe wording for the agent to use. Essential for museum, documentary, editorial, legal, and forensic workflows.

Input parameters:

- `archive` (string): Optional archive to search e.g. 'DarkHistory'
- `hex` (string, required): Hex colour to analyse e.g. '#4A535C'
- `n_candidates` (integer): Number of archive candidates to return (default 5)
- `proposed_claim` (string, required): What you want to say about this colour e.g. 'cyanosis in a death chamber'

### `brand_collision` (~217 tokens)

Brand Colour Collision Check

Can this brand own this colour against these competitors in this market? Input: brand hex, brand name, competitor hexes and names, market, region. Returns CIEDE2000 distance to each competitor, archive context for each colour, a distinctiveness score (0-100), an ownership verdict (strong/viable/contested/collision), a plain-English verdict summary, and a strategic recommendation. Use before committing to a brand colour in a competitive market. Replaces manual colour distance checks and competitor palette analysis.

Input parameters:

- `brand_hex` (string, required): Brand hero colour hex e.g. '#D4A829'
- `brand_name` (string): Brand name e.g. 'Fortnum and Mason'
- `competitor_hexes` (array): List of competitor hex colours
- `competitor_names` (array): Competitor names matching hex order
- `market` (string): Market context e.g. 'UK luxury food retail'
- `region` (string): Region code e.g. 'GB', 'UAE', 'JP'

### `brand_report` (~274 tokens)

Complete Brand Colour Intelligence Report

One-call complete brand colour intelligence report. Input: hex + brand context + markets + medium + product type. Output: archive anchor, cliche contradiction, colour DNA, strategy verdict, commercial signals, market reading per market, usage rules, palette roles, ecommerce copy, memory hooks, Instagram caption, and Midjourney/Flux/DALLE agent brief. Use this instead of chaining colour_strategy + cliche_breaker + ecommerce_product_copy + memory_hooks + agent_brief separately. Two Claude calls total. One complete response.

Input parameters:

- `brand_context` (object): Brand context: category, positioning, audience, channels
- `concept` (string): Optional concept to search for cliche contradiction e.g. 'luxury', 'eco', 'wellness'
- `hex` (string, required): Hero hex colour e.g. '#4A2A50'
- `markets` (array): Target markets e.g. ['UK', 'France', 'Japan']
- `medium` (string): Medium e.g. 'packaging', 'digital', 'interior'
- `product_type` (string): Product type for copy e.g. 'velvet cushion', 'fragrance', 'cleaning spray'
- `target_model` (string): Image model for agent brief e.g. 'midjourney', 'flux', 'dalle'

### `brand_audit` (~233 tokens)

Complete Brand Colour Audit

Complete brand colour intelligence audit in one call. Accepts a palette array plus market, use_case, medium, and brand_category. Returns: colour roles with archive names, full WCAG accessibility matrix, cultural risk per colour, palette verdict with score and suggested addition, CSS variables, Tailwind config, and production notes. All computed data -- no LLM cost. Pass results to an LLM for written narrative. Replaces chaining accessibility_matrix + cultural_risk_assessment + palette_verdict separately.

Input parameters:

- `brand_category` (string): Optional brand category e.g. 'developer tool', 'food', 'fashion'
- `market` (string): Target market e.g. 'UK luxury', 'global', 'Japan'
- `medium` (string): digital | print | both
- `palette` (array, required): Array of hex values e.g. ['#D4A829', '#1A5C6E', '#0F2D6B', '#0A0A0B']
- `use_case` (string): Use case e.g. 'brand identity', 'packaging', 'app UI'

### `agent_verify` (~154 tokens)

Verify AI Image Generation Colour Fidelity

Verify that an AI-generated image actually used the colours specified in an agent_brief call. Supply the generated image (URL or base64) and the target palette from agent_brief colour_tokens. Returns a fidelity score 0-100, dE2000 distance per colour, match quality per colour (accurate/acceptable/drifted/ignored), and an overall verdict. Use after agent_brief + image generation to close the colour loop.

Input parameters:

- `image_base64` (string): Base64 encoded generated image
- `image_url` (string): URL of the generated image
- `target_palette` (array, required): Hex values from agent_brief colour_tokens e.g. ['#ED9921', '#E29937']

### `colour_passport` (~249 tokens)

Colour Passport -- Complete Colour Truth Object

Canonical single-call colour truth object. Returns everything known about a hex value: colour science (Lab, LCh, hue, chroma, depth, temperature, LRV), archive anchor with dE2000, claim_strength, do_not_say and evidence grade, hex provenance (status, confidence, spectrophotometric flag), physics (illuminant behaviour, gamut, print risk), and cultural reading (colour family, warnings, positives). Use this as the foundation call when you need the complete picture. Every other tool is built on this data. Replaces chaining colour_dna + archive_provenance + colour_cultural_risk + colour_metrics separately.

Input parameters:

- `hex` (string): Single hex colour e.g. #31559B
- `hexes` (array): Multiple hex colours for batch lookup e.g. ['#31559B', '#8B1A1A']. Max 20.
- `include_cultural` (boolean): Include cultural risk and associations (default true)
- `include_physics` (boolean): Include illuminant behaviour and gamut data (default true)
- `n_archive` (integer): Number of archive matches to return (default 3)

### `colour_passports` (~175 tokens)

Batch Colour Passport Lookup

Batch version of colour_passport. Submit up to 20 hex values in one call. Returns a full Colour Passport for each unique hex: colour science, archive anchor, evidence grade, do_not_say constraints, hex provenance, accessibility, and physics. Deduplicates hex values automatically. Use for multi-colour workflows, Figma palette analysis, or any case where calling colour_passport separately for each colour would be slow.

Input parameters:

- `hexes` (array, required): List of hex colours e.g. ['#31559B', '#8B1A1A']
- `include_cultural` (boolean): Include cultural associations (default false)
- `include_physics` (boolean): Include illuminant behaviour and gamut data (default true)
- `n_archive` (integer): Number of archive matches per colour (default 3)

### `colour_dna` (~70 tokens)

Colour DNA Fingerprint

Compact semantic fingerprint for a single hex colour. This is one component of colour_passport. Use colour_passport for a general colour profile; use this only when the user explicitly wants the fingerprint format alone.

Input parameters:

- `hex` (string, required): Hex colour to fingerprint e.g. '#4A2A50'

### `ecommerce_copy` (~249 tokens)

Ecommerce Product Copy from Archive Colour

Generate complete ecommerce product copy for any colour. Input: hex + product type + tone + channel. Output: colour name, product title, short description, long description, SEO title, meta description, alt text, Instagram caption, and cross-sell suggestion. Every piece of copy is grounded in archive provenance -- never generic AI colour copy. The colour name comes from the nearest archive match, not invented. Examples: velvet cushion in Murex Luxury, ceramic vase in Woad Vat Blue, linen throw in Standlake Silt. Directly useful for Shopify, WooCommerce, and editorial product pages.

Input parameters:

- `brand_name` (string): Optional brand name to include in copy
- `channel` (string): Sales channel e.g. 'shopify', 'etsy', 'instagram', 'editorial'
- `hex` (string, required): Hex colour of the product e.g. '#4A2A50'
- `product_type` (string, required): Product type e.g. 'velvet cushion', 'ceramic vase', 'linen throw', 'candle'
- `tone` (string): Copy tone e.g. 'premium but not pompous', 'warm and accessible', 'heritage and serious'

### `colour_hooks` (~160 tokens)

Make Any Colour Memorable

Generate a hook sentence, three-sentence story, tweet, image prompt, and follow-up questions for any hex colour. Backed by the nearest archive colour's cultural provenance. Tunable by audience (general public, designers, historians, children) and tone (dinner party, academic, social media, brand copy). Use to make archive colours shareable, to generate content, or to power a public-facing colour chat experience.

Input parameters:

- `audience` (string): Target audience e.g. 'general public', 'interior designers', 'children'
- `hex` (string, required): Hex colour e.g. '#154F20'
- `tone` (string): Desired tone e.g. 'dinner party', 'academic', 'social media', 'brand copy'

### `archive_provenance` (~115 tokens)

Explain a Colour's Provenance

Explains the provenance of a named archive colour: documented fact vs computational derivation vs cultural interpretation, with confidence and citation format. This is one component of colour_passport, but also a standalone research tool for deep provenance work (museum, documentary, editorial). Use colour_passport for a general profile; call this directly for research workflows needing full source-chain detail.

Input parameters:

- `colour_name` (string, required): Name of the archive colour e.g. 'Love Idleness', 'Woad Vat Blue', 'Murex Luxury'

### `colour_forensics` (~240 tokens)

Colour Specification Safety Check

Assess whether a hex colour can be safely specified for a physical application. Returns: specification_safe verdict (yes / conditional / avoid), risks, required actions, light behaviour under three illuminants (north daylight, warm artificial, direct sun), substrate-specific notes, and a recommended alternative. Backed by CIEDE2000 archive matching and Claude material knowledge. Examples: ultramarine on lime plaster, lead white on exterior timber, verdigris on north-facing interior wall, red ochre on historic brick.

Input parameters:

- `finish` (string): Paint finish e.g. 'matt', 'eggshell', 'gloss', 'limewash'
- `hex` (string, required): Hex colour to assess e.g. '#2A5498'
- `orientation` (string): Room or surface orientation e.g. 'north-facing', 'south exterior', 'east bedroom'
- `substrate` (string, required): Physical substrate e.g. 'lime plaster', 'gypsum board', 'brick', 'timber', 'canvas'
- `use` (string): Specific use context e.g. 'heritage repair', 'new build interior', 'conservation project'

### `palette_iterate` (~149 tokens)

Iterate and Refine a Palette

Refine an existing palette using natural language feedback. Submit your current palette and feedback such as more melancholic, too corporate add warmth, or better for Gen Z luxury. Returns a refined palette with archive grounding and change rationale.

Input parameters:

- `direction` (string): Alias for feedback — natural language direction e.g. more dangerous, more historical, warmer
- `feedback` (string, required): Natural language refinement e.g. more melancholic
- `markets` (array): Target markets
- `n_results` (integer): Number of variants to return (default 1)
- `palette` (array, required): Current hex palette to refine
- `use_case` (string): Use case context e.g. luxury homewares

### `colour_variants` (~55 tokens)

Get Colour Variants and Siblings

For any named archive colour, return historical variants, lighter and darker versions with archive matches, and cultural siblings. Essential for designers exploring around a colour.

Input parameters:

- `name` (string, required): Named archive colour e.g. Bourton Honey

### `palette_export` (~109 tokens)

Export Palette to Design Formats

Export a palette to CSS custom properties, Figma design tokens, Tailwind config, ASE hex list, or JSON. Each colour is automatically named from the archive. Embeds Colour Memory directly into design workflows.

Input parameters:

- `format` (string): css | figma | ase_hex | tailwind | json
- `names` (array): Optional custom names
- `palette` (array, required): Hex values to export
- `prefix` (string): Token prefix e.g. cm, brand (default: cm)

### `palette_compare` (~94 tokens)

Compare Two Palettes

Deep perceptual, cultural, and commercial comparison between two palettes. Returns timelessness scores, commercial strength, cultural depth, emotional difference, and a winner verdict for the stated use case.

Input parameters:

- `markets` (array): Target markets
- `palette_a` (array, required): First palette hex values
- `palette_b` (array, required): Second palette hex values
- `use_case` (string): Context for comparison e.g. luxury packaging

### `ecommerce_namer` (~233 tokens)

Product Line Colour Namer

Generate archive-grounded colour names for up to 40 product SKUs. Input: list of hex values, product category, brand name, naming style. Output: for each hex -- archive name, source citation, one-line product description, dE2000 match distance, match quality, and confidence score. Every name is archive-sourced, not invented. Each carries a primary source citation that can be defended to buyers, press, and brand teams. Use for paint ranges, candle collections, fashion lines, homeware, cosmetics. Style options: geographical, poetic, material, literary, mixed.

Input parameters:

- `brand_name` (string): Brand name for context
- `hexes` (array, required): List of hex values e.g. ['#D4A829', '#1A5C6E']
- `max_dE` (number): Max dE2000 distance to accept (default 25)
- `product_category` (string): e.g. 'paint', 'candle', 'fashion', 'homeware'
- `style` (string): geographical | poetic | material | literary | mixed (default)

### `ui_states` (~149 tokens)

UI State Palette Generator

Generate a complete WCAG-compliant UI state palette from a brand hex. Returns colours for: brand, hover, active, disabled, focus ring, success, warning, error, info, surface subtle, surface strong. All states computed for contrast against your background colour. Returns hex, contrast ratio, WCAG grade, and usage note for each state. Includes CSS custom properties ready to paste. Supports light and dark mode. Use before building any UI component system.

Input parameters:

- `background_hex` (string): Background hex (default #FFFFFF)
- `brand_hex` (string, required): Brand colour hex e.g. '#D4A829'
- `dark_mode` (boolean): Generate for dark mode (default false)

### `colour_namer` (~152 tokens)

Generate Archive-Grounded Colour Names

Generate memorable, archive-verified colour names for any hex value. Choose from naming styles: geographical, poetic, material, literary, botanical, industrial, or mixed. Every name is grounded in a real archive source. The core of the Shopify product naming use case.

Input parameters:

- `hex` (string, required): Hex colour to name e.g. #8B4A2A
- `market` (string): Target market e.g. UK luxury
- `n_names` (integer): Number of name options (default 5)
- `product_type` (string): Product type e.g. candle, paint, leather bag
- `style` (string): geographical | poetic | material | literary | botanical | industrial | mixed

### `palette_swatch` (~305 tokens)

Generate Palette Swatch Image

Generate a clean, text-free PNG swatch image from hex colours. Returns a URL to the PNG. Use for Midjourney --sref style references or design mood boards. Supports photo-proportional weights from palette extraction, equal distribution, grid layout, a true smooth LCh-interpolated gradient (no hard colour edges, best for mood/atmosphere/colour-grade references rather than literal composition), and 13 fixed design ratios (6310, 7020, triptych, quad, filmstrip, etc.).

Input parameters:

- `h` (integer): Output height in pixels (default 630)
- `hexes` (string, required): Comma-separated hex values e.g. #d4a829,#1a5c6e,#0a0a0b
- `layout` (string): photo | equal | grid | gradient | filmstrip | 6310 | 7020 | 5030 | 8010 | 5050 | 6040 | triptych | quad | 55-25-20 | quint | 70-10-20 | 40-30-20-10 | 33-33-24-10. gradient is a true smooth perceptual…
- `w` (integer): Output width in pixels (default 1200)
- `weights` (string): Comma-separated proportional weights from k-means extraction. Used only when layout=photo.

### `palette_analyse` (~143 tokens)

Analyse Palette Against Archive

Analyse a palette of hex colours against the Colour Memory archive. For each colour returns the nearest named archive entry with cultural name, source, claim_strength (A-E), do_not_say guardrails, and alternatives when confidence is low. Palette-level deduplication ensures no two colours map to the same archive entry. Use after extracting colours from a photo or generating a palette.

Input parameters:

- `archive` (string): Optional: restrict to one archive e.g. China, Pigment, ArtsAndCrafts
- `colours` (array, required): Array of colour objects
- `n` (integer): Max alternatives per colour when confidence is low (1-3, default 1)

### `ingest_image` (~118 tokens)

Ingest Image for Processing

Upload an image to Colour Memory for ephemeral processing. Returns image_id valid 5 minutes. Pass image_id to palette_extract or image_brief. Use for any image over 50 KB.

Input parameters:

- `image` (object): MCP file reference {download_url, mime_type, file_name}
- `image_base64` (string): Base64-encoded image data. Use this for locally uploaded files with no public URL. No size limit here (unlike palette_extract's image_base64).
- `source_url` (string): HTTPS URL of the image

### `palette_extract` (~302 tokens)

Extract Dominant Palette Colours

Extract dominant colours from an image using k-means++ clustering. Accepts a public image URL or base64-encoded image. Returns hex values with proportional weights sorted by luminance. Optionally runs palette_analyse on the results. Use this instead of image_palette when you need hex values with proportions for palette_analyse or palette_swatch.

Input parameters:

- `analyse` (boolean): If true, also run palette_analyse on the extracted colours and return archive names
- `archive` (string): Explicit single archive name to restrict matching to e.g. 'MarsColour', 'Japan', 'Victorian'.
- `grey_card_hex` (string): Hex value sampled from a grey or white card in the image for white balance correction e.g. #C8C8C8
- `image_base64` (string): Base64-encoded image data (small images only, under 50 KB)
- `image_id` (string): Ephemeral image_id from ingest_image (preferred for images over 50 KB)
- `image_url` (string): Public URL of the image to extract colours from
- `k` (integer): Number of colours to extract (3-12, default 6)
- `style_context` (string): Plain English style description that restricts archive matching to a coherent set e.g. 'English cottage garden', 'Victorian', 'Japanese', 'MarsColour', 'Arts and Crafts'. Prevents palette colours fro…

### `image_brief` (~293 tokens)

Generate Creative Brief from Image

Compound endpoint: one image in, full creative brief out. Extracts dominant colours, matches them to the Colour Memory archive with coherent cultural naming, understands the scene, identifies the style period, suggests product directions by category (textiles, interiors, fashion), generates an image generation prompt, and returns a swatch URL. Use instead of chaining palette_extract + palette_analyse + agent_brief separately. Pass style_context for coherent archive matching e.g. 'English cottage garden', 'Victorian', 'MarsColour'.

Input parameters:

- `archive` (string): Explicit archive name override e.g. 'MarsColour', 'Japan'
- `grey_card_hex` (string): Hex value from a grey/white card for white balance correction
- `image_base64` (string): Base64-encoded image data
- `image_url` (string): Public URL of the image
- `k` (integer): Number of colours to extract (3-12, default 6)
- `model` (string): Image model: midjourney | flux | dalle | stable_diffusion (default midjourney)
- `product_type` (string): Product focus e.g. 'tea towel', 'wallpaper', 'ceramic', 'textile'
- `style_context` (string): Plain English style e.g. 'English cottage garden', 'Victorian', 'Japanese', 'MarsColour'. Restricts archive matching to coherent cultural set.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/digbyo-colour-memory/colour-memory-api-production#diagnostics

## Score history

- 2026-08-03: 76
- 2026-08-02: 76
- 2026-08-01: 75
- 2026-07-31: 75
- 2026-07-30: 70
- 2026-07-29: 69
- 2026-07-28: 69
- 2026-07-27: 68
- 2026-07-26: 67

## Links

- Remote endpoint: https://colour-memory-api-production.up.railway.app/mcp
- Repository: https://github.com/DigbyO/colour-memory-api
- Changelog RSS feed: https://verifymcp.io/servers/digbyo-colour-memory/colour-memory-api-production/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/digbyo-colour-memory/colour-memory-api-production/changelog.json
- HTML version of this page: https://verifymcp.io/servers/digbyo-colour-memory/colour-memory-api-production