Imqueue MCP vs Xahau MCP — MCP Server Comparison | AllMCPs
Side-by-Side Model Context Protocol Comparison
Imqueue MCP vs Xahau MCP
In-depth architectural comparison of the Imqueue MCP and Xahau MCP MCP servers. Compare execution transports, security boundaries, tool capabilities, quality scores, and ready-to-paste client installation snippets for Claude, Cursor, Windsurf, and VS Code.
At a Glance & Executive Verdict
Imqueue MCP
Developer Tools · Local stdio
Quality: 64/100 (Good) | Auth: No auth required
Xahau MCP
Developer Tools · Local stdio
Quality: 45/100 (Fair) | Auth: No auth required
Verdict Summary: Choose Imqueue MCP if you need specialized Developer Tools tools running via a local process. Choose Xahau MCP if your workspace requires Developer Tools integration with local subprocess execution. Both servers can be configured concurrently in your client's mcpServers manifest.
Which MCP Server Should You Choose?
Choose Imqueue MCP when:
You need dedicated capabilities in the Developer Tools domain.
You prefer local stdio subprocess transport architecture.
Your security boundary fits: No auth required (Free / Open Source).
Search the official @imqueue docs (guides, tutorial, CLI manual, articles) and every exported symbol of every @imqueue package that publishes a generated API reference, returning the most relevant pages with their URLs. Each result names the package it belongs to. Takes a plain question or an exact symbol name such as 'RedisQueue.send', 'PgPubSub.listen' or 'watcherCheckDelay'. Answers 'how do I do X in @imqueue' and confirms a signature before code is written against it. Every result carries the page URL, which get_doc reads in full. Some capabilities are covered by two mutually exclusive packages — @imqueue/pg-prisma vs @imqueue/pg-sequelize, @imqueue/opentelemetry vs @imqueue/datadog — so for a query like 'tracing' or 'database', call list_packages for the choosing rule rather than taking whichever package ranks first, and pass `package` here to search within the one you settled on.
get_doc
Fetch the markdown of an @imqueue documentation page by its URL (as returned by search_docs). Returns plain markdown suitable for reading and quoting. Pass a URL with a #fragment — which is what search_docs returns for a section result — to get just that section plus the heading path above it; pass the URL without one to read the whole page. Only imqueue.org (framework docs) and imqueue.com (licensing, pricing, support) URLs are fetched; anything else is refused. Very large pages are truncated, which the result reports.
list_packages
The complete, authoritative catalogue of documented @imqueue packages, each with its current version, licence, minimum Node version, a one-line summary and its exact install command. Call this BEFORE adding any @imqueue dependency: search_docs can only find a package you already suspect exists, and this is the list. Covers typed RPC over a message queue, the Redis queue engine, the `imq` CLI, jobs and scheduling, Prisma and Sequelize database toolkits, method caching, tag-invalidated caching, PostgreSQL LISTEN/NOTIFY, Zod validation, OpenTelemetry or Datadog tracing, async logging, GraphQL N+1 batching across services, CIDR/IP checks and HTTP rate limiting. Some pairs are mutually exclusive — pg-prisma vs pg-sequelize, opentelemetry vs datadog — and installing both of a pair breaks silently, so read the `pick` rule on those entries before choosing. For one package's release history, links and the framework-wide Node and Redis requirements, use package_status.
Ready-to-Paste Client Configurations
Paste either (or both) of these JSON server blocks into your client config file (e.g. claude_desktop_config.json or ~/.cursor/mcp.json).
Imqueue MCP is categorized under Developer Tools and uses a local stdio subprocess. In contrast, Xahau MCP belongs to Developer Tools using local stdio subprocess. Select Imqueue MCP when you need capabilities focused on developer tools and Xahau MCP when you require tools for developer tools.
The current version, licence, minimum Node version and last release date of any published @imqueue package — or of all of them. Use it when the user asks which version of an @imqueue package is current, what licence it is under, or which Node or Redis version it needs. Covers every published package, including @imqueue/cli and @imqueue/mcp, and also returns the framework-wide licence, Node and Redis requirements, with a `licenseNote` that states the licence terms in a sentence. The facts are read from the npm registry by imqueue.org, and the result says when. Pass `package` for one entry, with or without the @imqueue/ scope; omit it for all of them.
scaffold_service
READ-ONLY: returns generated source code as text and writes nothing to disk, creates no project and runs no command. Generates an idiomatic @imqueue/rpc service (an IMQService subclass with @expose()d, JSDoc-typed methods) plus a bootstrap that starts it. Provide the methods you want, or omit them for a starter template. Any non-primitive parameter or return type also gets a types.ts with the required @classType()/@property() declarations — without those the generated client types it `any`, which compiles. Use create_service (local install only) if you want files actually written.
scaffold_client
READ-ONLY: returns text and writes nothing to disk, and does NOT run the command it shows you. Explains how to generate and use the fully-typed client for an @imqueue service: @imqueue generates the real client from a running service via `imq client generate`, so this returns that exact command plus an illustrative usage snippet. The generated file exports a single namespace holding the client class, so the import shape is not the obvious one — take it from `namespace` rather than guessing. Use generate_client (local install only) if you want the command actually run.
cli_status
Detect whether the `imq` CLI (@imqueue/cli) is installed on this machine and report its version. create_service and generate_client need it; the scaffold_service and scaffold_client tools do not.
cli_help
Run `imq [command] --help` and return the exact, version-accurate flags for a command (e.g. 'service create', 'client generate'). The flags it lists are the ones create_service accepts. Read-only: it prints help and exits.
create_service
Scaffold a real, provider-wired @imqueue service via `imq service create`. Runs as a DRY-RUN by default: it shows the plan and writes nothing. With apply=true it writes files into the target directory and may initialise git, configure CI and push to a remote. Accepts `imq` flags (cli_help lists them) to avoid interactive prompts. Requires the `imq` CLI.
generate_client
Run `imq client generate <Service>` to emit the real, fully-typed client, writing it into the output directory. The target service must be RUNNING — the CLI introspects the live service over its message queue. Requires the `imq` CLI.
cli_install
Install @imqueue/cli globally via `npm install -g @imqueue/cli`, replacing any `imq` already installed. cli_status reports whether it is already present. A global install may require a user-writable npm prefix or elevated permissions.
fleet
Run `imq ctl <action>` over a directory of service repositories. `status` reports what is running and changes nothing; `start`, `stop` and `restart` change which processes are running on this machine. Requires the `imq` CLI.
+2 more tools listed on main page
Xahau MCP Tools (53)
execute_hook
Run the real Hook bytecode in a local VM** against a simulated tx/state → actual accept/rollback, return code, state writes, emits, trace (`LOCAL_VM`).
simulate_transaction
PRE-SIGN FLIGHT SIMULATOR** — predict an unsigned tx's fate: originator + stakeholder hook chains (order canonical from xahaud `Transactor.cpp`/`applyHook.cpp`) run as real bytecode against live state; per-hook verdicts, decoded emits, state writes, static engine preflights, scam score.
what_if
TIME MACHINE** — fetch a real historical tx, apply your overrides, re-simulate at its original ledger. Reproduces the real reward claim's `GenesisMint` to the drop (test-locked).
fuzz_hook
Differential fuzzing**: sweep many generated transactions through the VM to map the hook's accept/rollback **decision boundary** (which tx types / amounts it accepts vs rejects).
annotate_hook_trace
Decode an `execute_hook` `trace[]`** into human-readable values by byte-width: canonical XFL float (`definite`), int64/native-drops (both endians), UInt32 + Ripple-epoch date, candidate account-id → r-address (`possible`), 32-byte hash. Raw hex always preserved; offline.
Post-mortem a real on-chain tx's hooks**: fetch the tx + its `meta.HookExecutions` + engine result, then run each fired hook's **real bytecode** through the VM and compare the VM's accept/rollback to what the chain recorded. On-chain decision is authoritative; VM run is `LOCAL_VM`; `agree` is `null…
vm_fidelity_report
Honest fidelity metric**: replays a committed corpus of real mainnet HookExecutions through the VM and reports agreement % over **comparable (non-degraded)** runs only; offline.
classify_hook
Infer in plain English what a hook does (firewall/emitter/stateful/financial/…).