@imqueue

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.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200,
      "description": "A question or a symbol name, e.g. 'expose a service method', 'delayed jobs' or 'IMQOptions.safeDelivery'"
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "maximum": 20,
      "description": "Max results (default 6)"
    },
    "package": {
      "type": "string",
      "description": "Restrict results to one package, e.g. 'http-protect' or '@imqueue/opentelemetry'. Use it once you know which package you want — the same words appear in several packages' symbols."
    }
  },
  "required": [
    "query"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "The query that was searched"
    },
    "count": {
      "type": "integer",
      "description": "Number of results returned (0 means no matches)"
    },
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "title": {
            "type": "string"
          },
          "section": {
            "type": "string",
            "description": "Where it sits in the docs, e.g. 'Guides' or 'API · @imqueue/core property'"
          },
          "description": {
            "type": "string"
          },
          "url": {
            "type": "string",
            "description": "Pass this to get_doc to read the page in full"
          },
          "symbol": {
            "type": "boolean",
            "description": "True for a generated API-reference page rather than prose"
          }
        },
        "required": [
          "title",
          "section",
          "description",
          "url"
        ],
        "additionalProperties": false
      },
      "description": "Most relevant first"
    },
    "advisories": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Present when the results involve two packages that cover the same ground. Each names both options with the rule for choosing — install exactly one, never both."
    }
  },
  "required": [
    "query",
    "count",
    "results"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

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.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "An imqueue.org or imqueue.com page URL, e.g. https://imqueue.org/get-started/"
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "The markdown mirror actually fetched — not always the URL passed in, which is why it is worth returning"
    },
    "markdown": {
      "type": "string",
      "description": "The page body — the same text carried in content, minus the heading path prefix"
    },
    "mimeType": {
      "type": "string",
      "description": "Media type of the page body carried in markdown and content"
    },
    "bytes": {
      "type": "integer",
      "description": "Size of the page body, so a caller can decide before reading it"
    },
    "truncated": {
      "type": "boolean",
      "description": "True when the page was too large to return whole — markdown holds the leading part only"
    },
    "section": {
      "type": "object",
      "properties": {
        "heading": {
          "type": "string",
          "description": "The section's own heading"
        },
        "ancestors": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Headings above it, outermost first — the path that says which 'Verify' this is"
        },
        "index": {
          "type": "integer",
          "description": "1-based position among the page's indexed sections"
        },
        "total": {
          "type": "integer",
          "description": "How many indexed sections the page has, so a caller can see what it did not read"
        }
      },
      "required": [
        "heading",
        "ancestors",
        "index",
        "total"
      ],
      "additionalProperties": false,
      "description": "Present when a #fragment resolved to one section — markdown is that section, not the page"
    },
    "fragmentMiss": {
      "type": "object",
      "properties": {
        "anchor": {
          "type": "string",
          "description": "The #fragment that was asked for and not found"
        },
        "available": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Anchors the page does index, for a retry"
        }
      },
      "required": [
        "anchor",
        "available"
      ],
      "additionalProperties": false,
      "description": "Present when a #fragment matched no indexed section — markdown is the WHOLE page, not the slice that was asked for"
    }
  },
  "required": [
    "url",
    "markdown",
    "mimeType",
    "bytes",
    "truncated"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

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.

{
  "type": "object",
  "properties": {},
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "packages": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "install": {
            "type": "string",
            "description": "The exact install command, including -g where the package is a CLI"
          },
          "summary": {
            "type": "string"
          },
          "version": {
            "type": "string",
            "description": "Highest published release. Absent only if the status feed was unreachable"
          },
          "license": {
            "type": "string",
            "description": "SPDX identifier of the published package"
          },
          "node": {
            "type": [
              "string",
              "null"
            ],
            "description": "engines.node, or null where the package declares no floor of its own"
          },
          "released": {
            "type": "string",
            "description": "Publication date of `version`, as YYYY-MM-DD"
          },
          "deprecated": {
            "type": "boolean"
          },
          "pick": {
            "type": "string",
            "description": "Present only where two packages cover similar ground: the rule for choosing between them"
          }
        },
        "required": [
          "name",
          "install",
          "summary"
        ],
        "additionalProperties": false
      },
      "description": "Ordered by what to reach for first"
    },
    "framework": {
      "type": "object",
      "properties": {
        "license": {
          "type": "string"
        },
        "licenseNote": {
          "type": "string",
          "description": "The licence terms in a sentence, including what the SPDX id alone does not say"
        },
        "node": {
          "type": "string",
          "description": "The Node version the framework as a whole requires"
        },
        "redis": {
          "type": "string"
        },
        "commercial": {
          "type": "string",
          "description": "Where to get a licence for closed-source distribution"
        }
      },
      "required": [
        "license",
        "licenseNote",
        "node",
        "redis",
        "commercial"
      ],
      "additionalProperties": false
    },
    "factsUnavailable": {
      "type": "boolean",
      "description": "True when imqueue.org/status.json could not be read, so no entry carries a version or licence. The catalogue itself is compiled in and still complete"
    }
  },
  "required": [
    "packages"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

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.

{
  "type": "object",
  "properties": {
    "package": {
      "type": "string",
      "description": "One package, with or without the scope: 'rpc', '@imqueue/rpc'. Omit for every package."
    }
  },
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "framework": {
      "type": "object",
      "properties": {
        "license": {
          "type": "string"
        },
        "licenseNote": {
          "type": "string"
        },
        "commercial": {
          "type": "string"
        },
        "node": {
          "type": "string"
        },
        "redis": {
          "type": "string"
        }
      },
      "required": [
        "license",
        "licenseNote",
        "commercial",
        "node",
        "redis"
      ],
      "additionalProperties": false
    },
    "packages": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "scoped": {
            "type": "string"
          },
          "version": {
            "type": "string"
          },
          "license": {
            "type": "string"
          },
          "node": {
            "type": [
              "string",
              "null"
            ]
          },
          "released": {
            "type": "string"
          },
          "firstRelease": {
            "type": "string"
          },
          "releases": {
            "type": "number"
          },
          "majors": {
            "type": "array",
            "items": {
              "type": "number"
            }
          },
          "deprecated": {
            "type": "boolean"
          },
          "install": {
            "type": "string"
          },
          "docs": {
            "type": "string"
          },
          "npm": {
            "type": "string"
          },
          "repo": {
            "type": "string"
          },
          "summary": {
            "type": "string"
          }
        },
        "required": [
          "name",
          "scoped",
          "version",
          "license",
          "node",
          "released",
          "firstRelease",
          "releases",
          "majors",
          "deprecated",
          "install",
          "docs",
          "npm",
          "repo",
          "summary"
        ],
        "additionalProperties": false
      }
    },
    "generated": {
      "type": "string",
      "description": "When the site last read these facts from the npm registry"
    },
    "source": {
      "type": "string"
    }
  },
  "required": [
    "framework",
    "packages",
    "generated",
    "source"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

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.

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Service name, e.g. 'user' or 'UserService'"
    },
    "methods": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "description": "Method name"
          },
          "description": {
            "type": "string",
            "description": "What the method does"
          },
          "params": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "name": {
                  "type": "string"
                },
                "type": {
                  "type": "string",
                  "description": "TypeScript type, e.g. 'string' or 'number[]'"
                },
                "description": {
                  "type": "string"
                },
                "optional": {
                  "type": "boolean",
                  "description": "Mark the parameter optional. @expose() publishes required parameters as mandatory, so callers of the generated client must pass a value for every non-optional one — set this for any parameter a caller may legitimately skip."
                }
              },
              "required": [
                "name",
                "type"
              ],
              "additionalProperties": false
            }
          },
          "returns": {
            "type": "string",
            "description": "TypeScript return type WITHOUT Promise<> — e.g. 'User' or 'string'"
          }
        },
        "required": [
          "name"
        ],
        "additionalProperties": false
      },
      "description": "Methods to expose"
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "service": {
      "type": "string",
      "description": "Class name used, after normalisation ('user' -> 'UserService')"
    },
    "install": {
      "type": "string"
    },
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string"
          },
          "language": {
            "type": "string"
          },
          "content": {
            "type": "string"
          }
        },
        "required": [
          "path",
          "language",
          "content"
        ],
        "additionalProperties": false
      }
    },
    "types": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Complex types the signatures refer to. Each needs @classType() on the class and @property() on every field — types.ts declares them; complete the fields. Empty when every type is a primitive."
    },
    "cliAlternative": {
      "type": "string",
      "description": "The CLI command that creates a full provider-wired project instead"
    }
  },
  "required": [
    "service",
    "install",
    "files",
    "types",
    "cliAlternative"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

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.

{
  "type": "object",
  "properties": {
    "service": {
      "type": "string",
      "description": "The service to call, e.g. 'user' or 'UserService'"
    },
    "methods": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "description": "Method name"
          },
          "description": {
            "type": "string",
            "description": "What the method does"
          },
          "params": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "name": {
                  "type": "string"
                },
                "type": {
                  "type": "string",
                  "description": "TypeScript type, e.g. 'string' or 'number[]'"
                },
                "description": {
                  "type": "string"
                },
                "optional": {
                  "type": "boolean",
                  "description": "Mark the parameter optional. @expose() publishes required parameters as mandatory, so callers of the generated client must pass a value for every non-optional one — set this for any parameter a caller may legitimately skip."
                }
              },
              "required": [
                "name",
                "type"
              ],
              "additionalProperties": false
            }
          },
          "returns": {
            "type": "string",
            "description": "TypeScript return type WITHOUT Promise<> — e.g. 'User' or 'string'"
          }
        },
        "required": [
          "name"
        ],
        "additionalProperties": false
      },
      "description": "Known methods (used to shape the example call)"
    }
  },
  "required": [
    "service"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "service": {
      "type": "string"
    },
    "client": {
      "type": "string",
      "description": "Generated client class name"
    },
    "namespace": {
      "type": "string",
      "description": "The ONLY export of the generated file: a namespace holding the client class. Import this, then `new <namespace>.<client>()` — importing the class directly does not resolve."
    },
    "generateCommand": {
      "type": "string",
      "description": "Run against the RUNNING service to emit the real typed client"
    },
    "output": {
      "type": "string",
      "description": "The file that command writes (a compiled .js lands beside it)"
    },
    "example": {
      "type": "object",
      "properties": {
        "language": {
          "type": "string"
        },
        "content": {
          "type": "string"
        }
      },
      "required": [
        "language",
        "content"
      ],
      "additionalProperties": false,
      "description": "An illustrative call — not a file to write"
    }
  },
  "required": [
    "service",
    "client",
    "namespace",
    "generateCommand",
    "output",
    "example"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

Return the setup instructions for running the full @imqueue MCP server on your own machine. The local server adds the CLI-backed tools, which act on your project files and running services and so cannot be offered by a hosted server. Returns instructions only — it installs nothing.

{
  "type": "object",
  "properties": {},
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "claudeCodeCommand": {
      "type": "string",
      "description": "One-liner for Claude Code"
    },
    "clientConfig": {
      "type": "object",
      "properties": {
        "mcpServers": {
          "type": "object",
          "properties": {
            "imqueue": {
              "type": "object",
              "properties": {
                "command": {
                  "type": "string"
                },
                "args": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                }
              },
              "required": [
                "command",
                "args"
              ],
              "additionalProperties": false
            }
          },
          "required": [
            "imqueue"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "mcpServers"
      ],
      "additionalProperties": false,
      "description": "Drop into an MCP config file as-is. VS Code and Visual Studio use `servers` with type:'stdio' instead of `mcpServers`."
    }
  },
  "required": [
    "claudeCodeCommand",
    "clientConfig"
  ],
  "additionalProperties": false,
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}