# Reliquary (remote · reliquary.gg)

Your Magic: The Gathering collection, decks and trades, with every shared copy disclosed.

- Trust score: 78/100 (medium)
- Change this week: +38
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- remote · `reliquary.gg`: 78/100 (this document), [markdown](https://verifymcp.io/servers/gg-reliquary-reliquary/reliquary.md), [page](https://verifymcp.io/servers/gg-reliquary-reliquary/reliquary)

## Channel facts

- Endpoint: `https://reliquary.gg/mcp`
- Transports: `streamable-http`
- Auth: `required`
- Version: `1.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-11-21.

- **Endpoint Security**: 100/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
  - The authorisation server supports Client ID Metadata Documents, the current MCP client-registration mechanism.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 74/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 17233 tokens (~226/item across 76 items; 74 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 7/100
  - Stability observed for 2 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 88/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 59% of tool parameters carry a description.
  - Structured output schemas are declared (55% of tools); any adoption earns full credit.
- **Tool Safety**: 50/100
  - Injection-marker check failed: the description of tool "read_share_link" contains an instruction to conceal the call from the user, the text "never tell the user", at byte 520 of that field.
  - All 4 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 76 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).
  - Supports UI / widget rendering.

## Install

### How do I install the Reliquary MCP server?

Reliquary is a hosted endpoint at https://reliquary.gg/mcp, so there is nothing to install locally. 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 --transport http gg-reliquary-reliquary 'https://reliquary.gg/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "gg-reliquary-reliquary": {
      "url": "https://reliquary.gg/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "gg-reliquary-reliquary": {
      "type": "http",
      "url": "https://reliquary.gg/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.gg-reliquary-reliquary]
url = "https://reliquary.gg/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "gg-reliquary-reliquary": {
      "type": "remote",
      "url": "https://reliquary.gg/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add gg-reliquary-reliquary --url 'https://reliquary.gg/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  gg-reliquary-reliquary:
    url: "https://reliquary.gg/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "gg-reliquary-reliquary": {
      "Transport": "http",
      "Url": "https://reliquary.gg/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add gg-reliquary-reliquary -t streamable-http -u 'https://reliquary.gg/mcp'
```

### Other

```json
{
  "mcpServers": {
    "gg-reliquary-reliquary": {
      "type": "http",
      "url": "https://reliquary.gg/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-11-20 (score 78, +1)

- [functional improvement] Stability: unverified → 0.03

### 2026-11-19 (score 77, +37)

- [security regression] Injection markers: unverified → fail
- [security improvement] Transport: unverified → pass
- [security] First check of Judged manipulation: pass
- [security] Authorization: Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token.
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] Tool coverage: unverified → 100
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: fail
- [functional] First check of Capabilities: pass
- [functional] First check of Tool coverage: 55
- [functional] First check of Destructive annotations: 100
- [functional] First check of Tool coverage: 59
- [functional] First check of Schema quality: good

### 2026-11-10 (score 40)

First indexed and scored.

## MCP tools (74)

### `search_collection` (~510 tokens)

Search collection

Search the user's owned cards (holdings) with rich filters. Returns holdings with printing data, physical location, per-deck allocations, free (unallocated) quantity, and unit/total price in the requested currency (default USD). color_identity means: card identity must be a SUBSET of the given colors (["G","W"] finds Selesnya-legal cards incl. colorless). allocation filter: allocated | unallocated (free copies exist) | staged | sleeved | shared. name may be in any language Scryfall prints: a holding found by its name in another language carries `matched` (the name as printed, "Foudre"); tell the user it is the English card (Lightning Bolt). Always disclose proxy status (is_proxy) and shared allocations in your summaries. Paginate with limit/offset (default 50, max 200).

Input parameters:

- `allocation` (string)
- `cmc_max` (number)
- `cmc_min` (number)
- `color_identity` (array)
- `condition` (string)
- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `finish` (string)
- `is_altered` (boolean)
- `is_proxy` (boolean)
- `is_signed` (boolean)
- `lang` (string)
- `limit` (integer)
- `location` (string): Location id or name
- `name` (string): Substring match on card name
- `offset` (integer)
- `oracle_text` (string): Substring of rules text, e.g. "Search your library"
- `origin` (string): How the card was acquired (mutually exclusive). printed_proxy/bought_proxy force is_proxy=true. is_proxy/is_signed/is_altered are independent flags that combine freely with any origin (a gift proxy =…
- `price_max` (number): Unit price upper bound in `currency`
- `price_min` (number): Unit price lower bound in `currency`
- `rarity` (string)
- `set_code` (string)
- `sort` (string)
- `type` (string): Substring of the type line, e.g. "Creature" or "Land"

Output parameters:

- `currency` (string)
- `items` (array)
- `limit` (number)
- `offset` (number)
- `total_cards` (number): Copies in those stacks, all pages
- `total_holdings` (number): Stacks matching the filters, all pages

### `add_holdings` (~312 tokens)

Add holdings

Add physical cards to the collection (bulk). Each item is a card reference (scryfall_id, or name [+ set_code, collector_number]) plus holding attributes. quantity ≥ 1 identical copies form one stack. Defaults: finish nonfoil, condition NM, lang en, origin "single", location "Unsorted" (created if missing; any unknown location name is auto-created). purchase_price is PER CARD in purchase_currency (USD/EUR/CHF). Unresolvable names are returned under "unresolved", the rest are added. A set_code (and collector_number) names one printing: an item whose card is not there comes back under "unresolved", naming the nearest printing. The list is added in one write: an item the collection refuses (an origin printed_proxy or bought_proxy with is_proxy false, a blank location) refuses the whole call and nothing is added. A name that is no card's exact name was added as Scryfall's closest match, and a name in another language as its English card: each is listed under "inexact" with the card it became (matched_by fuzzy or other_language). Tell the user which card was added for each fuzzy one. From a photo of cards, every name, set and finish is your own reading: list them and get the user's yes before adding.

Input parameters:

- `items` (array, required): Max 75 items per call (Scryfall batch limit). Send the whole list in one call: it is resolved in one batch.

### `update_holding` (~233 tokens)

Update holding

Update attributes of one holding (stack) by holding_id (get ids from search_collection/where_is). Changing location is a physical move and reconciles allocation statuses like move_holding. Reducing quantity below the allocated amount is rejected — deallocate first. origin printed_proxy/bought_proxy force is_proxy=true and it cannot be unset.

Input parameters:

- `condition` (string)
- `finish` (string)
- `holding_id` (string, required)
- `is_altered` (boolean)
- `is_proxy` (boolean)
- `is_signed` (boolean)
- `lang` (string)
- `location` (string): Location id or name — this physically moves the stack
- `notes` (string|null)
- `origin` (string): How the card was acquired (mutually exclusive). printed_proxy/bought_proxy force is_proxy=true. is_proxy/is_signed/is_altered are independent flags that combine freely with any origin (a gift proxy =…
- `purchase_currency`
- `purchase_price` (number|null)
- `quantity` (integer)

### `remove_holding` (~81 tokens)

Remove holding

DESTRUCTIVE: permanently delete a holding (the physical cards leave the collection, e.g. sold or traded away). Without confirm:true this only returns a dry-run summary of what would be deleted, including any allocations that would be released. Call again with confirm:true to actually delete.

Input parameters:

- `confirm` (boolean)
- `holding_id` (string, required)

### `crack_pack` (~172 tokens)

Crack pack

Conversational bulk-add for opening boosters: adds cards with origin preset to "booster" and location defaulting to "Unsorted". Give one item per distinct card (name [+ set_code, collector_number] or scryfall_id) with quantity and optional finish (foil pulls!). Unresolvable names come back under "unresolved" — ask the user to clarify those. The pack is added in one write, and a name added as Scryfall's closest match or read in another language is listed under "inexact" with the card it became: tell the user.

Input parameters:

- `items` (array, required)
- `location` (string): Where the cards physically go (default "Unsorted")
- `set_code` (string): Set the pack is from — applied to every item without its own set_code

### `where_is` (~127 tokens)

Where is

Locate a card by name across all holdings. Returns, per stack: physical location (where it is RIGHT NOW), quantity, free (unallocated) copies, and every allocation with deck, status (staged = earmarked but physically elsewhere; sleeved = physically in the deck) and shared disclosure. The name may be in any language Scryfall prints: a stack found that way carries read_as ("Foudre → Lightning Bolt"), say it. Always repeat the shared/proxy disclosures to the user.

Input parameters:

- `name` (string, required): Card name or substring, in English or another language

Output parameters:

- `stacks` (array)

### `card_detail` (~598 tokens)

Card detail

Everything about one card: oracle data (mana cost, type line, rules text, color identity, legalities — the map includes paupercommander (Pauper EDH: whether the card may sit in the 99) and duel (Duel Commander); card.pdh_commander separately flags cards that can LEAD a Pauper EDH deck, i.e. printed at uncommon with a creature/Vehicle/Spacecraft front face — legendary is NOT required in PDH), the focused printing (set, collector number, rarity, finishes, USD/EUR prices), EVERY printing across all sets with the user's per-printing ownership (qty_real / qty_real_foil / qty_proxy; set_digital=1 marks MTGO/Arena-only printings), and the user's holdings of any printing with physical location and deck allocations. Answers "do I own this card, and in which printings?" — use it before suggesting a purchase. card.rulings: the card's official rulings (published_at, source "wotc" = Wizards of the Coast or "scryfall", comment), from Scryfall's rulings file as of the catalogue's last load; quote them when asked how the card works, or how it works with another card. Reference by scryfall_id, by name (+ optional set_code/collector_number), or by oracle_id (the newest printing becomes the focus). A first lookup may read the card's printings and prices live from Scryfall (card data kept in the shared catalogue for 7 days; nothing in the user's account changes). DISCLOSURE: qty_proxy copies are proxies — physically present but never counted as owned; holdings with shared=true allocations must be relayed as "also allocated to …". Before the user signs in, it answers from the catalogue alone with signed_in: false: no qty_* fields, holdings or totals, so say nothing about what they own, and a card newer than the catalogue is not found until they sign in.

Input parameters:

- `collector_number` (string): Collector number within the set
- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `name` (string): Card name in English or any language Scryfall prints ("Blitzschlag", "Foudre", "稲妻"), used when scryfall_id is absent; an English name is also fuzzy-resolved via Scryfall
- `oracle_id` (string): Oracle id shared by all printings — use when no specific printing is meant
- `scryfall_id` (string): Exact Scryfall printing id, if known
- `set_code` (string): Set code, e.g. "2xm"

Output parameters:

- `card` (object)
- `currency` (string)
- `holdings` (array): The player's stacks of any printing. Absent before sign-in
- `printing` (object): The printing asked about, or the newest
- `printings` (array): Every printing, newest set first, each with what the player owns of it
- `signed_in` (boolean): Present, false, when the user has not signed in: the answer holds no copies, holdings or totals, so say nothing about what they own
- `totals` (object): Absent before sign-in

### `move_holding` (~93 tokens)

Move holding

"The card is physically HERE now." Moves a holding (stack) to a location (id or name; unknown names are created). Allocation statuses reconcile automatically: sleeved allocations into decks elsewhere drop to staged; staged allocations into the deck living at the target location become sleeved. Report the status_changes to the user.

Input parameters:

- `holding_id` (string, required)
- `location` (string, required): Target location id or name

### `list_sets` (~245 tokens)

List sets

Browse the Magic set catalog (cached from Scryfall, newest release first) with the user's per-set progress: card_count (total printings in the set), owned_printings (printings held as REAL cards) and proxy_only_printings (printings held only as proxies — physically present but not tournament-legal or tradeable, never counted as owned). Filter by set_type (core, expansion, masters, commander, draft_innovation, funny, starter, promo, token, …), name substring, or include_digital (default false). Use the returned set codes with set_completion. Owning another set's printing of a card does not count toward that set here.

Input parameters:

- `include_digital` (boolean): Include digital-only sets (default false)
- `limit` (integer): Default 100, max 1000 — the catalog has ~1000 sets; prefer filters
- `name` (string): Substring of the set name, e.g. "ravnica"
- `offset` (integer)
- `set_type` (string): Exact Scryfall set_type, e.g. "expansion", "core", "commander", "masters"

Output parameters:

- `sets` (array)

### `set_completion` (~478 tokens)

Set completion

Collection completion for one set, optionally one rarity ("Which uncommons from Ravnica Remastered am I missing?" → set "ravnica remastered", rarity "uncommon"). Accepts a set code or name. Every printing in the set is classified once: owned (≥1 real copy of this exact printing) | owned_other_printing (real copy from a different set only) | proxy_only (the user's only copies are proxies) | missing (no copy at all). `counts` always covers all four; `status` picks which card lists are returned — the default "missing" also includes the proxy_only and owned_other_printing lists for disclosure. Missing cards are priced cheapest-first in `currency` (default USD; cached prices at most 7 days old); price_to_complete covers every card not owned as a real copy of this set's printing. finish "foil" answers "which foils am I missing": only printings that exist in foil/etched are in scope, only foil/etched copies count as owned, prices switch to foil prices, and missing entries carry owned_nonfoil when the user holds the card in nonfoil ("nonfoil" is symmetric via owned_foil — mention these wrong-finish copies when reporting). Foil-only printings are always priced from their foil price; with the default finish "any", owned entries report foil_quantity when some copies are foil/etched. DISCLOSURE: when proxy_only is non-empty, tell the user those cards are proxies — physically present but not tournament-legal and not tradeable — and never count them as collected.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `finish` (string): Finish goal (default "any"). "foil" = foil-set tracking: foil/etched-capable printings only, foil/etched copies count, foil prices
- `rarity` (string)
- `set` (string, required): Set code ("rvr") or set name ("Ravnica Remastered")
- `status` (string): Which card lists to return (default "missing", which includes the disclosure lists)

Output parameters:

- `complete` (boolean)
- `completion_pct` (number)
- `counts` (object)
- `currency` (string)
- `finish` (string)
- `missing` (array)
- `note` (string)
- `owned` (array)
- `owned_other_printing` (array): Owned only in another set's printing
- `price_to_complete` (number|null): Every card in scope not owned as a real copy of this printing, missing ones unpriced left out
- `proxy_disclosure` (string): Present when proxy_only is not empty: relay it
- `proxy_only` (array): Cards held only as proxies, never collected. Proxies are not real cards: never counted as owned, always said
- `rarity` (string): The rarity asked, or "all"
- `set` (object)
- `total` (number): Printings in scope

### `collection_value` (~160 tokens)

Collection value

Total collection value in `currency` (default USD), plus gain/loss versus recorded purchase prices (converted through ECB rates). include_proxies defaults to FALSE — proxies are excluded from value everywhere unless explicitly requested; say so when reporting. top_movers:true adds the biggest 7-day price movers among owned cards (needs nightly snapshots). The value over time is price_history.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `include_proxies` (boolean): Default false
- `top_movers` (boolean)

Output parameters:

- `currency` (string)
- `fx_date` (string|null): The day of the ECB rates used
- `include_proxies` (boolean): false: proxies are left out of every figure; say so
- `priced_cards` (number)
- `purchase_known` (object): Gain or loss over the copies with a recorded purchase price only
- `top_movers` (array): The biggest 7-day movers among owned cards, when asked
- `total_value` (number|null)
- `unpriced_cards` (number): Copies with no price, left out of total_value

### `price_history` (~475 tokens)

Price history

Price over time, from the nightly snapshots Reliquary keeps of every printing it prices (for every printing since November 2026, before that only for owned ones; daily for 90 days, then one a week for a year). WITH a card reference: that printing's unit price per day in `currency` (`price` non-foil, `price_foil` foil, null where it has none), any card, owned or not; `since` is the first day kept (null: no history yet, say so). WITHOUT a card: the user's collection value per day — the cards owned TODAY at each day's prices (a card sold leaves the whole line); `value` sums only the copies that had a price that day and `cards_priced` counts them out of `cards`, so a rise where cards_priced rises is a card whose history starts there, not a price move: say so. Nothing is estimated. include_proxies defaults to FALSE: proxies count as zero, say so when reporting. days: 30 or 90 (a point a day) or 365 (a point a week); default 90. A day reads the latest snapshot at most 14 days old. Prices are Scryfall's list prices (USD from TCGplayer, EUR from Cardmarket); CHF is EUR × the stored ECB rate.

Input parameters:

- `collector_number` (string): Collector number within the set
- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `days`: 30, 90 or 365; default 90
- `include_proxies` (boolean): Collection only; default false
- `name` (string): Card name in English or any language Scryfall prints ("Blitzschlag", "Foudre", "稲妻"), used when scryfall_id is absent; an English name is also fuzzy-resolved via Scryfall
- `scryfall_id` (string): Exact Scryfall printing id, if known
- `set_code` (string): Set code, e.g. "2xm"

Output parameters:

- `cards` (number): The collection: copies owned today, each priced at each day's prices
- `collector_number` (string)
- `currency` (string)
- `days` (number): 30 or 90 (a point a day), 365 (a point a week)
- `image_uri` (string|null): The card's picture on Scryfall, to show as it is; null when the catalogue has none
- `include_proxies` (boolean): The collection: false leaves proxies out (as zero); say so
- `name` (string): The English name
- `points` (array)
- `rate_missing` (string): No rate for the currency: prices are null for want of it, not missing
- `scryfall_id` (string): A card asked: the printing
- `scryfall_url` (string): The card's page on Scryfall: link the card's name to it
- `set_code` (string)
- `since` (string|null): A card asked: the first day a price was kept; null: no history yet, say so

### `list_decks` (~60 tokens)

List decks

List all decks with format, card counts and allocation counts. `editable` false: the deck is past the decks the user's plan keeps editable. It still reads, shares, exports and deletes, and a change to it answers PLAN_LIMIT: say so.

Output parameters:

- `decks` (array)

### `create_deck` (~292 tokens)

Create deck

Create a deck. Formats: commander | pdh (Pauper Commander) | dc (Duel Commander) | standard | pioneer | modern | legacy | vintage | pauper | casual (default casual). A location of kind "deck" with the same name is created automatically — sleeved cards physically live there. For commander, pdh and dc decks pass the commander as a card reference; it is added to the deck list automatically. A pair (Partner, "Choose a Background" + a Background, Doctor's companion + a Doctor) goes in commander + partner. A companion (Lurrus, Yorion, …) goes in companion: it is added to the sideboard (outside the 100 in a commander format, one of the 15 elsewhere), and deck_health checks its condition: a card that breaks it makes the deck not legal, and the issue names it. Never refused for the plan: a deck past the decks the user's plan keeps editable is made with its list and answers editable:false and plan_limit, which names the decks that take edits: relay it.

Input parameters:

- `commander` (object)
- `companion` (object): The companion: a card with the Companion ability, kept in the sideboard
- `description` (string)
- `format` (string)
- `name` (string, required)
- `partner` (object): The second commander of a pair

### `update_deck` (~496 tokens)

Update deck

Change a deck (id or name): its name, format (commander | pdh (Pauper Commander) | dc (Duel Commander) | standard | pioneer | modern | legacy | vintage | pauper | casual), description, or who leads it. commander / partner take a card reference; null removes that commander (the card stays in the list). A newly named commander that the list lacks is added to the main deck. Fields left out are unchanged. companion takes a card reference (null: none; the card stays in the list): a card with the Companion ability, moved to or added to the sideboard (outside the 100 in a commander format); deck_health checks its condition and names any card that breaks it. Changing the format changes which rules deck_health and deck_stats apply; it never changes the list. lang sets the language the deck's rows ask for (Scryfall's code: de, ja, zhs…; null any) unless a row has its own: a preference, so a copy in another language still counts and is offered marked. open_to_trade:true PUBLISHES this deck's claimed copies on every tradelist the user publishes, each naming this deck (trading one breaks it): say so and ask before turning it on. The deck stays whole. play is how the deck is played (every deck starts casual): tournament counts a copy only a proxy covers as missing, so deck_status, the buylist, its wantlist link, trade matches and posts list that card until a real copy replaces the proxy; the proxy stays in the deck, and nothing is written to the list. casual plays proxies, and a deck with them is not tournament legal.

Input parameters:

- `commander`
- `companion`: The companion, kept in the sideboard; null: none
- `deck` (string, required): Deck id or name
- `description` (string|null)
- `format` (string)
- `lang`: The language the deck's rows ask for unless a row has its own; null any
- `name` (string)
- `open_to_trade` (boolean): true: the deck's claimed copies join every published tradelist, named as this deck's
- `partner`: The second commander of a pair
- `play` (string): tournament: a copy only a proxy covers counts as missing. casual (the default): proxies play

### `delete_deck` (~77 tokens)

Delete deck

DESTRUCTIVE: delete a deck (id or name). Holdings are NEVER deleted — every allocation is released and sleeved cards physically return to "Unsorted". Without confirm:true this returns a dry-run summary only; repeat with confirm:true to delete.

Input parameters:

- `confirm` (boolean)
- `deck` (string, required): Deck id or name

### `add_wants` (~249 tokens)

Add wants

Add cards to a deck's list (its wantlist), or to the personal deck-independent wantlist when deck is omitted. Send the whole list in ONE call (max 75 items): it is resolved and written in one batch. section: main (default) or sideboard, per item or for the whole call; commander formats have no sideboard. By default a want accepts ANY printing of the card (oracle-level). Set pin:true with a specific printing to require exactly that printing. Duplicate adds merge quantities. Adding a card claims nothing: each added row comes back with its coverage from the collection — allocated, shared_in, claimable (free copies you own, not yet claimed), missing — and proxies_allocated. Relay shared_detail / also_shared_with and proxies as deck_status requires. Next step: claim_from_collection. lang per item: the language the row asks for (Scryfall's code: de, ja, zhs…), a preference that trading matches first.

Input parameters:

- `deck` (string): Deck id or name; omit for the personal wantlist
- `items` (array, required)
- `section` (string): Section for every item without its own (default main)

### `update_want` (~167 tokens)

Update want

Change a deck-list row (want_id from deck_status): its quantity and/or its section (main | sideboard). quantity 0 cuts the card. Cutting a card or lowering its count RELEASES the copies the deck held beyond the new count: staged ones are simply free again, sleeved ones physically return to "Unsorted". The response lists them under `released` — tell the user, they may need to take the card out of the deck box. Cutting a commander also removes it as commander. lang sets the language the row asks for (Scryfall's code; null follows the deck's): a preference, it changes no copy.

Input parameters:

- `lang`
- `quantity` (integer)
- `section` (string)
- `want_id` (string, required)

### `replace_card` (~138 tokens)

Replace card

Swap one card of a deck list for another, keeping its count and section: the row want_id is cut and `replacement` is added. Typical use: a missing card and a pick from find_substitutes. Copies the deck held of the old card are released (listed under `released`; sleeved ones return to "Unsorted"). Nothing is claimed for the new card — the returned row shows its coverage (claimable = you own a free copy); run claim_from_collection to claim it.

Input parameters:

- `replacement` (object, required): The card that takes its place
- `want_id` (string, required): The row to replace (from deck_status)

### `deck_status` (~386 tokens)

Deck status

Per-card status of a deck list (deck id or name). deck.commanders names who leads it (one card, or a pair); deck.companion names its companion, or null; its row is the sideboard row with is_companion (outside the 100 in a commander format); deck.editable false: the deck is past the decks the user's plan keeps editable, and a change to it answers PLAN_LIMIT. sections counts main (commander included) and sideboard. Each row: its section, is_commander, wanted quantity and how it is covered — allocated (this deck's own copies), shared_in (copies deliberately shared from other decks — ALWAYS disclose these with which decks share them and where the cards physically are), claimable (free copies exist in the collection), missing. sleeved counts the allocated (own) copies that are physically in the deck; the other allocated copies are staged, still where they were. Row status is the strongest complete coverage: allocated > shared_in > claimable > missing. also_shared_with lists this deck's OWN copies that another deck also claims as shared: the two decks cannot be played at the same time — ALWAYS disclose these too, with the other deck and where the card physically is. A row with missing > 0 may carry held_elsewhere: copies the user DOES own that another deck claims (deck, where they are, is_proxy). Never call such a card "not owned": say it is in that deck, and that claim_from_collection with allow_shared:true would share it. deck.play tournament: a copy only a proxy covers counts as missing, and proxies_missing says how many of a row's missing copies the deck plays as proxies: say "you play a proxy; a tournament needs the real card". On a casual deck proxies count as covered.

Input parameters:

- `deck` (string, required): Deck id or name

Output parameters:

- `deck` (object)
- `sections` (object)
- `totals` (object)
- `wants` (array)

### `deck_health` (~194 tokens)

Deck health

Composed deck report: format legality (with per-issue detail: size, copy limits, sideboard, banned and restricted cards, commander and pairing rules, colour identity — pdh and dc by their own lists — and the companion's condition, naming each card that breaks it; deck.companion names the companion), missing cards, shared-copy disclosures (copies this deck borrows AND its own copies that other decks borrow — relay both), proxy count, and price-to-complete in `currency` (default USD). Proxies never affect legality but are always reported as a warning.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `deck` (string, required): Deck id or name

Output parameters:

- `cards_wanted` (number)
- `deck` (object)
- `legality` (object)
- `missing` (array)
- `missing_cards` (number)
- `price_to_complete` (object)
- `proxy_count` (number): Claimed proxies: always say so
- `shared_copies` (array): Copies this deck borrows and its own copies other decks borrow: relay every line
- `sideboard_cards` (number)

### `check_legality` (~256 tokens)

Check a decklist's legality

Whether a pasted decklist is legal, without saving it: in one format, or in every format when none is given. Takes the list as text ("4 Lightning Bolt" a line; a "Commander" and a "Sideboard" section, or *CMDR*, as the sites write them), any language Scryfall prints. Each verdict has legal and its issues (severity error or warning, code, message: size, copy limits, banned and restricted cards, commander and colour identity, the companion's condition). A list with a card in not_found is never called legal: the not_checked issue names those cards; say so. read_as names a card read in another language. Read from the card catalogue only; it works before the user signs in. For a deck already in Reliquary, deck_health reports more (missing cards, shared copies, proxies).

Input parameters:

- `decklist` (string, required): The decklist as text, at most 250 different cards
- `format` (string): One format to judge; omitted, every format but casual. commander | pdh (Pauper Commander) | dc (Duel Commander) | standard | pioneer | modern | legacy | vintage | pauper | casual

Output parameters:

- `commanders` (array): The commanders the list names, by their English names
- `companion`: The companion the list names, or null
- `ignored_lines` (array): Lines that were not read as cards (a maybeboard, a stray line)
- `main_cards` (number): Cards read in the main deck, the commanders among them
- `not_found` (array): Names the catalogue does not know, as typed: they were not checked, so say so
- `note` (string)
- `read_as` (array): Names read in another language, each with its card: "Foudre → Lightning Bolt"
- `shared_names` (array): Names in another language several cards share: not checked; ask which card is meant
- `sideboard_cards` (number): Cards read in the sideboard, the companion among them
- `verdicts` (array): One a format: the format asked, or every format but casual

### `deck_stats` (~278 tokens)

Deck stats

What a deck list is, for building: every row with its card facts (type, mana cost, mana value, colour identity, section, is_commander, is_companion), the mana curve of nonland cards (last bucket 7+), cards per type, coloured mana symbols against lands per colour, opening-hand land odds (exactly 0…7 lands in seven; two_to_four_lands), land_drops (a land every turn through turns 1…6, going first and second), and format legality. All figures are over the LIBRARY: the main deck without the commander(s) and without the sideboard. Probabilities are 0…1, hypergeometric — no mulligans, tutors or card draw; say so when quoting them. Optional `odds`: the chance of holding at least `want` (default 1) of a group of cards by `turn` (0 = the opening seven). Name the group by `cards` (names in the list) or by `type` (Land, Creature, …); on_the_play:true skips the first draw (two-player, going first). Reads the list only: it says nothing about which copies you own — use deck_status for that.

Input parameters:

- `deck` (string, required): Deck id or name
- `odds` (object)

Output parameters:

- `cards` (array)
- `deck` (object)
- `legality` (object)
- `note` (string)
- `odds` (object): Present when odds were asked
- `stats` (object)

### `search_cards` (~347 tokens)

Search cards

Find cards in the catalogue of every paper printing — NOT limited to what the user owns (search_collection is that). query is the start of a name ("lightn"), any words of a name in any order ("bolt", "harvest hand"), or a set code and collector number ("FDN 120") for one exact printing (match "printing"; otherwise match "name" and scryfall_id is the printing a bare name means). A name in another language is found too, by its start or in full, and by any word for languages written with spaces: the hit is the card under its English name, with `matched` the name that found it ("Foudre" → Lightning Bolt): tell the user which card it is. Each hit carries owned (real copies of any printing), free (real copies no deck claims exclusively) and proxies. DISCLOSURE: proxies are never counted as owned — say "you hold N proxies" separately. Served from the local catalogue with no Scryfall call; a card released after the last catalogue load may be missing — card_detail by name still finds it once the user is signed in (before sign-in it reads the same catalogue, so ask them to sign in first). A very common word alone ("dragon", "of") reads only the first few hundred names: add another word or the start of the name. Default 12 hits, max 30. Before the user signs in, hits carry no owned, free or proxies: say nothing about what they own.

Input parameters:

- `limit` (integer)
- `query` (string, required): Name start, name words (in English or another language), or "SET NUMBER"

Output parameters:

- `hits` (array): Catalogue hits, best first, not limited to what the user owns

### `whats_missing` (~197 tokens)

Whats missing

Cards missing from a deck (not coverable from the collection) with the cheapest cached printing price per card (`cheapest_price`, non-foil, and `cheapest_printing` as "SET number"; both null when no printing has a price yet) and a price-to-complete total in `currency` (default USD). The total leaves unpriced cards out: say how many rows have no price. Prices come from the local printings cache (nightly refresh). Run claim_from_collection first, or copies the user owns and has not claimed are still counted as coverable, not missing.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `deck` (string, required): Deck id or name

Output parameters:

- `currency` (string)
- `deck` (string)
- `missing_cards` (number)
- `note` (string)
- `price_to_complete` (number): Leaves out the rows with no price: say how many
- `rate_missing` (string): Present when CHF was asked and no CHF rate is stored: no CHF price could be given at all, the cards are not unpriced. Relay it.
- `rows` (array)

### `personal_wantlist` (~101 tokens)

Personal wantlist

The personal wantlist: cards the user wants that belong to no deck (add with add_wants without `deck`, change or cut a row with update_want). Per row: wanted, claimable (free copies the user already holds — those are not missing) and missing. Only the `missing` copies appear on the shared wantlist (create_share_link kind "wantlist" without deck) and in match_tradelist / compare_trade.

Output parameters:

- `totals` (object)
- `wants` (array)

### `generate_buylist` (~184 tokens)

Generate buylist

Buylist of missing cards for one deck (id or name) or ALL decks (omit deck), cheapest-first, with a mass-entry friendly text block ("4 Lightning Bolt" per line) for Cardmarket/TCGplayer and an estimated total in `currency` (default USD). Per item: quantity, unit_price (non-foil), cheapest_printing ("SET number") and the decks that miss it. total_estimated leaves out the `unpriced_items`: give that count with the total.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `deck` (string): Deck id or name; omit for all decks combined

Output parameters:

- `currency` (string)
- `items` (array)
- `rate_missing` (string): Present when CHF was asked and no CHF rate is stored: no CHF price could be given at all, the cards are not unpriced. Relay it.
- `text` (string): "4 Card Name" per line, for a shop's mass entry
- `total_estimated` (number): Leaves out unpriced_items: give that count with the total
- `unpriced_items` (number)

### `complete_deck_on_budget` (~529 tokens)

Complete deck on budget

How to finish one deck (id or name) with `budget` to spend, in `currency` (default USD): the missing copies bought cheapest first while the budget lasts (`buy`, with `text` as "4 Card Name" lines for a shop), the copies that do not fit (`over_budget`, `over_by`), and the cards with no price yet (`no_price_yet`, left out of every total). A price is the cheapest non-foil printing among the priced ones, or the pinned printing's when the list pins one. Each over-budget card carries `owned_stand_ins`: cards the user owns with copies no deck claims outright, in the deck's colour identity, and `cheaper_to_buy`: cards whose cheapest price for every copy of the line fits what is left of the budget. With `stand_ins_by` "rules text" both come from the cards nearest by rules text (a nearer mana value and a more played card first), legal in the format; with "type and mana value" (no list for the card yet) they are mechanical filters only, still legal in the format, and `cheaper_to_buy` is empty; null for the commander, which gets none. Either way YOU judge whether one does the job. Say `proxies` beside a stand-in that has any, and name every deck in its `shared_with`: those copies are already borrowed. A line's `claimed_by_other_decks` means the user owns copies another deck claims: say so before they buy (claim_from_collection with allow_shared can borrow them). Name the cards in `printings_not_compared` as possibly cheaper: some of their printings have no price yet, and the nightly price refresh reaches every printing within a week (`prices_queued` is always 0: this tool queues nothing). Copies the user owns free (`claimable`) are not missing: run claim_from_collection first. Read-only: it changes nothing and starts no work. Relay `rate_missing` when present. `stand_ins_withheld`, when present, means the user's plan has no stand-ins: relay it once, as written.

Input parameters:

- `budget` (number, required): Money to spend, in `currency`
- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `deck` (string, required): Deck id or name

Output parameters:

- `budget` (number)
- `buy` (array)
- `claimable` (number): Free copies not claimed: not missing, claim_from_collection takes them
- `complete` (boolean)
- `currency` (string)
- `deck` (object)
- `left_over` (number)
- `no_price_yet` (array): Left out of every total: say so
- `over_budget` (array)
- `over_by` (number)
- `prices_queued` (number): Always 0: this tool queues nothing; the nightly refresh reaches every printing within a week
- `printings_not_compared` (array): Priced from part of their printings: one not yet priced may be cheaper
- `rate_missing` (string): Present when CHF was asked and no CHF rate is stored: no CHF price could be given at all, the cards are not unpriced. Relay it.
- `spend` (number)
- `stand_ins_withheld` (string): Present when the user's plan has no stand-ins: relay it once, as written
- `text` (string)
- `total_estimated` (number): Every missing copy with a price; leaves out no_price_yet

### `what_can_i_build` (~60 tokens)

What can I build

Rank decks by how completable they are right now (allocated + shared + claimable free cards vs. the full list), optionally filtered by format. completion_pct 100 means every card is owned or already allocated.

Input parameters:

- `format` (string)

Output parameters:

- `decks` (array)

### `show_card_location` (~119 tokens)

Show where a card is

Use this when the user asks where a card is and a picture helps: shows each matching card with its image, every stack (how many, in which place, which printing) and the decks that claim it. Reads the same data as where_is and changes nothing. The result is also your answer in words: say the place first; name every deck on a stack whose claim is `shared`; say when a stack `is_proxy`. `more_cards` counts matches not shown.

Input parameters:

- `name` (string, required): Card name or part of it

Output parameters:

- `cards` (array)
- `more_cards` (number): Matching cards not shown
- `note` (string)
- `query` (string)
- `view` (string)

### `show_buylist` (~203 tokens)

Show what to buy

Use this when the user asks what to buy for a deck (id or name), or for all decks (omit deck), and a table helps: missing cards with count, cheapest non-foil printing and unit price, a total in `currency` (default USD) and the plain "4 Card Name" list. Reads the same data as generate_buylist and changes nothing; run claim_from_collection first or owned copies still count as coverable. Give `unpriced_items` with the total, and relay `rate_missing` when present: it means no CHF price could be given at all.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `deck` (string): Deck id or name; omit for all decks combined

Output parameters:

- `cards` (number)
- `currency` (string)
- `deck` (string|null): Null: every deck
- `items` (array)
- `more_items` (number): Items counted and not listed
- `note` (string)
- `rate_missing` (string): Present when CHF was asked and no CHF rate is stored: no CHF price could be given at all, the cards are not unpriced. Relay it.
- `text` (string)
- `total_estimated` (number): Leaves out unpriced_items: give that count with the total
- `unpriced_items` (number)
- `view` (string)

### `show_deck` (~207 tokens)

Show a deck

Use this when the user asks how a deck (id or name) stands and a summary card helps: claimed (and how many of those sleeved), shared, free to claim and missing, legality, proxies, price to complete in `currency` (default USD), with the shared and missing cards listed and a link to the deck. Reads the same data as deck_status and deck_health and changes nothing. ALWAYS relay every `shared` row with the other decks and where the card physically is (`borrowed`: another deck holds the copy; `lent`: this deck holds it and another counts on it), and the `proxies` count.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `deck` (string, required): Deck id or name

Output parameters:

- `deck` (object)
- `image_uri` (string|null): The card's picture on Scryfall, to show as it is; null when the catalogue has none
- `legal` (boolean)
- `missing` (array)
- `more_missing` (number)
- `more_shared` (number)
- `note` (string)
- `price_to_complete` (object)
- `proxies` (number): Claimed proxies: always say so
- `shared` (array): Relay every row, with the other decks and where the card physically is
- `totals` (object)
- `view` (string)

### `show_buildable_decks` (~138 tokens)

Show what can be built

Use this when the user asks what they can build or play and a ranked list helps: the decks already in Reliquary, most complete first, each with a picture, the share of its list at hand and the first cards it misses, optionally for one format. Reads the same data as what_can_i_build and changes nothing. "At hand" counts claimed, shared and free copies together: 100% does not mean sleeved, and a deck at 100% may share copies with another deck. A deck that is not in Reliquary is not ranked: import it first.

Input parameters:

- `format` (string)

Output parameters:

- `decks` (array)
- `format`
- `more_decks` (number)
- `note` (string)
- `view` (string)

### `show_card` (~264 tokens)

Show a card

Use this when the user asks to see a card ("show me Lightning Bolt", "what does Rhystic Study look like?") or to compare a few: up to 8 cards, each drawn with its picture, mana cost, type line, rules text and printing, and its Scryfall link. A name may be in any language Scryfall prints; the card comes back under its English `name`, and `asked` keeps what was asked: when they differ, say which card it is ("Foudre is Lightning Bolt"). A bare name shows the printing the name means; give set_code and collector_number for one printing. This is a preview of the card, not of the player's copies: it says nothing about what they own (where_is and show_card_location do). Each card in `not_found` was not found: say so, with its `error`. Link each card's name to its `scryfall_url`. A name newer than the catalogue is looked up on Scryfall; a scryfall_id is read from the catalogue alone.

Input parameters:

- `cards` (array, required): The cards to show, 1 to 8: each by name (any language) or scryfall_id, optionally with set_code + collector_number

Output parameters:

- `cards` (array)
- `not_found` (array): Cards asked for and not found: say so
- `note` (string)
- `view` (string)

### `allocate` (~159 tokens)

Allocate

Allocate copies of a holding (holding_id from search_collection/where_is) to a deck (id or name). shared:false (default) claims free copies exclusively — the sum of non-shared allocations can never exceed the stack size. shared:true deliberately shares copies that other decks also use (always disclose: which decks, where the card physically is). status "staged" (default) earmarks without moving; "sleeved" also physically moves the cards into the deck's location (splitting the stack when only part of it is sleeved).

Input parameters:

- `deck` (string, required): Deck id or name
- `holding_id` (string, required)
- `quantity` (integer, required)
- `shared` (boolean)
- `status` (string)

### `sleeve` (~50 tokens)

Sleeve

Mark a staged allocation as sleeved: the cards physically move into the deck's location (stack splits if partial). allocation_id comes from allocate/deck_status/where_is.

Input parameters:

- `allocation_id` (string, required)

### `sleeve_deck` (~187 tokens)

Sleeve deck

Sleeve everything a deck (id or name) has claimed for itself, in one call: each staged, non-shared allocation becomes sleeved and its copies physically move into the deck's location (a stack the deck holds only part of is split). Use it once the user says the deck is physically built. Borrowed copies never move: a shared allocation stays staged, and so does a copy whose stack another deck has sleeved. Returns `sleeved` and `stayed`; every `stayed` row carries its `reason`, the other decks (`also_allocated_to`) and where the card is (`physically_in`). ALWAYS tell the user which cards stayed and why, name the other decks on any `sleeved` row that lists them, and say which sleeved cards are proxies (`is_proxy`).

Input parameters:

- `deck` (string, required): Deck id or name

### `unsleeve` (~58 tokens)

Unsleeve

Take a sleeved allocation back out of the deck: status returns to staged and the cards physically move to return_location (id or name, default "Unsorted").

Input parameters:

- `allocation_id` (string, required)
- `return_location` (string)

### `claim_from_collection` (~267 tokens)

Claim from collection

Auto-match a deck's wants against the collection: free copies become non-shared staged allocations (real cards preferred over proxies). allow_shared:true additionally covers remaining needs with copies already allocated to OTHER decks, as explicitly shared allocations. Returns claimed / shared / missing. ALWAYS relay the shared list (with the other decks) and the missing list to the user. Every proxy it claims, owned or borrowed, is named in proxies_claimed (each claimed and shared entry carries is_proxy); proxy_warning, when not null, is one sentence: relay it to the user word for word. Claiming moves no real card: once the user has physically built the deck, sleeve_deck moves the claimed cards into it. On a tournament deck (deck.play) only real copies are claimed. They fill empty slots first, and each one past them releases one of the card's proxies (proxies_replaced, released: relay them). A released proxy that was sleeved is recorded back in "Unsorted": tell the user to take it out of the deck box and sleeve the real copy. This powers the "import deck → pull what I have → tell me what I lack" workflow.

Input parameters:

- `allow_shared` (boolean): Default false
- `deck` (string, required): Deck id or name

### `deallocate` (~96 tokens)

Deallocate

Release an allocation (fully, or `quantity` copies of it). Sleeved copies physically return to return_location (default "Unsorted"). Identify the allocation by allocation_id, or by holding_id + deck.

Input parameters:

- `allocation_id` (string)
- `deck` (string): Deck id or name (with holding_id)
- `holding_id` (string)
- `quantity` (integer)
- `return_location` (string)

### `deallocate_all` (~82 tokens)

Deallocate all

DESTRUCTIVE: release EVERY allocation of a deck (holdings are never deleted; sleeved cards return to return_location, default "Unsorted"). Without confirm:true this returns a dry-run summary; repeat with confirm:true to execute.

Input parameters:

- `confirm` (boolean)
- `deck` (string, required): Deck id or name
- `return_location` (string)

### `allocation_conflicts` (~56 tokens)

Allocation conflicts

Decks that cannot be physically assembled at the same time: holdings promised (shared + non-shared) to more decks than copies exist. Use after claim_from_collection with allow_shared, and before the user takes decks to an event.

Output parameters:

- `conflicts` (array)
- `summary` (string)

### `find_substitutes` (~517 tokens)

Find substitutes

Cards that could replace a target card, two ways. `similar`: the cards whose rules text is nearest the target's (precomputed over the whole catalogue, best first: nearest by text, with a nearer mana value, a more played card and one whose effects point at the same side ahead; `similarity` 0–1 is the text closeness alone, not a verdict), fitted to the deck when given — its colour identity (both commanders of a pair, else the target's), legal in its format, not already in it — as `owned` (the user's cards with free copies) and `to_buy` (cheapest priced printing in `currency`, null when none is priced; `owned_claimed` = copies the user owns that the decks in `claimed_by` claim in full: name them). Nearness is in the words, not in how a card plays with the deck: YOU judge which do the job, and say so. `similar.known` false means no list exists for the card yet. `candidates`: owned cards passing mechanical filters only (a shared primary type, cmc within cmc_window, default ±2, ignored for lands; optional price_ceiling per copy; with a deck, legal in its format). Both lists leave out a banned card, and a restricted one unless the row holds a single copy, since a swap keeps the row's count. Disclose free vs. claimed counts, say `proxies` beside a card that has any, and name every deck in `shared_with`. A card to buy with no price yet gets one from the nightly price refresh (`price_queued` is always false: this tool queues nothing). To make the swap, call replace_card with the row's want_id. Read-only: it changes nothing and starts no work; a target named by a name newer than the catalogue is looked up on Scryfall. Not on every plan: a PLAN_LIMIT answer says so.

Input parameters:

- `cmc_window` (number)
- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `deck` (string): Deck context (id or name)
- `limit` (integer)
- `price_ceiling` (number)
- `target` (object, required): The card to replace

Output parameters:

- `candidates` (array): Owned cards passing mechanical filters only: judge functional similarity yourself
- `constraints` (object)
- `note` (string)
- `similar` (object)
- `target` (object)

### `cards_for_commander` (~494 tokens)

Cards for a commander

Cards that belong in a commander deck (id or name; Commander, Duel Commander or Pauper Commander, with its commander set), in two lists titled by `title` ("For <commander>"; never call them recommendations). `played_with`: what the commander's tournament lists play, most played first — `share` 0–1 of its lists play the card, `share_elsewhere` of the format's other lists (a card far above its share elsewhere is this commander's own). Whenever you mention these counts, credit every source in `sources` by name with its link (TopDeck.gg always), and when `cedh` is true say they are cEDH tournament lists, not casual decks; `note` says it in one sentence. `known` false: under 10 lists a year, no counts. `on_theme`: the cards nearest the commander's rules text in its colours (`closeness` 0–1, not a verdict), for every commander, without the cards `played_with` holds. They are cards LIKE the commander — goblin makers for a goblin maker — and miss cards that work WITH it (the instants a spell-trigger commander wants): YOU judge which fit, and say so. Both lists are fitted to the deck: in its colour identity, legal in its format, not already in it; `owned` = the user's cards with free copies, `to_buy` = cheapest priced non-foil printing in `currency` (default USD), null when none is priced yet (the nightly price refresh prices it; `price_queued` is always false and `prices_queued` 0). Say `proxies` beside a card that has any, name every deck in `shared_with` (those copies are borrowed), and name the decks in `claimed_by` when `owned_claimed` > 0. `limit` per list and side, default 10, max 30. Read-only: it changes nothing and starts no work.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `deck` (string, required): Deck id or name
- `limit` (integer)

Output parameters:

- `commanders` (array)
- `deck` (object)
- `on_theme` (object)
- `played_with` (object)
- `prices_queued` (number): Always 0: this tool queues nothing; the nightly refresh prices a card with no price
- `title` (string): What the lists are called ("For <commander>"); never call them recommendations

### `deck_combos` (~452 tokens)

Combos in a deck

The combos in a deck (id or name), any format, from Commander Spellbook's combo database (a copy refreshed with the card catalogue, not a live search). `in_list`: combos the deck's main list holds whole, most played first (up to 30; `in_list_total` says how many, counted among the 400 most played candidates read). `one_card_away`: combos the list misses one card of, most played first (up to 20; `more_one_card_away` when there are more), that card legal in the deck's format, in its colour identity and not in the deck: `missing.have` "owned" = the user owns a free copy (say `proxies` beside it when > 0, and name every deck in `shared_with`: those copies are borrowed), "to_buy" = its cheapest priced non-foil printing in `currency` (default USD; null when none is priced yet), and when `owned_claimed` > 0 name the decks in `claimed_by` that hold the user's copies. Each combo: its `cards` (`must_be_commander`: it works only from the command zone, so it counts only when that card leads the deck), `produces` (what it makes), `requires` (a kind of card it also needs, any one), `prerequisites` (the board it starts from), `mana_needed`, `steps`, `notes`, and `url`, its page on Commander Spellbook. Whenever you show a combo, credit Commander Spellbook by name with the link in `source`. `known` false: the combos are not loaded yet. Spellbook lists combos as written; check a combo's steps against the cards' text and rulings (card_detail) before you vouch for it. Changes nothing.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `deck` (string, required): Deck id or name

Output parameters:

- `deck` (object)
- `in_list` (array)
- `in_list_total` (number)
- `known` (boolean): False: the combos are not loaded yet
- `more_one_card_away` (boolean)
- `one_card_away` (array)
- `source` (object): Commander Spellbook: credit it by name with this link whenever a combo shows

### `list_locations` (~35 tokens)

List locations

All physical locations (binders, boxes, shelves, …) incl. each deck's auto-created location, with holding/card counts.

Output parameters:

- `locations` (array)

### `create_location` (~52 tokens)

Create location

Create a physical location. kind: binder | box | deckbox | shelf | other (deck locations are automatic).

Input parameters:

- `kind` (string)
- `name` (string, required)
- `notes` (string)

### `audit_location` (~65 tokens)

Audit location

Reconciliation view for a location (id or name): every holding physically there, plus — for deck locations — sleeved allocations that claim to be there, and any mismatches (allocation says sleeved but the stack is elsewhere).

Input parameters:

- `location` (string, required): Location id or name

Output parameters:

- `location` (object)
- `mismatches` (array): Claims sleeved here whose stack is physically elsewhere
- `physically_here` (array)
- `sleeved_here_on_paper` (array): A deck place: the claims sleeved into this deck
- `total_cards` (number)

### `create_share_link` (~698 tokens)

Create share link

Create (or fetch the existing) public share URL for a wantlist, deck, or tradelist. kind "wantlist": the cards still MISSING from a deck — or from the personal wantlist when no deck is given. kind "deck": the full decklist with prices. By default it is the list alone — card names, any printing. show_printings:true adds the exact printing and finish of the copies in the deck (else the printing the list pins); show_proxies:true adds which copies are proxies. ASK the user which they want before sharing a deck that contains proxies or special printings. Passing either option for a deck that is already shared changes the existing link in place (same URL). kind "tradelist" with a location: every card physically there (typically "Trade Binder"), with condition and prices. kind "tradelist" WITHOUT a location: the user's tradelist by rule, what `rule` picks — unclaimed (every copy no deck claims), spares_card (all but one copy of each card; a claimed copy counts as the one kept) or spares_printing (all but one of each printing). Default spares_card; passing rule on the existing link changes it in place. Explain what the rule publishes and ask before publishing it. keep_open (spares rules only, default false): true keeps one copy of each card even from decks open to trade, so a card the user owns once is never offered; false offers every copy an open deck claims. It applies to every tradelist the user publishes. Every tradelist also carries the claimed copies of decks marked open_to_trade (update_deck) and copies decks borrow as shared, each naming the deck a trade breaks (breaks_decks: the deck names are public on the page). A tradelist never lists a proxy. The URL is PUBLIC — anyone holding it can view the list until it is revoked; tell the user this when sharing something sensitive. Minting is idempotent per target: sharing the same thing again returns the same URL. Only a new kind "deck" link counts toward the plan (PLAN_LIMIT past it); a wantlist or tradelist link never…

Input parameters:

- `deck` (string): Deck id or name — required for kind "deck"; optional for "wantlist" (omit to share the personal wantlist)
- `keep_open` (boolean): kind "tradelist" with no location only: under a spares rule, keep one copy of each card even from decks open to trade
- `kind` (string, required)
- `location` (string): Location id or name for a place's tradelist, e.g. "Trade Binder"; omit for the tradelist by rule
- `rule` (string): kind "tradelist" with no location only: what the tradelist by rule offers
- `show_printings` (boolean): kind "deck" only. Show the exact printings the owner plays. Default false on a new link; omitted keeps an existing link's setting.
- `show_proxies` (boolean): kind "deck" only. Show which copies are proxies. Default false on a new link; omitted keeps an existing link's setting.

### `list_share_links` (~60 tokens)

List share links

List every share link this user has minted — kind, what it points at (deck or location name), public URL, whether it is revoked, and for deck links what they show (show_printings, show_proxies: 1 or 0).

Output parameters:

- `links` (array): Every link the user minted, newest first, revoked ones included

### `revoke_share_link` (~86 tokens)

Revoke share link

Take a share link offline immediately. Accepts the link id, the bare token, or the full /s/ (or legacy /w/) URL. Privacy-restoring, so it needs no confirmation — but the old URL dies permanently; sharing the same list again later mints a NEW URL.

Input parameters:

- `link` (string, required): Share link id, token, or full share URL

### `read_share_link` (~229 tokens)

Read share link

Read someone else's public Reliquary share link — a /s/ or /w/ URL, or the bare token. Returns the list contents with prices plus next_steps for acting on it. This is ANOTHER person's public list: never present it as the current user's own data. A tradelist never lists a proxy: no trade offers one. A deck share carries options {show_printings, show_proxies}: proxy_quantity on a row is how many of the owner's copies are proxies — relay it; proxy_quantity null (show_proxies false) means the owner did NOT say, so never tell the user the deck is proxy-free. With show_printings false, set_code is null and the row means any printing of that card. deck.commanders names who leads a deck share: none, one card, or a pair — name both of a pair. deck.companion names its companion, a sideboard row marked is_companion; null for none.

Input parameters:

- `currency` (string): Display currency, default USD
- `link` (string, required): Full share URL or bare token

Output parameters:

- `card_count` (number)
- `currency` (string)
- `deck`
- `decklist_text` (string)
- `kind` (string): Another person's public list: never present it as the current user's own
- `next_steps` (string)
- `of_deck` (boolean): A wantlist: true when it is a deck's missing cards, false the personal wantlist
- `options` (object): A deck share: what the owner chose to show beyond the list
- `proxy_cards` (number|null): A deck share: proxy copies in the owner's deck; null when the owner chose not to say
- `rows` (array)
- `rule`: A tradelist by rule: what the owner offers (every copy no deck claims, or all but one of each card / printing); null a place's
- `title` (string): A wantlist: what it is of. A tradelist: the place it is, or "Tradelist" for one by rule
- `total_price` (object)
- `total_value` (object)

### `match_wantlist` (~325 tokens)

Match wantlist

What the CURRENT user could SEND another player: that player's missing cards against the current user's copies. Takes their shared wantlist or deck link (a /s/ or /w/ URL, or the bare token) or their handle ("@name": every wantlist they published). Free copies come first; where they run out, copies a deck of the user claims are offered too, after them. Each match has copies[]: printing, finish, condition, where it physically is, unit_price in `currency` (default USD; null = no price known, and unpriced_quantity says how many copies a row's value leaves out). A proxy is never offered: the answer holds real cards only, and its proxy fields are always zero. includes_shared / copies[].shared_with name decks of the user that SHARE that stack. copies[].breaks_decks names EVERY deck of the user that claims or shares the copy: for each, say "trading this card breaks your deck <name>" before any trade talk. A row's lang is the language the other player asked for; copies[].other_language marks a copy in another language: say "not the language asked for".

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `token` (string, required): Full share URL, bare token, or a handle written with its @

Output parameters:

- `matches` (array): What the user could send: free copies first, then copies a deck of the user's claims (named in breaks_decks); never a proxy
- `total` (object)

### `match_tradelist` (~278 tokens)

Match tradelist

What the CURRENT user could GET from another player: the cards in that player's tradelist that the user's decks or personal wantlist still miss. Takes their tradelist link (URL or bare token) or their handle ("@name": every tradelist they published). Each match says you_need, they_offer, wanted_by (the user's deck names, or "Personal wantlist") and copies[] with printing, finish, condition, language and unit_price in `currency` (default USD). A want that pins a printing matches that printing only. A proxy is never offered: the answer holds real cards only, and its proxy fields are always zero. copies[].breaks_decks names the other player's decks that claim or share the copy: say "trading this breaks their deck <name>". A row's lang is the language the user's list asks for; copies[].other_language marks a copy in another language: say "not the language asked for".

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `link` (string, required): Full share URL, bare token, or a handle written with its @

Output parameters:

- `matches` (array): What the user could get from the other player's tradelist
- `total` (object)

### `compare_trade` (~358 tokens)

Compare a trade

Read-only: compares, and proposes or changes nothing (offer_swap is the tool that proposes a swap to a friend). Both directions of a trade with one player in ONE call: you_send (as match_wantlist) and you_get (as match_tradelist), each with its rows, card count and value in `currency` (default USD; CHF and EUR are what players at a table use), plus difference {amount, direction: you_send_more | you_get_more | even, unpriced_cards}. When unpriced_cards > 0 the gap leaves those cards out — say so, never call such a trade even. `with` is that player's handle ("@name") or one or two of their share links (their wantlist, their tradelist). A side they have not published is null and listed in not_published. This is everything that matches, NOT advice on which cards to trade and not an evened-out deal: present both lists and the gap, and let the players choose. Same disclosure duties as match_wantlist and match_tradelist: no proxy is ever offered; name every deck a copy breaks (copies[].breaks_decks, either side) and every copy in another language than asked. `with` names the player's handle also when reached by a wantlist or tradelist link.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…
- `with` (array, required): One handle ("@name"), or one or two share links of the same player

Output parameters:

- `currency` (string)
- `difference`: Everything that matches on both sides, not an evened-out deal; null unless both sides are published
- `not_published` (array)
- `note` (string)
- `with` (string|null): The other player's handle ("@name"), also when reached by a wantlist or tradelist link; null for a deck share or a player without one
- `you_get`: null: they published no tradelist
- `you_send`: null: they published no wantlist

### `draft_trade_post` (~288 tokens)

Draft a trade post

Read-only: writes the TEXT of a trade list for the user to copy and post themselves (WhatsApp, Discord, anywhere). It posts nothing, sends nothing and publishes nothing (style: whatsapp | discord | text; default whatsapp): list "deck" (the deck's missing cards, linked by its wantlist link), "wantlist" (the personal wantlist's missing cards) or "tradelist" (what the user's published tradelists offer, linked by their handle). One line a card: count, name, the printing when the list pins one, a flag for a language other than English (one with no flag is written as its name), and on a tradelist each copy a deck of the user claims or plays shared named with that deck (lines[].breaks_decks): relay it. `cards` keeps only those names. Relay `text` as it is, in a code block or ready to copy. This tool NEVER publishes: when url is null no link is live yet — the note says which create_share_link call would publish it; ask the user before calling it, then call this again.

Input parameters:

- `cards` (array): Only these card names (English); omit for the whole list
- `deck` (string): Deck id or name, for list "deck"
- `list` (string, required)
- `style` (string)

Output parameters:

- `cards` (number): Copies the message lists
- `lines` (array)
- `note` (string)
- `publish`: With no live link: what create_share_link would publish to carry this post. Ask the user first
- `text` (string): The message to post, ready to copy: relay it as it is
- `url` (string|null): The live link the message ends with; null: none is published, and the text has no link

### `set_handle` (~175 tokens)

Set handle

Take, change or give up the current user's handle: the name other players type ("@name") to find the wantlists and tradelists this user has PUBLISHED with create_share_link. 3–20 characters: letters, digits, "-" and "_". handle null gives it up. Tell the user what a handle exposes: anyone who knows it — signed in or not, at /@name — sees every wantlist and tradelist link that is not revoked, never a deck share, the collection, a name or an email. Revoking a link removes it from the handle at once. Giving up the handle also leaves the trade circle: every friend and request goes. Changing it keeps the circle.

Input parameters:

- `handle` (string|null, required): The handle to take, with or without the @; null to give it up

### `read_handle` (~132 tokens)

Read handle

Without `handle`: the current user's own handle (null when they have none) and its public URL. With `handle` ("@name"): the wantlists and tradelists that player published, each with its share URL — read one with read_share_link, or go straight to compare_trade with the handle. Exact match only: there is no search and no list of handles, and an unknown handle answers the same as one with nothing published. This is ANOTHER player's public data: never present it as the current user's own.

Input parameters:

- `handle` (string): Another player's handle; omit for the current user's own

Output parameters:

- `handle` (string|null): Without a handle asked: the user's own, null when they have none
- `lists` (array): Another player's published lists: never present them as the current user's own
- `url` (string|null): The user's own handle page

### `add_friend` (~203 tokens)

Add friend

Ask another player into the current user's trade circle by their handle ("@name"). Friends are matched against each other in one call (match_circle). A request reaches only a handle that has a wantlist or tradelist published; any other handle answers "Nothing is published under @name", the same as a lookup, so this never tells whether a player exists. The user needs a handle of their own (set_handle): it is the only thing the friend sees of them. status "pending" waits for the friend to accept; a request they already sent is accepted at once ("accepted"). What a friend can see: exactly what the handle publishes (wantlists and tradelists), never the collection, a deck share, a name or an email. The account's plan holds a number of friends, requests sent included: past it the answer is a plan limit naming the page that describes plans.

Input parameters:

- `handle` (string, required): The friend's handle, written with its @

### `accept_friend` (~75 tokens)

Accept friend

Accept a circle request another player sent the current user (my_circle lists them under requests_received). Both become friends at once: each sees what the other's handle publishes, in match_circle. Counts against the friends the account's plan holds.

Input parameters:

- `handle` (string, required): The handle of the player who sent the request, with its @

### `remove_friend` (~79 tokens)

Remove friend

Remove a friend from the current user's trade circle, decline a request they received, or cancel one they sent — by the other player's handle. `was` says which it was. Both sides stop seeing each other's match; nothing in either collection changes. Asking again needs a new request.

Input parameters:

- `handle` (string, required): The friend's handle, with its @

### `my_circle` (~147 tokens)

My circle

The current user's trade circle: friends, requests_received (waiting for the user: accept_friend or remove_friend), requests_sent (waiting for the friend), each by handle with the date. places_taken counts friends and requests sent against cap (null = no limit). handle is the user's own, null when they have none. invites: the invite links the user made (invite_friend), each for one player, with its state: open, waiting (a newcomer signed up and has not accepted yet: they have no handle, so they are told here, not under requests_sent), accepted, closed or expired. An open or waiting link takes a place against cap; cancel_invite gives it back.

Output parameters:

- `cap` (number|null): Friends the account's plan holds, requests sent included; null = no limit
- `friends` (array)
- `handle` (string|null): The user's own handle; null when they have none (they need one to add friends)
- `invites` (array): Invite links the user made (invite_friend), newest first: the last 30 days, and any still waiting. Open and waiting ones take a place against cap
- `places_taken` (number): Friends, requests sent and open invite links, counted together against cap
- `requests_received` (array): Waiting for the user: accept_friend or remove_friend
- `requests_sent` (array): Waiting for the friend to accept

### `match_circle` (~316 tokens)

Match circle

Every friend in the current user's trade circle at once, both directions: for each friend, you_send (their published wantlists' missing cards against the user's copies, free ones first, as match_wantlist) and you_get (their published tradelists against what the user's decks and wantlist miss, as match_tradelist), with values in `currency` (default USD) and the difference, as compare_trade. A side the friend has not published is null and in not_published. Each row has `new`: not there at the user's last recorded look; new_cards counts them per friend — lead with those. Once you have shown the user the matches, call mark_circle_seen so the next look marks only what came after (this tool itself never records a look). Each friend is matched alone, so one copy can show against several friends: say so when it does. Disclosure duties, as match_wantlist and match_tradelist (no proxy is ever offered): name every deck a copy breaks (copies[].breaks_decks: "trading this card breaks <deck>"), and every copy not in the language asked for (copies[].other_language). This is everything that matches, not advice on what to trade.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…

Output parameters:

- `currency` (string)
- `friends` (array)
- `note` (string)
- `totals` (object)

### `mark_circle_seen` (~74 tokens)

Mark circle seen

Record that the current user has seen their trade circle's matches: the next match_circle (here or on the Trade page) marks as `new` only what came after. Call it once after showing the user match_circle's answer, never before and never in the background. marked_friends counts the friends whose match changed.

### `invite_friend` (~141 tokens)

Invite friend

An invite link for ONE player who is not on Reliquary yet, to bring them into the current user's trade circle. Relay `url` and `sentence` for the user to send (WhatsApp, a message): the sentence counts the cards the user's handle publishes and never names one. The link is single use and lasts 30 days: the first account made through it gets a circle request from the user waiting, which the new player accepts. A player already on Reliquary is added by handle (add_friend) instead. Needs the user's own handle (set_handle) and a free place in the plan's circle; a few links a day.

### `cancel_invite` (~98 tokens)

Cancel invite

Take back an invite link the current user made (my_circle lists them, with their code): an open link stops bringing anyone in, and a link a newcomer used has its circle request withdrawn. Either way its place in the plan's circle is free again. A link whose player accepted is a friend now: remove_friend instead.

Input parameters:

- `code` (string, required): The link's code, the part after /i/ (or the whole link)

### `offer_swap` (~283 tokens)

Offer swap

Propose a swap to a FRIEND in the trade circle, from match_circle's rows with that friend: `send` picks rows of you_send and `get` rows of you_get, each by card name and count (a card with several rows: narrow with printing and lang, as the row shows them). Copies go as the match deals them: free ones first, then a deck's copy, never a proxy. Nothing outside the match can be added. `add_to` names, for a card the user GETS, the deck of theirs that claims it once the swap is approved: only on the user's say-so, never by default. Nothing moves until the friend approves; it expires after 14 days, and the user can withdraw it (answer_swap). Before calling, show the user both sides, their values, and every deck of theirs a copy they send breaks (breaks_decks in match_circle), and ask. The answer is the swap as my_swaps shows it.

Input parameters:

- `add_to` (array): Cards the user gets that a deck of theirs claims on the yes, as the user ticked them
- `get` (array): Rows of you_get to receive, with counts
- `send` (array): Rows of you_send to send, with counts
- `with` (string, required): The friend's handle, with its @

### `my_swaps` (~194 tokens)

My swaps

The current user's swaps with friends: waiting_for_you (proposed to the user: approve or decline with answer_swap), waiting_for_friend (proposed by the user: they may withdraw it), and answered in the last 30 days. Each swap: you_give and you_receive with cards, value in `currency` (default USD) and lines. Disclosure duties: name every deck of the user's a copy they give breaks (lines[].breaks_decks), and on an open swap every claim the yes would release (lines[].would_release). The friend's deck names are never shown. An open swap past expires_at reads expired.

Input parameters:

- `currency` (string): Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav…

Output parameters:

- `answered` (array): Approved, declined, withdrawn or expired, the last 30 days
- `currency` (string)
- `note` (string)
- `waiting_for_friend` (array): Proposed by the user: the friend answers; the user may withdraw
- `waiting_for_you` (array): Proposed to the user: approve or decline (answer_swap)

### `answer_swap` (~193 tokens)

Answer swap

Answer a swap: approve or decline one proposed to the current user, or withdraw one they proposed. Approve moves cards in both collections at once: each copy given leaves its owner (the claims it no longer fits released, and named), each copy received lands in Unsorted as a trade. Without confirm: true, approve is a dry run: show the user what they give, receive and what would_release names, and ask before confirming. `add_to` ticks, for a card the user receives, the deck of theirs that claims it: only on the user's say-so. Refused, with nothing moved, when a copy is gone or changed since the proposal. Decline and withdraw move nothing.

Input parameters:

- `add_to` (array)
- `answer` (string, required)
- `confirm` (boolean): approve only: true to move the cards; without it nothing moves
- `swap_id` (string, required)

### `import_deck` (~466 tokens)

Import deck

Create a deck from pasted decklist text — the reliable path, ask for it first ("4 Lightning Bolt (2XM) 123" per line; Commander/Sideboard sections, "SB:" lines and *F* foil markers understood; any site's text export works: Moxfield, Archidekt, MTGGoldfish, MTGO, Arena). The link of a public Moxfield deck (moxfield.com/decks/…) is also accepted: it is asked for once, as a browser would. When Moxfield does not answer, the error says so — ask the user to open the deck on Moxfield → More → Export, copy the text, and retry with decklist_text. Sideboard cards land in the sideboard section; up to two commanders are kept as a pair. A companion (a Companion section, Moxfield's companion, *CMPN*) becomes the deck's companion, in the sideboard. Wants are stored oracle-level (any printing satisfies them). Card names may be in any language Scryfall prints ("4 Blitzschlag", "1 Foudre"): read_as lists each with the English card it was read as — tell the user. A foreign name several cards share is left unresolved with those cards named: ask which. Returns the deck, unresolved card names, ignored_lines (lines that were not a card: show them to the user, never guess) and notes to relay — e.g. a Commander list that came with a sideboard keeps it, and legality will flag it. Never refused for the plan: a deck past the decks the user's plan keeps editable is imported whole and answers editable:false and plan_limit, which names the decks that take edits: relay it. Typical next step: claim_from_collection to pull owned cards and report what is missing.

Input parameters:

- `commander` (object): Commander override (else detected from the source)
- `companion` (object): Companion override (else detected from the source)
- `decklist_text` (string): Plain decklist text — preferred
- `format` (string)
- `name` (string): Deck name override
- `url` (string): Public Moxfield deck URL (alternative to decklist_text; Moxfield may block it)

### `import_batch` (~471 tokens)

Import batch

Bulk-import collection rows that were parsed client-side from a CSV export: rows = the CSV rows as objects keyed by the file's own column headers. format: auto (default) recognises the app from the headers — ManaBox, Deckbox (also Delver Lens's Deckbox preset), Moxfield, Dragon Shield, Sorted, Archidekt, TCGplayer app, MTGGoldfish, TopDecked, Helvault, Deckstats, MTGStocks, CardCastle — and reads any other file by its column names (Name / Card Name, Set Code, Set Name, Collector Number, Quantity, Foil / Finish, Condition, Language, Scryfall ID, Purchase Price, Reg Qty + Foil Qty). Pass a format id only to overrule the detection; decklist (or decklist_text with no rows) reads plain decklist text into the collection. The response names the format it read (detected_format) and sets unchecked_layout when that layout was written without a real export file to test it: tell the user, and suggest they look over the first cards once the job is done. A Cardmarket export cannot be imported (it names cards only by Cardmarket's product number) and is refused with that reason. A card named in another language is read as its English card (fix_unresolved with job_id lists them as read_as). A set given by name only is matched to its set when the name is the one Scryfall uses; otherwise the card's newest regular printing is taken. Max 500 rows per call — pass the returned job_id in follow-up calls to continue the same job, then processing runs in the background in resumable chunks. ManaBox binders / Dragon Shield folders become locations automatically. Returns job status; when it finishes as needs_review, use fix_unresolved. A name matching no card exactly is looked up on Scryfall, at most 200 an import and 500 a day per player: a row past that is left for fix_unresolved, saying why.

Input parameters:

- `decklist_text` (string)
- `format` (string)
- `job_id` (string): Continue a previously created job
- `rows` (array)
- `start` (boolean): Begin background processing (default true)

### `fix_unresolved` (~130 tokens)

Fix unresolved

Review imports that need attention. Without row_id: list unresolved rows (optionally for one job_id). With job_id, read_as also lists rows that named their card otherwise, each with the English card it was read as ("Blitzschlag" → Lightning Bolt): tell the user. With row_id + printing (scryfall_id, or name/set_code/collector_number): resolve that row to the given printing and import it with the original quantity/condition/price attributes.

Input parameters:

- `job_id` (string)
- `printing` (object)
- `row_id` (string)

### `export_collection` (~62 tokens)

Export collection

Export the whole collection as CSV text. format moxfield_csv (re-importable into Moxfield) or deckbox_csv. Large collections produce large text — offer the REST endpoint /api/v1/export/collection for downloads.

Input parameters:

- `format` (string, required)

Output parameters:

- `csv` (string)

### `export_deck` (~106 tokens)

Export deck

Export a deck (id or name) as plain decklist text: Commander section first when set (both of a pair), then a Companion section when the deck names one, then the "N Card Name" lines of the main deck, then a Sideboard section when there is one, the companion repeated there as Arena writes it (pinned printings keep their set/collector number). import_deck reads it back whole.

Input parameters:

- `deck` (string, required): Deck id or name

Output parameters:

- `decklist` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/gg-reliquary-reliquary/reliquary#diagnostics

## Score history

- 2026-11-21: 78
- 2026-11-20: 78
- 2026-11-19: 77
- 2026-11-18: 40
- 2026-11-17: 40
- 2026-11-16: 40
- 2026-11-15: 40
- 2026-11-14: 40
- 2026-11-13: 40
- 2026-11-12: 40
- 2026-11-11: 40
- 2026-11-10: 40

## Common questions

### What is the Reliquary MCP server?

Reliquary is an MCP server listed in the public MCP registry as gg.reliquary/reliquary. Your Magic: The Gathering collection, decks and trades, with every shared copy disclosed. This page covers its hosted endpoint (https://reliquary.gg/mcp).

### Is the Reliquary MCP server safe to use?

Reliquary scores 78 out of 100 on VerifyMCP. 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 Reliquary MCP server expose?

Reliquary exposes 74 tools: search_collection, add_holdings, update_holding, remove_holding, crack_pack, and 69 more. Their descriptions and schemas cost roughly 16,663 tokens of context every time the server is loaded.

### Does the Reliquary MCP server require authentication?

Yes. Reliquary asked us for credentials when we connected, so you will need to authorise it in your MCP client before it can do anything.

### Is the Reliquary MCP server still maintained?

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

### What did VerifyMCP test on the Reliquary MCP server?

VerifyMCP ran 14 checks on Reliquary, covering TLS certificate, Authorization, HTTPS, HSTS header and 10 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://reliquary.gg/mcp
- Website: https://reliquary.gg/connect
- Changelog RSS feed: https://verifymcp.io/servers/gg-reliquary-reliquary/reliquary.xml
- Changelog JSON feed: https://verifymcp.io/servers/gg-reliquary-reliquary/reliquary/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/gg-reliquary-reliquary/reliquary.json
- HTML version of this page: https://verifymcp.io/servers/gg-reliquary-reliquary/reliquary
