Enables management of BullMQ job queues hosted on Redis, allowing for queue monitoring, job lifecycle control, and log retrieval across multiple Redis instances.
Click on "Install 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., "@BullMQ MCP Server show me the status and recent failed jobs in the email-notifications queue"
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.
A comprehensive BullMQ MCP (Model Context Protocol) server for managing BullMQ Redis-based job queues. This BullMQ MCP integration enables Claude Desktop and other AI assistants to interact with BullMQ queues, monitor job status, manage workers, and perform queue operations through natural language.
Keywords: BullMQ MCP, BullMQ Model Context Protocol, BullMQ Claude integration, BullMQ AI assistant, BullMQ queue management, Redis queue MCP
🔌 Connection Management: Connect to multiple Redis instances and switch between them
📊 Queue Operations: List, pause, resume, drain, and clean queues
⚙️ Job Management: Add, remove, retry, and promote jobs
📈 Job Monitoring: View job details, logs, and statistics
🧹 Bulk Operations: Clean jobs by status with configurable limits
🔄 Multiple Connections: Manage different Redis instances (development, staging, production)
📝 Job Logs: Add and view custom log entries for jobs
🎯 Flexible Status Filtering: Query jobs by various states (active, waiting, completed, failed, delayed)
Related MCP server: Jenkins MCP Server
To install BullMQ Queue Management Server for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @adamhancock/bullmq-mcp --client claudenpm install -g @adamhancock/bullmq-mcpOr with pnpm:
pnpm install -g @adamhancock/bullmq-mcpOr with yarn:
yarn global add @adamhancock/bullmq-mcpPull the Docker image from GitHub Container Registry:
docker pull ghcr.io/adamhancock/bullmq-mcp:latestOr use a specific version:
docker pull ghcr.io/adamhancock/bullmq-mcp:v1.0.0If you have the Claude CLI installed, you can add the BullMQ server with a single command:
Using npm package:
claude mcp add --scope user bullmq -- npx -y @adamhancock/bullmq-mcpUsing Docker:
claude mcp add-json bullmq --scope user '{"command": "docker", "args": ["run", "-i", "--rm", "-e", "REDIS_URL=redis://host.docker.internal:6379", "ghcr.io/adamhancock/bullmq-mcp:latest"], "scope": "user"}'With Redis URL environment variable:
# NPM version
claude mcp add --scope user bullmq -e REDIS_URL=redis://localhost:6379 -- npx -y @adamhancock/bullmq-mcp
# Docker version with environment variable
claude mcp add-json bullmq --scope user '{"command": "docker", "args": ["run", "-i", "--rm", "-e", "REDIS_URL=redis://host.docker.internal:6379", "ghcr.io/adamhancock/bullmq-mcp:latest"], "scope": "user"}'Note: When using Docker with claude mcp add, use host.docker.internal instead of localhost to connect to Redis running on your host machine.
To manually configure Claude Desktop, add the following to your Claude configuration file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
{
"mcpServers": {
"bullmq": {
"command": "npx",
"args": ["-y", "@adamhancock/bullmq-mcp"]
}
}
}With Redis URL:
{
"mcpServers": {
"bullmq": {
"command": "npx",
"args": ["-y", "@adamhancock/bullmq-mcp"],
"env": {
"REDIS_URL": "redis://localhost:6379"
}
}
}
}Alternative configurations:
Using global installation:
{
"mcpServers": {
"bullmq": {
"command": "bullmq-mcp"
}
}
}Using local installation:
{
"mcpServers": {
"bullmq": {
"command": "node",
"args": ["/path/to/bullmq-mcp/dist/index.js"]
}
}
}Using Docker:
{
"mcpServers": {
"bullmq": {
"command": "docker",
"args": ["run", "--rm", "-i", "ghcr.io/adamhancock/bullmq-mcp:latest"],
"env": {
"REDIS_URL": "redis://host.docker.internal:6379"
}
}
}
}Note: When using Docker, use host.docker.internal instead of localhost to connect to Redis running on your host machine.
connect - Connect to a Redis instance
{
id: string, // Connection identifier
url?: string, // Redis URL (e.g., redis://user:pass@localhost:6379/0)
host?: string, // Redis host (default: localhost) - ignored if url is provided
port?: number, // Redis port (default: 6379) - ignored if url is provided
password?: string, // Redis password (optional) - ignored if url is provided
db?: number // Redis database number (default: 0) - ignored if url is provided
}The tool will use the Redis URL in this order of preference:
url parameter if provided
REDIS_URL environment variable if set
Individual connection parameters (host, port, password, db)
Docker Auto-redirect: When running in a Docker container (detected via DOCKER env variable or DOCKER_HOST),
localhost will automatically redirect to host.docker.internal to connect to Redis on the host machine.
disconnect - Disconnect from current Redis instance
list_connections - List all saved connections
switch_connection - Switch to a different connection
{
id: string // Connection identifier to switch to
}list_queues - List all queues in the current connection
{
pattern?: string // Queue name pattern (supports wildcards, default: "*")
}stats - Get queue statistics
{
queue: string // Queue name
}pause_queue - Pause queue processing
{
queue: string // Queue name
}resume_queue - Resume queue processing
{
queue: string // Queue name
}drain_queue - Remove all jobs from a queue
{
queue: string // Queue name
}clean_queue - Clean jobs from queue
{
queue: string, // Queue name
grace?: number, // Grace period in milliseconds (default: 0)
limit?: number, // Maximum number of jobs to clean (default: 1000)
status?: "completed" | "failed" // Job status to clean (default: "completed")
}get_jobs - Get jobs from queue by status
{
queue: string, // Queue name
status: "active" | "waiting" | "completed" | "failed" | "delayed" | "paused" | "repeat" | "wait",
start?: number, // Start index (default: 0)
end?: number // End index (default: 10)
}get_job - Get a specific job by ID
{
queue: string, // Queue name
jobId: string // Job ID
}add_job - Add a new job to the queue
{
queue: string, // Queue name
name: string, // Job name
data: object, // Job data (JSON object)
opts?: { // Job options
delay?: number, // Delay in milliseconds
priority?: number, // Job priority
attempts?: number, // Number of attempts
backoff?: object, // Backoff configuration
removeOnComplete?: boolean, // Remove job when completed
removeOnFail?: boolean // Remove job when failed
}
}remove_job - Remove a job from the queue
{
queue: string, // Queue name
jobId: string // Job ID
}retry_job - Retry a failed job
{
queue: string, // Queue name
jobId: string // Job ID
}promote_job - Promote a delayed job
{
queue: string, // Queue name
jobId: string // Job ID
}get_job_logs - Get logs for a job
{
queue: string, // Queue name
jobId: string // Job ID
}add_job_log - Add a log entry to a job
{
queue: string, // Queue name
jobId: string, // Job ID
message: string // Log message
}// Connect using Redis URL
await use_mcp_tool("bullmq", "connect", {
id: "local",
url: "redis://localhost:6379"
});
// Or connect using individual parameters
await use_mcp_tool("bullmq", "connect", {
id: "local",
host: "localhost",
port: 6379,
password: "mypassword",
db: 0
});
// Or connect using REDIS_URL environment variable
// (no url parameter needed if REDIS_URL is set)
await use_mcp_tool("bullmq", "connect", {
id: "local"
});
// List all queues
await use_mcp_tool("bullmq", "list_queues", {});// Add a job with delay
await use_mcp_tool("bullmq", "add_job", {
queue: "email-queue",
name: "send-welcome-email",
data: {
to: "user@example.com",
subject: "Welcome!",
template: "welcome"
},
opts: {
delay: 5000, // Process after 5 seconds
priority: 1, // Higher priority (lower number = higher priority)
attempts: 3, // Retry up to 3 times
backoff: {
type: "exponential",
delay: 2000
}
}
});
// Get job status
await use_mcp_tool("bullmq", "get_job", {
queue: "email-queue",
jobId: "1"
});
// Add a custom log entry
await use_mcp_tool("bullmq", "add_job_log", {
queue: "email-queue",
jobId: "1",
message: "Email template rendered successfully"
});
// View job logs
await use_mcp_tool("bullmq", "get_job_logs", {
queue: "email-queue",
jobId: "1"
});// Get queue statistics
await use_mcp_tool("bullmq", "stats", {
queue: "email-queue"
});
// Returns: active, waiting, completed, failed, delayed, paused counts
// Get failed jobs with details
await use_mcp_tool("bullmq", "get_jobs", {
queue: "email-queue",
status: "failed",
start: 0,
end: 20
});
// Retry a specific failed job
await use_mcp_tool("bullmq", "retry_job", {
queue: "email-queue",
jobId: "123"
});
// Clean completed jobs older than 1 hour
await use_mcp_tool("bullmq", "clean_queue", {
queue: "email-queue",
grace: 3600000, // 1 hour in milliseconds
status: "completed",
limit: 100 // Clean max 100 jobs
});
// Pause processing
await use_mcp_tool("bullmq", "pause_queue", {
queue: "email-queue"
});
// Resume processing
await use_mcp_tool("bullmq", "resume_queue", {
queue: "email-queue"
});
// Completely drain a queue (remove ALL jobs)
await use_mcp_tool("bullmq", "drain_queue", {
queue: "test-queue"
});// Add a repeating job
await use_mcp_tool("bullmq", "add_job", {
queue: "metrics-queue",
name: "collect-metrics",
data: { source: "api" },
opts: {
repeat: {
pattern: "*/5 * * * *" // Every 5 minutes (cron syntax)
}
}
});
// Promote a delayed job to be processed immediately
await use_mcp_tool("bullmq", "promote_job", {
queue: "notification-queue",
jobId: "456"
});
// Get jobs by different statuses
const statuses = ["active", "waiting", "completed", "failed", "delayed"];
for (const status of statuses) {
await use_mcp_tool("bullmq", "get_jobs", {
queue: "worker-queue",
status: status,
start: 0,
end: 5
});
}Redis Server: Ensure Redis is running locally or accessible remotely
# Check if Redis is running
redis-cli ping
# Should return: PONGClaude Desktop: Install and configure Claude Desktop with the BullMQ MCP server
Connect to Redis
Connect to Redis using the bullmq tool with id "local"Explore Queues
List all queues and show me their statisticsMonitor Jobs
Show me failed jobs in the email-queueManage Jobs
Add a test job to my-queue with some sample dataWhen using the Docker version:
Redis Connection: The server automatically redirects localhost to host.docker.internal when running in Docker, so you can use either:
redis://localhost:6379 (will auto-redirect)
redis://host.docker.internal:6379 (explicit Docker host)
Connection Timeout: Connections have a 10-second timeout to prevent hanging on unreachable hosts
Environment Variables: Set REDIS_URL=redis://localhost:6379 - it will auto-redirect in Docker
Network Access: The Docker container needs network access to reach your Redis instance
Persistence: The container is ephemeral - all data is stored in Redis, not the container
Check the health of all my queues - show me which ones have failed or stuck jobsShow me the failed jobs in the payment-queue and their error messagesRetry all failed jobs in the notification-queueClean up completed jobs older than 24 hours from all queues// Connect to different Redis instances
await use_mcp_tool("bullmq", "connect", {
id: "production",
url: "redis://prod-redis.example.com:6379"
});
await use_mcp_tool("bullmq", "connect", {
id: "staging",
url: "redis://staging-redis.example.com:6379"
});
// Switch between connections
await use_mcp_tool("bullmq", "switch_connection", {
id: "production"
});After configuring Claude Desktop, restart Claude and test the connection:
Open Claude Desktop
Start a new conversation
Test the MCP connection:
Can you connect to my local Redis using the bullmq tool? Use connection id "local" with default settings.If successful, you should see a confirmation message. You can then:
List all available queues
Check queue statistics
View job details
Perform queue operations
# Install dependencies
pnpm install
# Run in development mode
pnpm dev
# Build for production
pnpm build
# Run built version
pnpm start
# Create global link
pnpm link --globalRedis not running: Ensure Redis is running on the specified host and port
# Start Redis (macOS with Homebrew)
brew services start redis
# Start Redis (Linux)
sudo systemctl start redis
# Test connection
redis-cli pingAuthentication failed: Check that the Redis password (if any) is correct
# Test with password
redis-cli -a yourpassword pingWrong database: Ensure you're connecting to the correct Redis database number
"No active connection": Use the connect tool first before other operations
First connect to Redis with: connect to Redis using bullmq with id "local""Job not found": Ensure the job ID exists in the specified queue
List jobs in the queue first to see available job IDs"Queue not found": The queue may not exist or have any jobs yet
List all queues to see what's availableConnection timeout: Check firewall settings and Redis bind address
# Check Redis config
grep "^bind" /etc/redis/redis.confServer not starting: Check Claude Desktop configuration file syntax
Tools not available: Restart Claude Desktop after configuration changes
Permission denied: Ensure the MCP server has execute permissions
Enable verbose logging in Claude Desktop:
Run Claude from terminal to see logs
macOS: /Applications/Claude.app/Contents/MacOS/Claude
Windows: Run Claude from Command Prompt
Linux: Run from terminal
Test the MCP server directly:
# Run the server manually to check for errors
npx @adamhancock/bullmq-mcpCheck Redis connection:
# Test Redis connectivity
redis-cli -h localhost -p 6379 ping
# Check Redis info
redis-cli info clientsVerify environment variables:
# Check if REDIS_URL is set
echo $REDIS_URLNode.js 18+
Redis server
BullMQ-compatible Redis setup
The BullMQ MCP server bridges the gap between AI assistants and BullMQ job queue management. With this MCP integration, you can:
Natural Language Queue Management: Use conversational commands to manage BullMQ queues
AI-Powered Debugging: Let Claude analyze failed jobs and suggest solutions
Automated Queue Monitoring: Set up intelligent alerts and monitoring through AI
Cross-Environment Management: Seamlessly switch between development, staging, and production queues
Feature | BullMQ MCP | Traditional CLI/GUI |
Natural language commands | ✅ Yes | ❌ No |
AI-assisted debugging | ✅ Yes | ❌ No |
Batch operations | ✅ Yes | ⚠️ Limited |
Learning curve | ✅ Minimal | ⚠️ Moderate |
Integration with AI tools | ✅ Native | ❌ None |
BullMQ - The powerful Node.js job queue
Model Context Protocol - The protocol enabling AI-tool integration
Claude Desktop - AI assistant with MCP support
Contributions to the BullMQ MCP server are welcome! Please feel free to submit issues or pull requests to improve this integration.
For issues related to:
BullMQ MCP Server: GitHub Issues
BullMQ: BullMQ Documentation
MCP Protocol: MCP Documentation
MIT
Search Terms: BullMQ MCP, BullMQ Model Context Protocol, BullMQ Claude, BullMQ AI integration, BullMQ queue management MCP, Redis queue MCP, BullMQ automation, BullMQ natural language, BullMQ Claude Desktop, MCP server for BullMQ
Add a new job to the queue
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | Job data (JSON object) | |
| name | Yes | Job name | |
| opts | No | Job options | |
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior. It only states the action without detailing side effects (e.g., job processing initiation), error cases, or required permissions.
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 concise (one sentence) but could be more helpful without becoming verbose. It front-loads the purpose but lacks supporting details.
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 having 4 parameters with a nested options object and no output schema, the description provides no context on return values, error handling, or job lifecycle. It is incomplete for the tool's complexity.
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 parameters are documented in the input schema. The description adds no extra meaning beyond the schema, which is adequate but not improved.
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 'Add a new job to the queue' clearly states the verb (add) and resource (job to queue). It distinguishes the tool from siblings like remove_job or get_job, but does not explicitly differentiate from other job-adding tools if any exist.
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 on when to use this tool, when not to, or alternatives. It does not mention prerequisites like queue existence or constraints on job names/data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Add a log entry to a job
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes | Job ID | |
| queue | Yes | Queue name | |
| message | Yes | Log message |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description does not disclose behavioral traits beyond the action 'add'. No annotations provided, so it carries the full burden. It does not mention idempotency, side effects, or permissions.
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 wasted words. Efficient but could be more informative. Front-loaded with the action.
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 tool with complete schema descriptions, but lacks details on return value or effect, 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 has 100% description coverage, so the base is 3. The description adds no extra meaning beyond the parameter names and descriptions 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 'Add a log entry to a job' uses a specific verb and resource, clearly distinguishing it from siblings like 'get_job_logs' (retrieval) and 'add_job' (adding a job).
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 on when to use this tool versus alternatives (e.g., when would you use get_job_logs? No mention of prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Clean jobs from queue
| Name | Required | Description | Default |
|---|---|---|---|
| grace | No | Grace period in milliseconds | |
| limit | No | Maximum number of jobs to clean | |
| queue | Yes | Queue name | |
| status | No | Job status to clean | completed |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must fully disclose behavior. It only says 'Clean jobs from queue' without mentioning that it likely deletes jobs, the effect of parameters like grace and limit, or that the operation may be irreversible. The agent cannot infer safety or side effects.
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 extremely concise (4 words) but lacks structure and substance. It is not a complete sentence that provides context; it is just a phrase. While brevity is good, this is under-specification, not effective conciseness.
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 4 parameters, one required, and a list of many sibling tools, the description is critically incomplete. It does not explain the cleaning semantics, the effect of parameters like grace and limit, or what return value to expect. No output schema exists, so the description should compensate but fails.
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 each parameter described in the schema. The description adds no additional meaning beyond what is already in the schema. Baseline score 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 'Clean jobs from queue' uses a vague verb 'clean' that could mean remove, purge, or archive. It identifies the resource (queue) but does not specify the precise action. Compared to sibling tools like drain_queue or remove_job, the purpose is somewhat clear but lacks specificity.
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 on when to use this tool versus alternatives. For example, when one should use clean_queue instead of drain_queue or remove_job is not mentioned, leaving the agent with no contextual decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Connect to Redis instance. Can use REDIS_URL environment variable if set. When running in Docker, localhost will automatically redirect to host.docker.internal.
| Name | Required | Description | Default |
|---|---|---|---|
| db | No | Redis database number (ignored if url is provided) | |
| id | Yes | Connection identifier | |
| url | No | Redis URL (e.g., redis://user:pass@localhost:6379/0). If not provided, will use REDIS_URL env var or individual connection parameters. | |
| host | No | Redis host (ignored if url is provided) | localhost |
| port | No | Redis port (ignored if url is provided) | |
| password | No | Redis password (ignored if url is provided) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must disclose all behavioral traits. It mentions automatic Docker redirection and env var usage, but fails to discuss side effects, error handling, or whether the connection is persistent. This is insufficient for a tool that establishes external connections.
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, front-loaded with the main action, and every sentence adds necessary context (env var, Docker). No redundant or irrelevant 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?
Given 6 parameters and no output schema, the description is too brief. It does not explain what the return value is, how to use the connection after connecting, or what happens on failure. The tool's role in the broader context (e.g., needed for other operations) is implied but not stated.
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 baseline is 3. The description does not add extra meaning beyond the schema; it only mentions the 'id' parameter implicitly. No additional parameter semantics are 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 clearly states 'Connect to Redis instance' and provides additional context about env var and Docker behavior. It distinguishes itself from sibling tools like 'disconnect' and 'list_connections'.
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 gives no explicit guidance on when to use this tool versus others (e.g., disconnecting or listing connections). It implies usage as a first step but lacks 'when-to-use' or 'when-not-to-use' instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Disconnect from current Redis instance
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden. It only states 'disconnect' but does not disclose key behavioral traits: whether disconnection is graceful, what happens to in-flight operations, if it requires specific permissions, or the resulting state of the connection.
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 that front-loads the action and resource with no unnecessary words. Every part earns its place.
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?
While the tool is simple with no parameters or output schema, the description lacks mention of return values, success confirmation, error handling, or side effects. It is minimally viable but leaves the agent guessing about the outcome of the call.
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 tool has no parameters, so schema coverage is 100%. The description appropriately adds no further parameter details since none exist. Baseline 4 for zero parameters is justified.
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 'Disconnect from current Redis instance' clearly states the specific action (disconnect) and the resource (current Redis instance). This immediately distinguishes it from sibling tools like 'connect' or 'list_connections'.
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 'switch_connection' or 'connect'. The description does not specify prerequisites or conditions for disconnection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Remove all jobs from a queue
| Name | Required | Description | Default |
|---|---|---|---|
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description fails to disclose side effects, reversibility, or blocking behavior for this destructive operation.
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 with no wasted words, conveying the core function efficiently.
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 destructive nature and lack of output schema, the description does not explain return values, prerequisites, or post-condition, leaving agents underinformed.
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 description adds no extra meaning beyond the schema's 'Queue name'; baseline score 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?
Description explicitly states 'Remove all jobs from a queue', which clearly identifies the action and resource, distinguishing it from siblings like remove_job that target single jobs.
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 drain_queue versus alternatives like clean_queue or remove_job; usage is implied but not clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a specific job by ID
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes | Job ID | |
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description does not disclose any behavioral traits such as read-only nature, error handling, or required permissions. The minimal description adds no behavioral context beyond the tool's name.
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 key action 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?
Given the complexity (many sibling tools, no output schema), the description lacks context on what a job is or what the return value contains. It is minimally sufficient but not complete for an agent to use effectively.
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 descriptions cover both parameters (jobId, queue) adequately. Description does not add any new information beyond the schema, but coverage is 100%, 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?
Description clearly states verb 'Get' and resource 'specific job by ID'. However, it does not differentiate from sibling tool 'get_jobs', which might confuse about singular vs plural retrieval.
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 on when to use this tool versus alternative sibling tools like retry_job, remove_job, or get_jobs. Agent left to infer from name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get logs for a job
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes | Job ID | |
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full burden for transparency. It discloses no behavioral traits such as log format, pagination, truncation, permissions required, or whether it returns all logs or just recent ones. The minimal description leaves critical usage details unknown.
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 focused sentence with no superfluous words. It is suitably concise, though it could be slightly expanded to improve clarity 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 low complexity (2 params, no output schema) but many sibling tools, the description is incomplete. It does not explain the nature of the logs, expected output format, or any constraints (e.g., retention, filtering). An agent would lack sufficient context to use the tool effectively.
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 descriptions for both parameters ('Job ID', 'Queue name'). The description adds no extra meaning beyond what the schema already provides, 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 'Get logs for a job' clearly states the verb and resource. It implicitly distinguishes from sibling tools like 'get_job' (job details) and 'add_job_log' (adding logs), but does not explicitly contrast them.
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 'get_job' or 'add_job_log'. The description does not mention prerequisites, limitations, or preferred contexts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get jobs from queue by status
| Name | Required | Description | Default |
|---|---|---|---|
| end | No | End index | |
| queue | Yes | Queue name | |
| start | No | Start index | |
| status | Yes | Job status to filter by |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, ordering of results, or pagination behavior. The schema implies pagination via start and end parameters, but the description does not clarify this.
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, succinct sentence that efficiently conveys the core purpose. It is front-loaded with key information. However, it could be structured to include a bit more detail without sacrificing conciseness.
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 has 4 parameters, no output schema, and no annotations, the description is incomplete. It does not explain return format, maximum results, or typical usage patterns. Sibling tools provide context, but the description alone is insufficient.
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 all parameters are described in the schema. The description adds no additional meaning beyond what the schema already provides. Baseline is 3 as per guidelines for high 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 'Get jobs from queue by status' clearly indicates the action (get), resource (jobs), and filter (by status). It distinguishes from siblings like get_job which retrieves a single job, and list_queues which lists queues. However, it lacks details on what exactly is returned (e.g., list or count).
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 on when to use this tool versus alternatives. For example, when to use get_jobs vs get_job or stats is not indicated. The description does not mention prerequisites or context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all saved connections
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose read-only behavior, authentication requirements, return format, or pagination. The single sentence provides minimal transparency beyond the core action.
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 short, front-loaded sentence with no wasted words. Every word earns its place.
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 parameterless tool, the description is adequate but could be more complete by indicating the returned data structure or read-only nature. Without annotations or output schema, it lacks behavioral context.
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 input schema has no parameters, so schema description coverage is 100%. The description adds no extra meaning about parameters, which is acceptable. Baseline for 0 params is 4.
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 'List all saved connections' uses a specific verb 'list' and resource 'saved connections', clearly distinguishing it from siblings like connect, disconnect, and switch_connection.
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 on when to use this tool vs alternatives. Siblings include connect, disconnect, and switch_connection, but the description does not suggest using list_connections before connecting or switching.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all queues in the current connection
| Name | Required | Description | Default |
|---|---|---|---|
| pattern | No | Queue name pattern (supports wildcards) | * |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description does not disclose that the optional 'pattern' parameter exists or that it supports wildcards. It also fails to specify what happens if no connection is established. With no annotations, the description should compensate but does not.
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 sentence of 8 words with no waste. It is front-loaded with the essential action. Every word earns its place.
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 parameter, the description is minimal but misses context about the connection requirement and filtering capability. It is adequate for basic understanding but could be improved.
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%. The tool description adds no additional meaning beyond the schema's parameter description ('Queue name pattern (supports wildcards)'). 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 verb 'List', the resource 'queues', and the scope 'in the current connection'. It is distinguishable from sibling tools (e.g., get_jobs, clean_queue) which operate on different resources.
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 on when to use this tool versus alternatives is provided. It does not mention prerequisites (e.g., an active connection) or exclude cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Move failed jobs to a dead letter queue with TTL. Designed for cleaning up old failed jobs that have been manually resolved.
| Name | Required | Description | Default |
|---|---|---|---|
| queue | Yes | Source queue name | |
| dlqKey | No | Dead letter queue Redis key (outside BullMQ namespace) | dlq:failed_jobs |
| dryRun | No | Preview what would be moved without actually moving | |
| jobName | Yes | Specific job name to filter (e.g., 'upsertHubspotContact') | |
| ttlDays | No | TTL in days for dead letter queue entries | |
| beforeTimestamp | Yes | Unix timestamp in milliseconds - jobs created before this will be moved |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry burden. It mentions moving and TTL but does not disclose whether original jobs are deleted, permissions needed, or side effects. The dry-run parameter exists but is not highlighted in description. Schema covers some behavioral hints but description adds minimal 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?
Two concise sentences: first states action, second states purpose. No unnecessary words. Front-loaded with key 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?
With 6 parameters, no output schema, and no annotations, the description provides basic purpose but lacks details on return values, error states, or system impact. Adequate but leaves gaps for an agent to fully understand the tool's behavior.
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 baseline is 3. Description adds context about TTL and cleanup, aligning with parameters like ttlDays and beforeTimestamp, but does not add significant new meaning 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?
Description clearly states verb 'Move' and resource 'failed jobs to a dead letter queue with TTL', and specifies the intended purpose 'cleaning up old failed jobs that have been manually resolved'. This differentiates from siblings like retry_job or clean_queue.
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?
Description gives explicit context 'cleaning up old failed jobs that have been manually resolved', indicating when to use. However, no explicit alternatives or when-not-to-use are mentioned, though the context implies it is for resolved failures.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Pause queue processing
| Name | Required | Description | Default |
|---|---|---|---|
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must bear the full burden of behavioral disclosure. It only says 'Pause queue processing' without detailing effects on jobs, reversibility, idempotency, or required permissions. This is insufficient for safe tool use.
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 with no extraneous words. While it is concise, it could be more structured with additional context without being verbose. Still, it earns its place.
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 annotations, the description is too brief to fully inform the agent. It lacks explanation of return values, side effects, or safe usage contexts, making it incomplete for a tool that modifies system state.
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 one parameter 'queue' described as 'Queue name'. The description adds no extra meaning beyond the schema, so the baseline score of 3 is appropriate given high 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 'Pause queue processing' clearly states the tool's action (pause) and resource (queue). It is specific enough to differentiate from sibling tools like 'resume_queue' or 'clean_queue', though it does not explicitly mention the distinction.
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 like 'drain_queue' or 'resume_queue'. It does not mention scenarios, prerequisites, or exclusions, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Promote a delayed job
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes | Job ID | |
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fails to disclose any behavioral traits such as whether the action is destructive, idempotent, or requires specific permissions. The single sentence offers no visibility into side effects or state changes.
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 extremely concise (one sentence, no extra words). It is front-loaded with the action and resource. However, it sacrifices informativeness for brevity, which is acceptable for a simple tool but limits its utility.
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 has only two required parameters, no output schema, and no annotations, the description should explain the outcome of promotion (e.g., where the job moves). It fails to complete the mental model for the agent, leaving ambiguity about the tool's effect.
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?
Both parameters are documented in the schema with clear descriptions (Job ID, Queue name), and schema coverage is 100%. However, the description adds no additional meaning or context for how these parameters are used or their constraints.
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 states the action ('Promote') and resource ('a delayed job'), but the term 'promote' is vague and not clearly defined. It could mean moving the job to an active queue or changing its priority, which diminishes clarity. It does distinguish from siblings like 'retry_job' or 'get_job' but lacks specificity.
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 on when to use this tool versus alternatives like 'retry_job' or 'add_job'. The description does not provide context for typical scenarios or prerequisites, leaving the agent without decision criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query jobs in the dead letter queue
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max number of jobs to return | |
| dlqKey | No | Dead letter queue Redis key | dlq:failed_jobs |
| jobName | No | Filter by job name (optional) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It does not disclose whether the operation is read-only, any side effects, pagination behavior, or return format. The agent is left uninformed about what to expect from the tool.
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, which is concise but lacks structure. It does not waste words, but it is too short to convey critical usage details. Important information like parameter purpose or return type is missing, making it insufficiently 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 tool has 3 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the return format, default behavior (e.g., limit=10), or how it relates to sibling tools like move_failed_jobs_to_dlq. The agent lacks context for effective use.
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?
All three parameters (limit, dlqKey, jobName) have descriptions in the input schema (100% coverage). The tool description adds no additional semantic information beyond what the schema already provides, so the baseline score 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 uses 'query jobs in the dead letter queue', which clearly identifies the resource (dead letter queue) and the action (query). It differentiates from siblings like get_jobs (likely main queue) and get_job (single job), though the verb is generic.
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 on when to use this tool vs alternatives such as get_jobs or get_job. It does not state that this is for dead letter jobs specifically (though implied), nor does it provide context about prerequisites or when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Remove a job from the queue
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes | Job ID | |
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It only says 'remove', which implies deletion, but lacks details on side effects (e.g., irreversible? permissions needed? impact on queue state). Insufficient for an agent to understand operational consequences.
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 brief sentence, which is concise but borderline under-specified. It could include more context without losing conciseness, such as noting the job is removed permanently.
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?
With no output schema and simple functionality, the description should still clarify return behavior (e.g., success/failure indication) or error conditions. The current text leaves gaps for an agent relying solely on this definition.
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 both parameters described as 'Job ID' and 'Queue name'. The description adds no further meaning, such as valid formats or constraints. With high coverage, baseline 3 is appropriate; no extra value from description.
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 removes a job from the queue with a specific verb ('Remove') and resource ('job'). It implicitly distinguishes from siblings like 'add_job' and 'retry_job', though it could be more precise by specifying the removal by ID from a named queue.
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 on when to use this tool versus alternatives (e.g., 'retry_job' or 'promote_job'), or prerequisites like job existence or queue state. The description only states what it does, not the appropriate context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Resume queue processing
| Name | Required | Description | Default |
|---|---|---|---|
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, but it provides no behavioral details such as prerequisites, effects on queue processing, or whether the operation is idempotent.
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?
While extremely concise, the description is under-specified and fails to convey necessary information. Conciseness should not sacrifice 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 simplicity of the tool and the presence of many sibling tools, the description is incomplete. It should mention that the queue must be paused first and what state the queue transitions to.
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?
There is only one parameter with 100% schema coverage, so the schema already defines it. The description adds no extra meaning beyond the parameter name.
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 'Resume queue processing' is vague and essentially restates the tool name. It does not clearly indicate that it resumes a paused queue, which is the likely intent given sibling tools like 'pause_queue'.
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 like 'pause_queue' or 'drain_queue'. The context is implied but not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retry a failed job
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes | Job ID | |
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure. It only says 'retry' but does not explain side effects (e.g., does it reset attempts, move the job, or require any permissions?). The agent gets no insight into what happens after invocation.
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 that front-loads the action. However, it could benefit from slightly more context (e.g., 'from its original queue') without becoming verbose. It is efficient but minimal.
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 has two required parameters and no output schema, the description is adequate for a simple operation. However, it lacks context about job state (must be failed), queue validity, and what happens after the retry (e.g., success/failure). Completeness is acceptable but not robust.
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 provides basic descriptions for jobId and queue. The tool description adds no extra meaning beyond referencing a 'failed job', which is a usage constraint rather than parameter semantics. Baseline 3 applies.
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 'retry' and the resource 'a failed job', which distinguishes it from sibling tools like add_job (create), get_job (read), remove_job (delete), and promote_job (different action). It's specific and unambiguous.
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 (e.g., promote_job, add_job). No prerequisites, no when-not-to-use, and no context about the job's state or queue existence. The description simply states the action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get queue statistics
| Name | Required | Description | Default |
|---|---|---|---|
| queue | Yes | Queue name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior. It states 'Get' implying a read-only operation, but does not confirm no side effects, resource consumption, or caching behavior. The description is too minimal for full 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 short phrase, highly concise. It could be slightly more informative without adding much length, but it is efficient.
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, no output schema, no annotations), the description is too terse. It fails to explain what statistics are provided or how the output is structured, leaving an agent with insufficient context for correct usage.
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 only parameter 'queue' has a clear description in the schema ('Queue name') which provides 100% coverage. The description adds no additional meaning beyond the schema, so a 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 'Get queue statistics' clearly indicates the tool retrieves some form of statistics for a queue, distinguishing it from specific list/get tools like get_jobs or list_queues. However, it lacks specificity about what type of statistics (e.g., count, rate, latency) are returned.
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 sibling tools like get_jobs or list_queues. There are no exclusions, prerequisites, or context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Switch to a different connection
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Connection identifier to switch to |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only says 'Switch to a different connection'. It does not disclose what happens to the previous connection, whether it disconnects or stays active, or any prerequisites like being already connected.
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 extremely concise with a single sentence that clearly states the purpose. It is well front-loaded, but could benefit from slightly more detail without losing efficiency.
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 tool with one parameter and no output schema, the description is minimally sufficient. However, given the presence of many sibling tools, additional context about when to switch vs connect would improve completeness.
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 parameter 'id' is described in the schema (100% coverage), so the description adds no extra meaning. Baseline 3 is appropriate as the schema handles the definition.
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 switches to a different connection, specifying the verb 'Switch' and resource 'connection'. However, it does not distinguish from sibling tools like 'connect' or 'disconnect', which could have overlapping semantics.
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 switch_connection versus alternatives such as connect or list_connections. The context of switching between existing connections is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool targets a distinct action: connection management, queue control, job CRUD, logs, and dead letter queue. No overlap or ambiguity.
All tools follow verb_noun snake_case pattern (e.g., get_jobs, add_job_log). Even 'stats' is a common abbreviation consistent with the style.
20 tools cover connection, queue, job, log, and DLQ management without feeling excessive or sparse. Well-scoped for a BullMQ admin server.
Covers all major BullMQ operations: connection lifecycle, queue stats/control, job CRUD, retries, promotion, cleaning, logs, and dead letter queue. No obvious gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Create and manage scheduled, guarded AI agent jobs with built-in quality control and 900+ connectors
Connect AI assistants to GitHub - manage repos, issues, PRs, and workflows through natural language.
Connect, monitor, and control AI agents — tasks, approvals, schedules, and governance.
Async message queue for AI agents. Self-provision queues, push/poll messages, no signup.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/adamhancock/bullmq-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
