Astrology MCP Server: 171+ AI Tools Across 12 Domains [2026]

About the author: Torsten Brinkmann is an Astrologer and Developer Advocate with 16 years of experience in Western astrology and software engineering. He holds an M.Sc. in Computer Science from TU Munich and has contributed to open-source ephemeris and chart rendering libraries. His writing addresses both the astronomical mathematics behind natal charts and the developer integration patterns for astrology APIs.

AI agents are getting smarter, but most are still blind to spiritual and metaphysical data. An agent that can search the web and write code still cannot cast a birth chart, draw tarot cards, interpret dream symbols, or look up crystal healing properties. The Model Context Protocol changes that. MCP gives agents a standardized way to discover and call external tools. The question is: which tools do you give your agent?

Most MCP servers in the spiritual data space cover a single domain. You get astrology tools, or nothing. If you want your agent to combine a birth chart reading with a tarot spread and a dream symbol lookup in one conversation, you need multiple providers, multiple credentials, and multiple configuration blocks. That is credential sprawl, and it kills agent development velocity.

RoxyAPI solves this with 12 dedicated MCP servers, 171+ tools, and one API key.

Why multi-domain MCP matters for AI agents

A single-vertical MCP server handles its own domain well. Point an agent at an astrology-only server and it can cast birth charts, pull horoscopes, and read transits all day. That is enough for a pure astrology chatbot.

But the most compelling AI agent experiences cross domain boundaries. A user asks about their week ahead. The agent could pull their daily horoscope based on sun sign, then draw a tarot card for additional guidance, check their personal year number from numerology, and surface a relevant dream symbol if the user mentions a recurring dream. That multi-domain conversation is impossible with a single-domain MCP server.

With RoxyAPI, your agent discovers 171+ tools across 12 domains through the same authentication mechanism. No credential juggling. No separate billing accounts. No inconsistent response formats.

Ready to build this? RoxyAPI MCP gives your AI agent every insight domain under one key. Follow the MCP setup guide to connect your first server, or see pricing.

How many tools per domain: the full breakdown

Each RoxyAPI domain has its own MCP server at a dedicated URL. Every endpoint in that domain becomes a callable tool. Here is the current count from the live MCP servers:

Count the tools on any single server and the number is unremarkable. The number that is hard to assemble anywhere else is the row labelled Total: Human Design, tarot, I-Ching, dreams, crystals, and angel numbers reachable from the same agent, on the same key, on the same subscription, with every calculation verified against NASA JPL Horizons. That is the axis, not the tool count on one vertical.

How to set up the RoxyAPI MCP servers

Every RoxyAPI MCP server is a remote Streamable HTTP endpoint. No local processes, no Docker containers, no npm packages to install. You point your agent at a URL and it auto-discovers the tools.

There are two surfaces, and picking the right one for the job saves you quota.

The docs server at https://roxyapi.com/mcp/docs is keyless. It exposes one tool, search_docs, over the entire reference, so a coding agent like Claude Code, Cursor, or GitHub Copilot writes correct integration code with the right endpoint paths and field names on the first try. It returns documentation, never live calculations, and it costs nothing.

The per-domain servers at https://roxyapi.com/mcp/{domain-slug} need an API key. These are for the agent you ship: the one that casts a real chart or draws a real spread to answer a user. Grab a key from the pricing page.

Wire the docs server while you build, then add the domain servers your product actually calls. The configs below do both.

VS Code (GitHub Copilot, Cline, Continue)

Create or edit .vscode/mcp.json in your workspace:

{
  "servers": {
    "roxy-docs": {
      "type": "http",
      "url": "https://roxyapi.com/mcp/docs"
    },
    "roxy-astrology": {
      "type": "http",
      "url": "https://roxyapi.com/mcp/astrology",
      "headers": {
        "X-API-Key": "your_api_key_here"
      }
    },
    "roxy-tarot": {
      "type": "http",
      "url": "https://roxyapi.com/mcp/tarot",
      "headers": {
        "X-API-Key": "your_api_key_here"
      }
    },
    "roxy-human-design": {
      "type": "http",
      "url": "https://roxyapi.com/mcp/human-design",
      "headers": {
        "X-API-Key": "your_api_key_here"
      }
    }
  }
}

Reload VS Code after saving. Add more domains by repeating the block with a different slug (vedic-astrology, numerology, forecast, biorhythm, iching, dreams, crystals, angel-numbers, location).

Claude Desktop

Edit your claude_desktop_config.json:

