Tarot MCP Server
This server provides tarot card information, search, readings, and session management through MCP tools.
Get detailed card info by name, language (en/zh), and orientation
List all cards, filterable by category (major/minor arcana, suits)
Search cards by keyword, suit, element, arcana, number, or orientation
Find similar cards and compare 2–5 cards with optional orientations
List available spreads and get spread recommendations based on question, category, and timeframe
Perform readings using 25+ built-in spreads, including single card, Celtic Cross, and moon-phase readings
Create custom spreads with your own positions and meanings
Get daily card guidance and random card draws
Retrieve moon-phase readings with optional custom date
View database analytics and improvement recommendations
Track and review reading history within sessions using session IDs
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Tarot MCP Serverdo a Celtic Cross reading about my career path this year"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Tarot MCP
A bilingual tarot reading service and visual card table, built with TypeScript, React and Vite. It includes a complete 78-card Rider–Waite–Smith deck, original Midnight Art Nouveau artwork, 25 built-in spreads, and daily, moon-phase and custom readings.
Write a question, start each shuffle yourself, cut the current deck, and choose face-down cards in order. Confirmation keeps the table visible and retries the same selection; it never silently draws replacement cards. Reveal the cards individually before the overall interpretation appears. In an embedded MCP App, the reader can then explicitly request interpretation in ChatGPT. The standalone Web page keeps the server's local interpretation and does not claim to send it to ChatGPT.
Run locally
Requires Node.js 20.19 or later and npm.
npm ci
npm run start:http -- --host 127.0.0.1npm ci runs the package's prepare build. Open
the card table. To rebuild after changes:
npm run buildFor server development, npm run dev:http -- --host 127.0.0.1 executes the
TypeScript source. Rebuild the UI with npm run build:ui after frontend edits;
these commands do not start a Vite development server or hot reload the page.
Related MCP server: Tarot MCP Server
Which protocol is this?
Surface | Implementation | Entry point |
MCP server | Official MCP SDK; stdio, Streamable HTTP and legacy SSE |
|
MCP Apps | Official Apps SDK; single-file embedded React UI |
|
Browser WebMCP | Experimental imperative provider using |
|
HTTP API | Express routes used by the standalone web page |
|
WebMCP is a Community Group draft, not a finalized W3C Standard. The browser provider follows the September 4, 2026 draft's registration surface and also handles Chrome 152's execution callbacks. Unsupported browsers retain the manual card table. MCP Apps and an HTTP MCP endpoint alone are not WebMCP. See the WebMCP implementation notes for the source references, exposed tools, browser differences and verification instructions.
Connect an MCP client
For a local checkout, use the absolute built entry path:
{
"mcpServers": {
"tarot": {
"command": "node",
"args": ["/absolute/path/to/tarot-mcp/dist/index.js"]
}
}
}For a client accepting a remote Streamable HTTP URL, use
http://127.0.0.1:3000/mcp. If MCP_AUTH_TOKEN is configured, supply its Bearer
authorization header. The web page accepts the same token under Connection
settings and stores it only in the current browser tab's session storage.
An MCP Apps client renders the table in its conversation. For local stdio clients without Apps support, the default browser fallback opens a temporary loopback page for the same pending draw. The original tool call stays pending until the user confirms, allowing the conversation to continue with the result. HTTP/SSE servers do not open a browser on the server machine.
Client and environment configuration covers Cursor, ChatWise's long-running option, browser fallback modes, session persistence, authentication and origin/host allowlists.
Code map
Location | Responsibility |
| Canonical deck, card validation, search, analysis and formatting |
| Spreads, reading interpretation, visual draw lifecycle and sessions |
| Domain types, shared visual input schema, localization and utilities |
| Tool implementations calling the domain services |
| MCP protocol, Apps capabilities and browser handoff delivery |
| HTTP listener, middleware and public static assets |
| REST routing, MCP transport sessions and JSON-RPC errors |
| Async requests, cancellation, retries and reading transitions |
| Card selection, animation state and stage composition |
| Browser feature detection, tool registration and live page access |
| Ordered styles for setup, controls, ritual, draw, reading and responsive behavior |
| Web and MCP artwork variants, manifest and QA evidence |
| Reproducible artwork processing and verification |
Original PNGs, artwork provenance and QA files are retained because they are inputs or evidence for the deck pipeline. Full-resolution sources and contact sheets are excluded from the distributable build; they are not duplicate runtime assets. See the artwork workflow.
Checks
npm run build # Server, Web UI, self-contained MCP App and assets
npm run test:all # Domain, transport, UI and WebMCP regression tests
npm run lint
npm run verify:build # Deck integrity and packaged asset checksnpm run test:coverage measures the server suite. Transport tests need permission
to listen on loopback ports and create local IPC sockets.
The UI suite covers selection order, cut/shuffle behavior, confirmation retries, reveal and details, localization, host handoff, and WebMCP lifecycle/cancellation. Native browser checks are described in WebMCP verification.
Deploy
The personal ChatGPT deployment uses the official Secure MCP Tunnel, not a
public endpoint or directory submission. The base Compose listener is restricted
to 127.0.0.1:3000; the tunnel override adds container-to-container Bearer auth
and the pinned ghcr.io/openai/tunnel-client:v0.0.14 image on the project network.
On the chosen server, with Docker running, Compose v2 or newer, curl, and the GitHub CLI available:
cp -n .env.example .env
# Fill the three values privately in .env; do not commit or print the file.
gh attestation verify oci://ghcr.io/openai/tunnel-client:v0.0.14 -R openai/tunnel-client && \
bash deploy.shStop if provenance verification fails. deploy.sh validates required variables
without printing resolved secrets, builds without first taking the service down,
and checks tarot health followed by private tunnel readiness. Readiness is not
proof that ChatGPT has discovered or used the connection.
See private ChatGPT setup
for the runtime-key/organization/workspace requirements, No Authentication
connection, refresh procedure, and verification commands. Use the local Web page
or your own SSH local forwarding; this configuration does not publish /draw to
the internet. The named tarot-sessions volume preserves reading history.
Pending draws remain process-local and are lost on restart; the UI asks the
reader to start again instead of retrying an invalid deck indefinitely.
Further documentation
Code is licensed under MIT. Artwork has its own documented provenance and licensing terms.
Available Tools
14 toolscreate_custom_spreadA
Create a custom tarot spread and draw cards for it. Use this when no existing spread fits your needs and you want to create your own layout with specific positions and meanings.
| Name | Required | Description | Default |
|---|---|---|---|
| language | No | Output language (default: en) | en |
| question | Yes | The question or focus for this reading | |
| positions | Yes | Array of position objects defining each card position in the spread | |
| sessionId | No | Optional session ID returned by a previous reading; omit to start a new session | |
| spreadName | Yes | Name for your custom spread | |
| description | Yes | Description of what this spread is designed to explore |
Output Schema
| Name | Required | Description |
|---|---|---|
| cards | Yes | |
| question | Yes | |
| readingId | Yes | |
| sessionId | No | Present when the reading is tracked in a session |
| timestamp | Yes | ISO 8601 |
| spreadName | Yes | |
| spreadType | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are minimal (readOnlyHint=false, idempotentHint=false). The description adds that the tool draws cards, indicating a write/creation action. It does not contradict annotations. However, it does not detail side effects like session creation or storage, so its behavioral disclosure is adequate but not extensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, both front-loaded with the action and usage guidance. Every sentence adds value without wasted words. It is concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema (mentioned in context signals), the description does not need to explain return values. It covers the tool's purpose and usage context adequately for a creation tool. However, it could mention that the tool also draws cards and possibly initiates a session, but overall it is quite complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so every parameter has a description in the schema. The tool description adds no additional parameter details beyond 'specific positions and meanings' which is already implied by the schema. Therefore, the description does not significantly enhance parameter understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a custom spread and draws cards for it. It specifies the action verb 'Create' and the resource 'custom tarot spread', and distinguishes it from using existing spreads.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use this tool: 'when no existing spread fits your needs'. This distinguishes it from sibling tools like list_available_spreads or recommend_spread. It implies not to use if a standard spread suffices, though it doesn't explicitly list exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
find_similar_cardsARead-onlyIdempotent
Find cards with similar meanings to a given card
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of similar cards to return (default: 5) | |
| cardName | Yes | The name of the card to find similar cards for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey read-only and idempotent behavior. The description adds no further behavioral context such as error handling, result limits (already in schema), or the definition of 'similar meanings'. It is adequate but does not go beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence of 11 words that clearly communicates the tool's purpose without any extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple, read-only tool with complete schema and annotations, the description is nearly complete. It could mention the output format or definition of similarity, but the core functionality is well covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already describes both parameters (cardName and limit). The description does not add any additional semantic information about the parameters beyond what is in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Find' and resource 'cards' with the qualifier 'with similar meanings to a given card'. It distinguishes from siblings like 'search_cards' (general search) and 'get_card_meanings_comparison' (comparison of two specific cards).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance is provided. The description only states what the tool does, with no mention of alternatives or context for choosing this tool over siblings like 'get_card_meanings_comparison' or 'search_cards'. The usage is implied from the name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_card_infoARead-onlyIdempotent
Get detailed information about a specific tarot card from the Rider-Waite deck
| Name | Required | Description | Default |
|---|---|---|---|
| cardName | Yes | The name of the tarot card (e.g., 'The Fool', 'Two of Cups') | |
| language | No | Output language (default: en) | en |
| orientation | No | The orientation of the card (upright or reversed) | upright |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true. Description adds no further behavioral context beyond 'get detailed information', which is consistent. No disclosure of potential rate limits, response size, or data structure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with verb and resource. No wasted words, efficient and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a simple info retrieval tool with well-documented parameters and annotations. However, lacks specifics on what 'detailed information' includes (e.g., meanings, symbols), which would be helpful given no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear descriptions for all three parameters. Description does not add additional meaning beyond schema, but baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states action (get detailed information), resource (specific tarot card), and source (Rider-Waite deck). Distinguishes from siblings like list_all_cards, search_cards, get_card_meanings_comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implied usage for fetching detailed info on a single card, but no explicit when-to-use or when-not-to-use guidance, nor alternatives mentioned. Adequate but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_card_meanings_comparisonARead-onlyIdempotent
Compare 2-5 tarot cards, including optional card orientation, to understand their relationships and combined message
| Name | Required | Description | Default |
|---|---|---|---|
| cards | No | Preferred input: array of 2-5 card objects with names and optional orientations | |
| context | No | The context or question for interpreting these cards together | |
| language | No | Output language: "en" or "zh" (default: en) | en |
| cardNames | No | Legacy input: array of 2-5 card names, interpreted as upright |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description clarifies that the tool compares cards and outputs a combined message, which aligns with annotations (readOnlyHint, idempotentHint). No contradictions; adds context beyond the annotations by describing the output purpose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that front-loads the core action (compare cards) with key details (2-5, optional orientation, output purpose). No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is complete for this tool: it covers the main use case, parameters are well-documented in schema, annotations provide safety hints, and no output schema exists to explain return values. Nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description does not add new semantics beyond summarizing the function, achieving baseline with no additional parameter-level detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool compares 2-5 tarot cards with optional orientation to understand relationships and combined message. It distinguishes from siblings like get_card_info (single card) and get_random_cards (random selection).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for comparing cards but does not explicitly state when to use this tool versus alternatives like perform_reading or recommend_spread. No when-not-to-use guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_daily_cardARead-only
Draw a single card for daily guidance and insight
| Name | Required | Description | Default |
|---|---|---|---|
| language | No | Output language (default: en) | en |
| question | No | Optional specific question for daily guidance | What do I need to know for today? |
Output Schema
| Name | Required | Description |
|---|---|---|
| cards | Yes | |
| question | Yes | |
| readingId | Yes | |
| sessionId | No | Present when the reading is tracked in a session |
| timestamp | Yes | ISO 8601 |
| spreadName | Yes | |
| spreadType | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description's addition of 'single card' and 'daily guidance' provides some context but no further behavioral traits like randomness or state dependence. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no redundancy, front-loaded with action and context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 optional params, read-only, output schema exists), the description sufficiently covers the purpose and usage context. No major gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and descriptions are provided for both parameters. The tool description adds no extra semantics beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'Draw a single card' and the context 'daily guidance and insight', distinguishing it from siblings like 'get_random_cards' (multiple cards) and 'perform_reading' (spread-based).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for daily guidance but gives no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_database_analyticsARead-onlyIdempotent
Get comprehensive analytics and statistics about the tarot card database
| Name | Required | Description | Default |
|---|---|---|---|
| includeRecommendations | No | Whether to include improvement recommendations (default: true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds no behavioral insights. It neither contradicts nor significantly extends the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence that conveys the tool's purpose without any extraneous text. Every word is necessary.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one optional param, no output schema, strong annotations), the description is minimally adequate. However, it does not elaborate on what statistics or analytics are provided, which could be important for agent decision-making.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% coverage for the single optional parameter, so the schema already documents its meaning. The description does not add any parameter-specific context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Get') and resource ('comprehensive analytics and statistics about the tarot card database'), which is distinct from all sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, context, or when it would be inappropriate to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_moon_phase_readingBRead-only
Perform a tarot reading based on the current moon phase with an appropriate spread
| Name | Required | Description | Default |
|---|---|---|---|
| language | No | Output language (default: en) | en |
| question | Yes | Your question or intention for the moon phase reading | |
| customDate | No | Optional custom date in YYYY-MM-DD format (defaults to today) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the read-only nature is clear. The description adds that the reading is moon-phase-based and uses an appropriate spread, providing some behavioral context but not extensive details beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no redundancy, efficiently conveying the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema and the complexity of a tarot reading, the description should explain what the reading returns (e.g., card names, interpretation). It does not, leaving critical information gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% description coverage, so the description adds little extra meaning. It does not clarify that customDate overrides the moon phase date, leaving ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs a tarot reading based on the moon phase with an appropriate spread, which is specific and distinguishes it from siblings like 'perform_reading' and 'get_daily_card'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'perform_reading' or 'get_daily_card'. The description lacks context on preferred use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_random_cardsBRead-only
Get random cards with optional filtering
| Name | Required | Description | Default |
|---|---|---|---|
| suit | No | Filter by card suit | |
| count | No | Number of random cards to draw (default: 1) | |
| arcana | No | Filter by arcana type | |
| element | No | Filter by element |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description does not contradict annotations (readOnlyHint=true). It adds minimal behavioral context beyond 'random' and 'optional filtering', but the annotations already indicate a safe read operation. No side effects or additional behaviors are disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that conveys the core functionality without unnecessary words. It could be slightly expanded to include more context without becoming verbose, but it remains concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool and the presence of annotations, the description is mostly adequate. However, it lacks information about the return format or what constitutes a 'card' object, which would be helpful without an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema coverage, the baseline is 3. The description summarizes the parameters as 'optional filtering', which adds little beyond the schema. It does not provide specific details about each parameter beyond what is already in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get random cards') and the resource ('cards'), with optional filtering. It effectively distinguishes the tool from siblings like 'list_all_cards' and 'search_cards', which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives, such as 'search_cards' for specific queries or 'list_all_cards' for a complete listing. The context of 'random' is implied but not elaborated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_session_historyARead-onlyIdempotent
List the readings performed so far in a session (summaries with spread, question, time, and drawn cards)
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | Yes | The session ID returned by a previous reading |
Output Schema
| Name | Required | Description |
|---|---|---|
| createdAt | Yes | ISO 8601 |
| sessionId | Yes | |
| readingCount | Yes | |
| storedReadings | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and idempotentHint=true, and the description adds context that it returns summaries with specific fields. However, it does not describe error handling, pagination, or limits. The description adds some value beyond annotations but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that directly conveys purpose and content. It is front-loaded with the verb and resource, with no redundant information. Efficient but could benefit from more structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter) and presence of an output schema, the description adequately conveys what the tool returns. It specifies the fields in summaries, so the agent has a good idea of the output. Missing details about empty sessions or limits, but overall complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%; the only parameter 'sessionId' is described in the schema as 'The session ID returned by a previous reading'. The description does not add additional semantics for the parameter beyond this, so baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resource 'readings performed so far in a session', specifying the content of summaries. It distinguishes from sibling tools like perform_reading (which creates a reading) and get_card_info (which retrieves card details).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs alternatives, such as when a session exists or how to obtain a sessionId. The description only states what it does, without prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_all_cardsARead-onlyIdempotent
List all available tarot cards in the Rider-Waite deck
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | Filter cards by category | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, so the description adds the deck specificity but no additional behavioral insights beyond that. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One clear sentence, no fluff, front-loaded with the core action. Perfectly concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with one optional parameter and robust annotations, the description is sufficient. It could optionally mention output format or default behavior, but not necessary.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides full description for the single parameter 'category' (enum with description), so the description does not need to add more. Baseline 3 applies due to high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'list', the resource 'available tarot cards', and specifies the deck 'Rider-Waite', which distinguishes it from sibling tools like search_cards or get_card_info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly indicates use for getting all cards but does not provide explicit guidance on when to use this tool versus alternatives like search_cards or get_random_cards.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_available_spreadsARead-onlyIdempotent
List all available tarot spreads with their positions and meanings
| Name | Required | Description | Default |
|---|---|---|---|
| language | No | Output language (default: en) | en |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description states the tool 'List all available spreads', which aligns with the readOnlyHint=true and idempotentHint=true annotations. It adds value by specifying that positions and meanings are included, going beyond the annotations alone.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It immediately identifies the action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description provides enough context by stating the tool returns spreads with positions and meanings. Given the tool's simplicity (one optional parameter), the description is reasonably complete for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema coverage is 100% (single parameter 'language' with enum and default). The description does not mention the language parameter, but the schema already fully describes it. Baseline of 3 is appropriate since no additional semantics are added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'List' and identifies the resource as 'available tarot spreads' with the detail 'with their positions and meanings', which clearly distinguishes it from sibling tools like 'get_daily_card' or 'recommend_spread'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for browsing spreads but provides no explicit guidance on when to use this tool versus alternatives like 'recommend_spread' or 'create_custom_spread'. The context signals show no required parameters, suggesting simple usage, but the lack of when-not usage is a gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
perform_readingC
Perform a tarot card reading using a specific spread
| Name | Required | Description | Default |
|---|---|---|---|
| language | No | Output language (default: en) | en |
| question | Yes | The question or focus for the reading | |
| sessionId | No | Optional session ID returned by a previous reading; omit to start a new session | |
| spreadType | Yes | The type of tarot spread to perform |
Output Schema
| Name | Required | Description |
|---|---|---|
| cards | Yes | |
| question | Yes | |
| readingId | Yes | |
| sessionId | No | Present when the reading is tracked in a session |
| timestamp | Yes | ISO 8601 |
| spreadName | Yes | |
| spreadType | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate this is not read-only (readOnlyHint: false) and not idempotent, but the description adds no additional behavioral context. It does not disclose side effects, state changes, or return format beyond the schema. With sparse annotations, the description should provide more transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no waste. It is concise but could be more informative without losing brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of tarot readings (many spread types, session handling, language options) and that an output schema exists, the description is incomplete. It does not explain session behavior, output structure, or how to interpret results, leaving significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description only adds 'using a specific spread', which does not clarify the meaning of parameters like question, sessionId, or language beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('perform') and the resource ('tarot card reading') and mentions the key parameter ('using a specific spread'). However, it does not distinguish this tool from siblings like get_daily_card or list_available_spreads, which could be alternatives for obtaining readings or card information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives. The description does not specify prerequisites, when not to use it, or how it compares to sibling tools such as get_daily_card or recommend_spread.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
recommend_spreadARead-onlyIdempotent
Get a recommendation for the most appropriate tarot spread based on your question or situation
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | The category of your question | any |
| language | No | Output language (default: en) | en |
| question | Yes | Your question or description of the situation you want guidance on | |
| timeframe | No | The timeframe you're asking about | any |
Output Schema
| Name | Required | Description |
|---|---|---|
| category | Yes | |
| question | Yes | |
| timeframe | Yes | |
| recommendations | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and idempotentHint=true, but the description adds no additional behavioral context such as how the recommendation is made, limitations, or what the output contains. The description merely restates the purpose without enriching the behavioral understanding beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, well-structured sentence of 15 words immediately conveys the tool's purpose. Every word earns its place, there is no redundancy, and the key action and resource are front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (4 parameters, output schema exists but not detailed in description), the description is minimally adequate. It does not explain how to interpret the recommendation or what output to expect, but the existence of the output schema somewhat compensates. Sibling differentiation is not addressed, leaving some context gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not mention any parameters, but the schema already adequately describes each parameter's meaning, so no additional value is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Get a recommendation' and identifies the resource as 'the most appropriate tarot spread', clearly distinguishing from sibling tools like 'list_available_spreads' (which just lists) and 'create_custom_spread' (which creates).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context that the tool is used 'based on your question or situation', implying it is for selecting a spread. However, it lacks explicit guidance on when not to use it or alternatives, which prevents a higher score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_cardsARead-onlyIdempotent
Search for tarot cards using various criteria like keywords, suit, element, etc.
| Name | Required | Description | Default |
|---|---|---|---|
| suit | No | Filter by card suit | |
| limit | No | Maximum number of results to return (default: 10) | |
| arcana | No | Filter by arcana type | |
| number | No | Filter by card number | |
| element | No | Filter by element | |
| keyword | No | Search keyword to find in card meanings, keywords, or symbolism | |
| orientation | No | Search in upright or reversed meanings |
Output Schema
| Name | Required | Description |
|---|---|---|
| results | Yes | |
| showing | Yes | |
| totalMatches | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds no extra behavioral details (e.g., pagination, response format) beyond mentioning search criteria.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that front-loads the core purpose. It is appropriately concise, though a bit more structure (e.g., mentioning default limit) could improve clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (7 parameters, output schema exists), the description is functional but minimal. It lacks details on how filters combine (AND/OR) and assumes the agent knows default behavior. The output schema covers return values, so completeness is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description merely echoes the parameter list without adding new semantic meaning, meeting the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'search' and the resource 'tarot cards', and lists example criteria like keywords, suit, and element. It distinguishes itself from sibling tools such as 'find_similar_cards' and 'get_random_cards' by being a general search tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for searching cards with filters but does not explicitly state when to use this tool versus alternatives like 'list_all_cards' or 'find_similar_cards'. No 'when not to use' guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
14 tool updates
v1.0.0- First observed
create_custom_spread - First observed
find_similar_cards - First observed
get_card_info - First observed
get_card_meanings_comparison - First observed
get_daily_card - First observed
get_database_analytics - First observed
get_moon_phase_reading - First observed
get_random_cards - First observed
get_session_history - First observed
list_all_cards - First observed
list_available_spreads - First observed
perform_reading - First observed
recommend_spread - First observed
search_cards
TDQS
Scored across 14 tools
Each tool has a clearly distinct purpose, from card info to reading types to analytics. While some tools involve drawing cards, their contexts (daily, moon phase, custom spread, general reading) are well-defined and described.
All tools follow a consistent snake_case verb_noun pattern (e.g., get_card_info, perform_reading, list_available_spreads), making the naming predictable and easy to interpret.
14 tools cover the domain thoroughly without being excessive. Each tool serves a specific need in tarot reading, from database exploration to personalized readings.
The tool set covers core tarot functionalities: card info, various reading types, spread management, search, and history. Minor gaps like advanced filtering or reading notes exist but do not hinder primary use cases.
Maintenance
Related MCP Connectors
Tarot card meanings, spreads and seeded reproducible readings for AI agents, one API key.
tarot-draw MCP — wraps StupidAPIs (requires X-API-Key)
Official Divine API MCP for Horoscope, Tarot, Numerology, and PDF Reports.
Related MCP Servers
- FlicenseBqualityDmaintenanceEnables users to perform tarot card readings and generate horoscopes based on specified dates, times, and locations. Provides mystical divination services through tarot draws and astrological calculations.2-
- AlicenseAqualityCmaintenanceProvides tarot card reading capabilities with a complete 78-card deck, multiple spread layouts (Celtic Cross, Past-Present-Future, etc.), and detailed card interpretations for divination and daily guidance.910 npm5MIT
- AlicenseAqualityAmaintenanceProvides tarot card meanings, spreads (three-card, yes/no), and random draws for any MCP-compatible client.53 npm2MIT
- AlicenseNot gradedqualityBmaintenanceProvides fortune-telling tools including tarot card spreads, Thai horoscope, zodiac info, and auspicious dates. Enables interactive tarot card picking via an MCP App UI and returns structured JSON for interpretation.1,106 npmMIT