mcp-server-celery 0.1.0__tar.gz

mcp_server_celery-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ariel Even
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_server_celery-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: mcp-server-celery
+Version: 0.1.0
+Summary: Read-only MCP server for debugging Celery: workers, queue depths, and stuck tasks.
+Keywords: mcp,celery,model-context-protocol,debugging,rabbitmq,redis
+Author: Ariel Even
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Celery
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Requires-Dist: celery>=5.3
+Requires-Dist: fastmcp>=4.1
+Requires-Dist: mcp>=2.3
+Requires-Dist: redis>=5.0
+Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/taltal-beep/mcp-server-celery
+Project-URL: Issues, https://github.com/taltal-beep/mcp-server-celery/issues
+Description-Content-Type: text/markdown
+
+# mcp-server-celery
+
+<!-- mcp-name: io.github.taltal-beep/mcp-server-celery -->
+
+[![CI](https://github.com/taltal-beep/mcp-server-celery/actions/workflows/ci.yml/badge.svg)](https://github.com/taltal-beep/mcp-server-celery/actions/workflows/ci.yml)
+
+An MCP server that lets AI agents debug a running Celery deployment. It checks which workers are alive, what each one consumes, and where messages are piling up — the checks you'd otherwise run by hand with `celery inspect` and `rabbitmqctl` every time something gets stuck.
+
+It is **read-only by default**. Broker passwords are masked in every response, including the broker info that Celery's own `inspect stats` sends back in plain text.
+
+Works with RabbitMQ (`amqp://`) and Redis (`redis://`, `rediss://`).
+
+## Tools
+
+| Tool | What it answers |
+| --- | --- |
+| `list_workers` | Which workers respond, their pool and concurrency, uptime, prefetch count, tasks processed, and the queues each one listens to. |
+| `queue_depths` | How many messages are waiting in each queue and which workers consume it. With no arguments it checks your configured queues plus every queue a live worker consumes. |
+
+Coming next: `active_tasks`, `reserved_tasks`, `scheduled_tasks`, `task_status`, and `diagnose_stuck`, which cross-references the above to flag queues no worker listens to, tasks routed to queues with no consumer, and workers that stopped responding. See the [roadmap](#roadmap).
+
+## Install
+
+Requires Python 3.10+ and [uv](https://docs.astral.sh/uv/).
+
+```bash
+uvx mcp-server-celery
+```
+
+Until the first PyPI release, run it from GitHub:
+
+```bash
+uvx --from git+https://github.com/taltal-beep/mcp-server-celery mcp-server-celery
+```
+
+## Configuration
+
+All configuration is through environment variables.
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `CELERY_BROKER_URL` | `amqp://guest:guest@localhost:5672//` | Broker to inspect. |
+| `CELERY_RESULT_BACKEND` | — | Result backend (used by `task_status`, coming in the next release). |
+| `CELERY_APP` | — | Import path of your app, e.g. `proj.celery:app`. Lets the server see your `task_queues` and routes. `CELERY_BROKER_URL` still overrides the app's broker if both are set. |
+| `CELERY_INSPECT_TIMEOUT` | `1.0` | Seconds to wait for worker replies. Raise it for large or slow clusters. |
+
+`CELERY_APP` has to be importable, so run the server from your project's directory and environment:
+
+```bash
+uv run --with mcp-server-celery mcp-server-celery
+```
+
+## Connect it
+
+### Claude Code
+
+```bash
+claude mcp add celery -e CELERY_BROKER_URL=redis://localhost:6379/0 -- uvx mcp-server-celery
+```
+
+### Cursor
+
+In `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "celery": {
+      "command": "uvx",
+      "args": ["mcp-server-celery"],
+      "env": { "CELERY_BROKER_URL": "redis://localhost:6379/0" }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+In `claude_desktop_config.json`, use the same `command`, `args` and `env` block as Cursor, under `mcpServers`.
+
+## Example
+
+Ask the agent "why are my email tasks not running?" and it can call `queue_depths`:
+
+```json
+{
+  "broker": "amqp://app:****@rabbit:5672//",
+  "queues": [
+    { "queue": "celery", "exists": true, "messages": 0, "consumers": 2, "workers_consuming": ["w1@web", "w2@web"] },
+    { "queue": "emails", "exists": true, "messages": 1843, "consumers": 0, "workers_consuming": [] }
+  ]
+}
+```
+
+`emails` has a backlog and no worker consumes it: the workers were started without `-Q emails`.
+
+## Notes on the data
+
+- **Redis** has no notion of consumers, so `consumers` is `null`; use `workers_consuming`, which comes from the workers themselves. Redis also deletes a queue's key once it is empty, so a drained queue shows `"messages": 0, "exists": null`.
+- **RabbitMQ** checks use a passive declare, so the server never creates a queue. A queue that doesn't exist shows `"exists": false`.
+- Workers that are too busy to answer within `CELERY_INSPECT_TIMEOUT` don't appear in `list_workers`. If a worker you expect is missing, try a larger `timeout` argument before assuming it's dead.
+
+## Safety
+
+- Every tool is annotated `readOnlyHint: true`. Write actions (revoke, retry, purge) will only be available behind an explicit opt-in flag.
+- URL credentials and `password`/`secret`/`token` fields are masked in all output and error messages.
+
+## Roadmap
+
+**v0.1** — `list_workers`, `queue_depths` ✅
+
+**v1** — `active_tasks`, `reserved_tasks`, `scheduled_tasks`, `task_status(task_id)`, `diagnose_stuck`
+
+**v2** — `summarize_failures`: groups recent failures by task name and exception type. Celery keeps no failure history by default, so this needs an event listener.
+
+## Development
+
+```bash
+uv sync
+uv run pytest tests/unit
+uv run ruff check . && uv run ruff format --check .
+```
+
+Integration tests start a real worker and need a broker:
+
+```bash
+CELERY_BROKER_URL=redis://localhost:6379/0 uv run pytest tests/integration -m integration
+```
+
+CI runs them against Redis and RabbitMQ on every push.
+
+## License
+
+MIT

mcp_server_celery-0.1.0/README.md

@@ -0,0 +1,134 @@
+# mcp-server-celery
+
+<!-- mcp-name: io.github.taltal-beep/mcp-server-celery -->
+
+[![CI](https://github.com/taltal-beep/mcp-server-celery/actions/workflows/ci.yml/badge.svg)](https://github.com/taltal-beep/mcp-server-celery/actions/workflows/ci.yml)
+
+An MCP server that lets AI agents debug a running Celery deployment. It checks which workers are alive, what each one consumes, and where messages are piling up — the checks you'd otherwise run by hand with `celery inspect` and `rabbitmqctl` every time something gets stuck.
+
+It is **read-only by default**. Broker passwords are masked in every response, including the broker info that Celery's own `inspect stats` sends back in plain text.
+
+Works with RabbitMQ (`amqp://`) and Redis (`redis://`, `rediss://`).
+
+## Tools
+
+| Tool | What it answers |
+| --- | --- |
+| `list_workers` | Which workers respond, their pool and concurrency, uptime, prefetch count, tasks processed, and the queues each one listens to. |
+| `queue_depths` | How many messages are waiting in each queue and which workers consume it. With no arguments it checks your configured queues plus every queue a live worker consumes. |
+
+Coming next: `active_tasks`, `reserved_tasks`, `scheduled_tasks`, `task_status`, and `diagnose_stuck`, which cross-references the above to flag queues no worker listens to, tasks routed to queues with no consumer, and workers that stopped responding. See the [roadmap](#roadmap).
+
+## Install
+
+Requires Python 3.10+ and [uv](https://docs.astral.sh/uv/).
+
+```bash
+uvx mcp-server-celery
+```
+
+Until the first PyPI release, run it from GitHub:
+
+```bash
+uvx --from git+https://github.com/taltal-beep/mcp-server-celery mcp-server-celery
+```
+
+## Configuration
+
+All configuration is through environment variables.
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `CELERY_BROKER_URL` | `amqp://guest:guest@localhost:5672//` | Broker to inspect. |
+| `CELERY_RESULT_BACKEND` | — | Result backend (used by `task_status`, coming in the next release). |
+| `CELERY_APP` | — | Import path of your app, e.g. `proj.celery:app`. Lets the server see your `task_queues` and routes. `CELERY_BROKER_URL` still overrides the app's broker if both are set. |
+| `CELERY_INSPECT_TIMEOUT` | `1.0` | Seconds to wait for worker replies. Raise it for large or slow clusters. |
+
+`CELERY_APP` has to be importable, so run the server from your project's directory and environment:
+
+```bash
+uv run --with mcp-server-celery mcp-server-celery
+```
+
+## Connect it
+
+### Claude Code
+
+```bash
+claude mcp add celery -e CELERY_BROKER_URL=redis://localhost:6379/0 -- uvx mcp-server-celery
+```
+
+### Cursor
+
+In `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "celery": {
+      "command": "uvx",
+      "args": ["mcp-server-celery"],
+      "env": { "CELERY_BROKER_URL": "redis://localhost:6379/0" }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+In `claude_desktop_config.json`, use the same `command`, `args` and `env` block as Cursor, under `mcpServers`.
+
+## Example
+
+Ask the agent "why are my email tasks not running?" and it can call `queue_depths`:
+
+```json
+{
+  "broker": "amqp://app:****@rabbit:5672//",
+  "queues": [
+    { "queue": "celery", "exists": true, "messages": 0, "consumers": 2, "workers_consuming": ["w1@web", "w2@web"] },
+    { "queue": "emails", "exists": true, "messages": 1843, "consumers": 0, "workers_consuming": [] }
+  ]
+}
+```
+
+`emails` has a backlog and no worker consumes it: the workers were started without `-Q emails`.
+
+## Notes on the data
+
+- **Redis** has no notion of consumers, so `consumers` is `null`; use `workers_consuming`, which comes from the workers themselves. Redis also deletes a queue's key once it is empty, so a drained queue shows `"messages": 0, "exists": null`.
+- **RabbitMQ** checks use a passive declare, so the server never creates a queue. A queue that doesn't exist shows `"exists": false`.
+- Workers that are too busy to answer within `CELERY_INSPECT_TIMEOUT` don't appear in `list_workers`. If a worker you expect is missing, try a larger `timeout` argument before assuming it's dead.
+
+## Safety
+
+- Every tool is annotated `readOnlyHint: true`. Write actions (revoke, retry, purge) will only be available behind an explicit opt-in flag.
+- URL credentials and `password`/`secret`/`token` fields are masked in all output and error messages.
+
+## Roadmap
+
+**v0.1** — `list_workers`, `queue_depths` ✅
+
+**v1** — `active_tasks`, `reserved_tasks`, `scheduled_tasks`, `task_status(task_id)`, `diagnose_stuck`
+
+**v2** — `summarize_failures`: groups recent failures by task name and exception type. Celery keeps no failure history by default, so this needs an event listener.
+
+## Development
+
+```bash
+uv sync
+uv run pytest tests/unit
+uv run ruff check . && uv run ruff format --check .
+```
+
+Integration tests start a real worker and need a broker:
+
+```bash
+CELERY_BROKER_URL=redis://localhost:6379/0 uv run pytest tests/integration -m integration
+```
+
+CI runs them against Redis and RabbitMQ on every push.
+
+## License
+
+MIT

mcp_server_celery-0.1.0/pyproject.toml

@@ -0,0 +1,73 @@
+[project]
+name = "mcp-server-celery"
+version = "0.1.0"
+description = "Read-only MCP server for debugging Celery: workers, queue depths, and stuck tasks."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+keywords = [
+    "mcp",
+    "celery",
+    "model-context-protocol",
+    "debugging",
+    "rabbitmq",
+    "redis",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Celery",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Monitoring",
+]
+dependencies = [
+    "celery>=5.3",
+    "fastmcp>=4.1",
+    "mcp>=2.3",
+    "redis>=5.0",
+]
+
+[[project.authors]]
+name = "Ariel Even"
+
+[project.urls]
+Repository = "https://github.com/taltal-beep/mcp-server-celery"
+Issues = "https://github.com/taltal-beep/mcp-server-celery/issues"
+
+[project.scripts]
+mcp-server-celery = "mcp_server_celery.server:main"
+
+[build-system]
+requires = ["uv_build>=0.8,<0.14"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "ruff>=0.15",
+]
+
+[tool.pytest.ini_options]
+markers = ["integration: needs a live broker (set CELERY_BROKER_URL)"]
+filterwarnings = ["error"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+    "B",
+    "UP",
+    "S",
+    "BLE",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = [
+    "S101",
+    "S603",
+]

mcp_server_celery-0.1.0/pyproject.toml.orig

@@ -0,0 +1,53 @@
+[project]
+name = "mcp-server-celery"
+version = "0.1.0"
+description = "Read-only MCP server for debugging Celery: workers, queue depths, and stuck tasks."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Ariel Even" }]
+requires-python = ">=3.10"
+keywords = ["mcp", "celery", "model-context-protocol", "debugging", "rabbitmq", "redis"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Celery",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Monitoring",
+]
+dependencies = [
+    "celery>=5.3",
+    "fastmcp>=4.1",
+    "mcp>=2.3",
+    "redis>=5.0",
+]
+
+[project.urls]
+Repository = "https://github.com/taltal-beep/mcp-server-celery"
+Issues = "https://github.com/taltal-beep/mcp-server-celery/issues"
+
+[project.scripts]
+mcp-server-celery = "mcp_server_celery.server:main"
+
+[build-system]
+requires = ["uv_build>=0.8,<0.14"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "ruff>=0.15",
+]
+
+[tool.pytest.ini_options]
+markers = ["integration: needs a live broker (set CELERY_BROKER_URL)"]
+filterwarnings = ["error"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "S", "BLE"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["S101", "S603"]

mcp_server_celery-0.1.0/src/mcp_server_celery/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("mcp-server-celery")

mcp_server_celery-0.1.0/src/mcp_server_celery/__main__.py

@@ -0,0 +1,3 @@
+from mcp_server_celery.server import main
+
+main()

mcp_server_celery-0.1.0/src/mcp_server_celery/client.py

@@ -0,0 +1,80 @@
+import os
+import sys
+from contextlib import suppress
+from typing import Any, Protocol
+
+from celery import Celery
+from celery.utils.imports import symbol_by_name
+from kombu.exceptions import ChannelError
+
+from mcp_server_celery.config import DEFAULT_BROKER_URL, Settings
+
+
+class Inspector(Protocol):
+    def ping(self) -> dict[str, Any] | None: ...
+    def stats(self) -> dict[str, Any] | None: ...
+    def active_queues(self) -> dict[str, list[dict[str, Any]]] | None: ...
+
+
+class CeleryClient:
+    def __init__(self, app: Celery, inspect_timeout: float = 1.0):
+        self.app = app
+        self.inspect_timeout = inspect_timeout
+
+    @classmethod
+    def from_settings(cls, settings: Settings) -> "CeleryClient":
+        if settings.app_path:
+            if os.getcwd() not in sys.path:
+                sys.path.insert(0, os.getcwd())  # match `celery -A`, which imports from cwd
+            app = symbol_by_name(settings.app_path)
+            if settings.broker_url:
+                app.conf.broker_url = settings.broker_url
+            if settings.result_backend:
+                app.conf.result_backend = settings.result_backend
+        else:
+            app = Celery(
+                "mcp-server-celery",
+                broker=settings.broker_url or DEFAULT_BROKER_URL,
+                backend=settings.result_backend,
+            )
+        return cls(app, settings.inspect_timeout)
+
+    def inspect(self, timeout: float | None = None, destination: list[str] | None = None) -> Inspector:
+        return self.app.control.inspect(timeout=timeout or self.inspect_timeout, destination=destination)
+
+    def configured_queues(self) -> list[str]:
+        queues = self.app.conf.task_queues or []
+        names = [q.name for q in queues]
+        default = self.app.conf.task_default_queue
+        return names if default in names else [default, *names]
+
+    def queue_depths(self, names: list[str]) -> list[dict[str, Any]]:
+        with self.app.connection_for_read() as conn:
+            conn.ensure_connection(max_retries=1)
+            is_amqp = conn.transport.driver_type == "amqp"
+            return [self._probe(conn, name, is_amqp) for name in names]
+
+    @staticmethod
+    def _probe(conn, name: str, is_amqp: bool) -> dict[str, Any]:
+        channel = conn.channel()
+        try:
+            _, messages, consumers = channel.queue_declare(queue=name, passive=True)
+        except ChannelError:
+            if is_amqp:
+                return {
+                    "queue": name,
+                    "exists": False,
+                    "messages": None,
+                    "consumers": None,
+                }
+            # Virtual transports drop the key once a queue is drained.
+            return {"queue": name, "exists": None, "messages": 0, "consumers": None}
+        finally:
+            with suppress(ChannelError, OSError):
+                channel.close()
+        return {
+            "queue": name,
+            "exists": True,
+            "messages": messages,
+            "consumers": consumers if is_amqp else None,
+        }

mcp_server_celery-0.1.0/src/mcp_server_celery/config.py

@@ -0,0 +1,22 @@
+import os
+from dataclasses import dataclass
+
+DEFAULT_BROKER_URL = "amqp://guest:guest@localhost:5672//"
+
+
+@dataclass(frozen=True)
+class Settings:
+    broker_url: str | None = None
+    result_backend: str | None = None
+    app_path: str | None = None
+    inspect_timeout: float = 1.0
+
+    @classmethod
+    def from_env(cls, env: dict[str, str] | None = None) -> "Settings":
+        env = os.environ if env is None else env
+        return cls(
+            broker_url=env.get("CELERY_BROKER_URL") or None,
+            result_backend=env.get("CELERY_RESULT_BACKEND") or None,
+            app_path=env.get("CELERY_APP") or None,
+            inspect_timeout=float(env.get("CELERY_INSPECT_TIMEOUT", "1.0")),
+        )

mcp_server_celery-0.1.0/src/mcp_server_celery/redact.py

@@ -0,0 +1,22 @@
+import re
+from typing import Any
+
+SECRET_KEYS = frozenset({"password", "passwd", "secret", "token", "api_key", "apikey"})
+MASK = "****"
+_URL_CREDENTIALS = re.compile(r"(?P<scheme>[a-zA-Z][a-zA-Z0-9+.-]*://)(?P<user>[^:@/\s]*):(?P<password>[^@/\s]+)@")
+
+
+def mask_url(url: str) -> str:
+    return _URL_CREDENTIALS.sub(lambda m: f"{m['scheme']}{m['user']}:{MASK}@", url)
+
+
+def redact(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {
+            k: (MASK if isinstance(k, str) and k.lower() in SECRET_KEYS and v else redact(v)) for k, v in value.items()
+        }
+    if isinstance(value, (list, tuple)):
+        return [redact(v) for v in value]
+    if isinstance(value, str):
+        return mask_url(value)
+    return value

mcp_server_celery-0.1.0/src/mcp_server_celery/server.py

@@ -0,0 +1,72 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Annotated, Any
+
+from fastmcp import FastMCP
+from fastmcp.exceptions import ToolError
+from kombu.exceptions import OperationalError
+from mcp.types import ToolAnnotations
+from pydantic import Field
+
+from mcp_server_celery import tools
+from mcp_server_celery.client import CeleryClient
+from mcp_server_celery.config import Settings
+from mcp_server_celery.redact import mask_url
+
+READ_ONLY = ToolAnnotations(read_only_hint=True, destructive_hint=False, open_world_hint=True)
+
+Timeout = Annotated[
+    float | None,
+    Field(description="Seconds to wait for worker replies. Defaults to CELERY_INSPECT_TIMEOUT."),
+]
+
+
+def _broker_errors(client: CeleryClient, fn: Callable[..., Any]) -> Callable[..., Any]:
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except (OperationalError, ConnectionError, OSError) as exc:
+            broker = mask_url(client.app.conf.broker_url or "")
+            raise ToolError(f"Cannot reach broker {broker}: {mask_url(str(exc))}") from exc
+
+    return wrapper
+
+
+def build_server(client: CeleryClient) -> FastMCP:
+    mcp = FastMCP(
+        "celery",
+        instructions=(
+            "Read-only diagnostics for a Celery deployment: workers, queues and tasks. "
+            "Broker credentials are always masked."
+        ),
+    )
+
+    def _wrap(fn):
+        return _broker_errors(client, fn)
+
+    @mcp.tool(annotations=READ_ONLY)
+    @_wrap
+    def list_workers(timeout: Timeout = None) -> dict:
+        """List workers that reply to broadcast, with pool, concurrency, uptime and the queues each consumes."""
+        return tools.list_workers(client, timeout=timeout)
+
+    @mcp.tool(annotations=READ_ONLY)
+    @_wrap
+    def queue_depths(
+        queues: Annotated[
+            list[str] | None,
+            Field(
+                description="Queue names to check. Defaults to configured queues plus every queue a worker consumes."
+            ),
+        ] = None,
+        timeout: Timeout = None,
+    ) -> dict:
+        """Count waiting messages per queue and show which workers consume each one. Works on RabbitMQ and Redis."""
+        return tools.queue_depths(client, queues=queues, timeout=timeout)
+
+    return mcp
+
+
+def main() -> None:
+    build_server(CeleryClient.from_settings(Settings.from_env())).run()

mcp_server_celery-0.1.0/src/mcp_server_celery/tools.py

@@ -0,0 +1,44 @@
+from typing import Any
+
+from mcp_server_celery.client import CeleryClient
+from mcp_server_celery.redact import redact
+
+
+def list_workers(client: CeleryClient, timeout: float | None = None) -> dict[str, Any]:
+    inspector = client.inspect(timeout=timeout)
+    pings = inspector.ping() or {}
+    stats = inspector.stats() or {}
+    queues = inspector.active_queues() or {}
+
+    workers = []
+    for hostname in sorted(set(pings) | set(stats) | set(queues)):
+        worker_stats = stats.get(hostname, {})
+        pool = worker_stats.get("pool") or {}
+        workers.append(
+            {
+                "hostname": hostname,
+                "responded_to_ping": hostname in pings,
+                "pid": worker_stats.get("pid"),
+                "uptime_seconds": worker_stats.get("uptime"),
+                "pool": pool.get("implementation"),
+                "concurrency": pool.get("max-concurrency"),
+                "prefetch_count": worker_stats.get("prefetch_count"),
+                "tasks_processed": worker_stats.get("total", {}),
+                "queues": sorted(q["name"] for q in queues.get(hostname, [])),
+            }
+        )
+    return redact({"worker_count": len(workers), "workers": workers})
+
+
+def queue_depths(client: CeleryClient, queues: list[str] | None = None, timeout: float | None = None) -> dict[str, Any]:
+    consumed_by: dict[str, list[str]] = {}
+    for hostname, worker_queues in (client.inspect(timeout=timeout).active_queues() or {}).items():
+        for q in worker_queues:
+            consumed_by.setdefault(q["name"], []).append(hostname)
+
+    names = queues or sorted(set(client.configured_queues()) | set(consumed_by))
+    results = []
+    for depth in client.queue_depths(names):
+        listeners = sorted(consumed_by.get(depth["queue"], []))
+        results.append({**depth, "workers_consuming": listeners})
+    return redact({"broker": client.app.conf.broker_url, "queues": results})