{
  "mcpServers": {
    "roxy-docs": {
      "type": "http",
      "url": "https://roxyapi.com/mcp/docs"
    },
    "roxy-astrology": {
      "type": "http",
      "url": "https://roxyapi.com/mcp/astrology",
      "headers": {
        "X-API-Key": "your_api_key_here"
      }
    },
    "roxy-tarot": {
      "type": "http",
      "url": "https://roxyapi.com/mcp/tarot",
      "headers": {
        "X-API-Key": "your_api_key_here"
      }
    },
    "roxy-dreams": {
      "type": "http",
      "url": "https://roxyapi.com/mcp/dreams",
      "headers": {
        "X-API-Key": "your_api_key_here"
      }
    }
  }
}

Config location: macOS ~/Library/Application Support/Claude/claude_desktop_config.json, Windows %APPDATA%\Claude\claude_desktop_config.json. Restart Claude Desktop after saving.

Claude Code

The fastest path is the RoxyAPI plugin, which registers the keyless docs server and loads a skill in one step:

/plugin marketplace add RoxyAPI/claude-plugin
/plugin install roxyapi@roxyapi

Prefer to wire it by hand? Add servers via CLI, docs server first:

claude mcp add-json roxy-docs '{"type":"http","url":"https://roxyapi.com/mcp/docs"}'

claude mcp add-json roxy-astrology '{"type":"http","url":"https://roxyapi.com/mcp/astrology","headers":{"X-API-Key":"your_api_key_here"}}'

claude mcp add-json roxy-tarot '{"type":"http","url":"https://roxyapi.com/mcp/tarot","headers":{"X-API-Key":"your_api_key_here"}}'

claude mcp add-json roxy-human-design '{"type":"http","url":"https://roxyapi.com/mcp/human-design","headers":{"X-API-Key":"your_api_key_here"}}'

Add --scope user to make servers available across all projects. Run claude mcp list to verify.

Cursor

Cursor uses the same .vscode/mcp.json format shown above. Create the file in your workspace root and reload the editor. While you are writing code, the keyless roxy-docs entry is the one doing the work: it answers "what is the field name for this" without spending a request.

A real multi-domain agent conversation

Here is what a multi-domain spiritual AI agent looks like in practice. The user starts a single conversation and the agent pulls from three different domains without any manual switching.

User: I was born March 15, 1990 at 2:30 PM in Berlin. Can you do a quick birth chart, draw three tarot cards for my week, and tell me what it means that I keep dreaming about water?

Agent workflow:

1. Calls post_astrology_natal_chart from the astrology MCP server with date, time, and coordinates for Berlin
2. Reads the natal chart response: Sun in Pisces, Moon in Scorpio, Ascendant in Leo. Notes the heavy water element presence.
3. Calls post_tarot_spreads_three_card from the tarot MCP server for a past/present/future reading
4. Gets The Moon (past), Ace of Cups (present), The Star (future). Notes the water symbolism in all three cards.
5. Calls get_dreams_symbols_id from the dreams MCP server with id "water" for dream interpretation data
6. Synthesizes everything: "Your birth chart is heavily water-influenced with Sun in Pisces and Moon in Scorpio. Your tarot draw reinforces this with The Moon, Ace of Cups, and The Star, all cards connected to water energy and intuition. Your recurring water dreams align with your natal water dominance. Water in dreams typically signifies emotions surfacing from the subconscious, which makes sense given your Pisces/Scorpio emphasis on emotional depth."

That cross-domain synthesis is the value. No single-domain tool can connect a natal chart to tarot symbolism to dream analysis. The agent needs access to all three domains, and MCP makes that access automatic.

Remote HTTP MCP vs local stdio servers

MCP servers run in two modes: local stdio and remote HTTP. The difference matters for production deployments.

Local stdio means you install a package (usually via npm or pip), and the MCP client spawns it as a child process on your machine. The client and server communicate through standard input/output streams. This works for development but creates operational overhead: you need Node.js or Python installed, the process consumes local resources, and every machine that runs your agent needs the same setup.

Remote HTTP (what RoxyAPI uses) means the server runs at a URL. Your agent sends HTTP POST requests to the server endpoint. No local installation. No child processes. No dependency management. The server handles computation, caching, and scaling.

For AI agent deployments, remote HTTP is simpler. You configure a URL and an API key. That configuration works identically on a laptop, a CI server, a cloud function, or a multi-agent orchestration framework. The tools behind those URLs run on infrastructure verified against NASA JPL Horizons, backed by 6,044 automated tests per deploy, 1,241 of them locked to named external references.

RoxyAPI implements the Model Context Protocol over Streamable HTTP transport, the current standard for remote MCP servers. Tool discovery (tools/list) is free. Tool calls (tools/call) count as billable API requests against your monthly quota.

One more thing that matters once an agent is live: every tools/call accepts an opt-in compact flag. Set it and the response comes back minified, with arrays of same-shaped objects encoded columnar so a field name is sent once rather than once per row. Same data, no fields dropped. Measured against the default output that is roughly 40 percent fewer tokens on a natal chart and about 52 percent on astrocartography, which is inference cost your agent stops paying on every turn. Quota is unaffected: one call is still one request.

Building a spiritual AI agent with the API

Beyond MCP, every RoxyAPI endpoint is also available as a standard REST API. Here is a curl example calling the Western astrology natal chart endpoint:

curl -X POST https://roxyapi.com/api/v2/astrology/natal-chart \
  -H "X-API-Key: your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "date": "1990-03-15",
    "time": "14:30:00",
    "latitude": 52.52,
    "longitude": 13.405,
    "timezone": 1
  }'

The response includes planets with signs, degrees, and houses, plus aspects, chart patterns, and per-planet interpretations. That same data is what your agent receives when it calls the post_astrology_natal_chart MCP tool. MCP wraps the REST API, so every endpoint documented in the API reference is also an MCP tool.

The TypeScript SDK provides full type safety:

import { createRoxy } from "@roxyapi/sdk";

const roxy = createRoxy("your_api_key_here");

const { data: chart } = await roxy.astrology.generateNatalChart({
  body: {
    date: "1990-03-15",
    time: "14:30:00",
    latitude: 52.52,
    longitude: 13.405,
    timezone: 1,
  },
});

Whether you use MCP, REST, or the SDK depends on your architecture. MCP is ideal for AI agents that need to auto-discover tools. REST and SDK are better for deterministic application logic where you know exactly which endpoints to call.

Frequently Asked Questions

Q: Can one MCP server cover multiple spiritual domains? A: Each RoxyAPI domain has its own MCP server with a dedicated URL. You configure multiple servers (one per domain) in your MCP client, but they all use the same API key and the same subscription. Your agent discovers tools from all configured servers simultaneously.

Q: How many MCP tools can an AI agent realistically use in one conversation? A: Most MCP clients can handle hundreds of tools without issues. Claude Desktop, VS Code, and Cursor all support multiple MCP servers with combined tool counts well above 100. The agent selects relevant tools based on the user query, so having 171+ tools available does not create confusion. It creates capability.

Q: What is the difference between remote HTTP MCP and local stdio MCP servers? A: Local stdio requires installing a package and spawning a process on your machine. Remote HTTP (what RoxyAPI uses) runs at a URL with no local dependencies. Remote is simpler for production: same config works everywhere, no version mismatches, no child process management. A tool call adds about 3ms of MCP overhead on top of the underlying API call, so the transport is not what your agent waits on.

Q: Is there an MCP server for tarot, I-Ching, or dream interpretation? A: Yes. RoxyAPI runs a dedicated Remote MCP server for tarot (10 tools), I-Ching (9 tools), dreams (5 tools), crystals (12 tools), and angel numbers (4 tools), each on its own URL and all on the same key as the astrology servers. Assembling that spread elsewhere means a separate vendor, credential, and bill per domain.

Q: How much does multi-domain MCP access cost? A: Every RoxyAPI subscription includes all 12 domains. The Starter plan at $39/month covers 50,000 requests across all domains. That works out to $3.25 per domain per month, and on annual billing it drops to $2.70 per domain, the lowest per-domain price we publish. Getting equivalent coverage from separate single-domain providers would cost $84 to $200+ per month.

One key, twelve domains, 171+ tools

The MCP ecosystem is growing fast, but spiritual and metaphysical data remains underserved. Most providers cover astrology and stop there. RoxyAPI covers 12 domains with 171+ tools under a single API key: Western astrology, Vedic astrology, Human Design, numerology, tarot, forecasting, biorhythm, I-Ching, dreams, crystals, angel numbers, and location data.

If you are building an AI agent, chatbot, or multi-agent system that needs spiritual intelligence, start with RoxyAPI MCP. One key. Twelve servers. 171+ tools. The MCP setup guide has a config snippet for every client above, and connecting the first one takes minutes.