# Zeplo MCP > Zeplo (Queue & Background Job API) lets your AI agent schedule, enqueue, and monitor background tasks directly from natural conversation. Stop checking dashboards to see why a webhook failed. Use this MCP to run CRON-like schedules, send web requests for later processing, or cancel jobs without touching any code. It's full control over asynchronous workflows. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** queue-management, background-jobs, webhooks, scheduling, serverless ## Description This connector lets your agent handle anything that needs to happen in the background. Instead of relying on manual API calls or complicated cron scripts, you talk to your AI client and tell it what job needs doing, when it needs doing, and where the results should go. Your agent can send a request right now, queue it up for later processing with automatic retries, or even set up a recurring schedule that fires every hour. It gives you total visibility into your entire processing pipeline, letting you list recent jobs by status or retrieve detailed timelines for any specific task. If a job fails, you don't just see the failure; you can use this MCP to manually trigger a retry and get the logs immediately. Because all these calls run through Vinkius, your AI agent gets full visibility into every single tool call, showing exactly which jobs were enqueued and what data flowed through, so nothing happens in the dark. ## Tools ### cancel_request Stops a pending or already scheduled job from running. ### create_queue Sets up a brand new processing queue for your workspace. ### create_schedule Establishes a recurring or one-time scheduled job trigger. ### create_token Generates and returns a new API token for the workspace that is only seen once. ### delete_queue Removes an existing queue from your workspace entirely. ### delete_schedule Deletes a scheduled job trigger, stopping it permanently. ### enqueue_request Sends an HTTP request payload to be processed in the background queue immediately or later. ### get_queue Retrieves overall metrics and details about a specific processing queue. ### get_request Gets the detailed status, payload, and timeline for any single job execution request. ### invite_team_member Adds a new user to your workspace team. ### list_queue_logs Retrieves paginated history and logs for all jobs within a specific queue. ### list_queues Shows a list of all queues currently set up in your workspace. ### list_schedules Displays all active scheduled jobs configured for the workspace. ### list_team Lists all members currently belonging to the workspace team. ### list_tokens Shows a list of all generated tokens for the workspace. ### update_queue Modifies the settings or parameters of an existing queue. ### update_schedule Changes, pauses, or resumes a scheduled job trigger. ## Prompt Examples **Prompt:** ``` Enqueue a POST request to https://api.myapp.com/sync with the JSON payload { "user_id": 123 }. ``` **Response:** ``` I've enqueued the job on Zeplo. The Job ID is `zeplo_abc123`. It is currently pending and will be executed immediately with automatic retries if it fails. ``` **Prompt:** ``` List the last 5 failed jobs and tell me why they failed. ``` **Response:** ``` I found 5 failed jobs. The most recent one (`zeplo_987`) failed because the endpoint returned a 500 Internal Server Error. The others failed due to timeout. Would you like me to retry any of them? ``` **Prompt:** ``` Schedule a GET request to https://api.service.com/health to run every hour. ``` **Response:** ``` I have created a schedule on Zeplo for that endpoint. It will trigger every hour starting now. You can monitor the executions using the `list_jobs` tool. ``` ## Capabilities ### Enqueue HTTP Requests Send an HTTP request to run later; the job is automatically retried if it fails. ### Set Recurring Schedules Create scheduled jobs that trigger repeatedly, like a clockwork report or notification. ### Monitor Job Status and Logs Get the current status, payload, and full history for any job using its unique ID. ### Control Job Lifecycle Cancel pending jobs or manually kick off retries for failed tasks on demand. ### Manage Queues and Schedules List, create, update, or delete the underlying queues and schedules themselves. ## Use Cases ### Handling Failed Webhooks A payment webhook fails due to a temporary 503 error. Instead of waiting for an Ops team member, you ask your agent to check the logs using `list_queue_logs`. The agent finds the failure and uses its capabilities to trigger an immediate retry via `enqueue_request`. ### Setting Up Daily Reporting The marketing team needs a report generated every morning at 6 AM. You tell your agent this requirement, and it executes the setup using `create_schedule`. The next day, you simply ask the AI to verify the schedule is running. ### Debugging Async Code You write a new background worker that sometimes fails. Instead of writing boilerplate test code, you tell your agent to `enqueue_request` with test data and then use `get_queue` to monitor the job's progress in real time. ### Team Onboarding A new team member needs access to manage these jobs. You ask your agent to run the necessary setup calls, like generating a dedicated API key using `create_token`, so they can work immediately. ## Benefits - Stop guessing why a webhook failed. Using `list_queue_logs` lets your agent pull the full history, telling you exactly what went wrong without manual log diving. - Running complex workflows is simple. You can chain this MCP with another—say, linking an API call to a CRM update—to build multi-step automations that span multiple services. - Need to run something immediately but don't want it tied to your current code deployment? Use `enqueue_request` to offload the job and let it retry automatically if the endpoint hiccups. - Manage scheduled tasks without deploying new cron jobs. Set up recurring reports or nightly syncs using `create_schedule`, all through natural conversation with your agent. - The system is always auditable. Every single action, from setting a schedule via `create_schedule` to retrieving data via `get_request`, produces a cryptographically signed audit trail. ## How It Works The bottom line is that your AI client handles all the infrastructure calls; you just tell it what workflow needs building. 1. Tell your agent to set up a job: specifying the target endpoint (e.g., `https://api.service.com/sync`) and if it needs to run immediately, or if it needs to happen on a schedule. 2. The MCP executes the necessary API call—whether that's enqueuing via `enqueue_request` or setting up a recurrence using `create_schedule`. The job is now in Zeplo's queue. 3. Your agent confirms the setup and provides a Job ID, which you can then use to check progress with tools like `get_request`. ## Frequently Asked Questions **How do I check if a job succeeded or failed using the `get_request` tool?** The `get_request` tool provides the detailed status and timeline for any job. You can read the response data to confirm success, or review the error payload if it failed. **Can I make a recurring schedule using `create_schedule`?** Yes, you can set up schedules that run on repeating intervals (like every hour) or specific dates. Just tell your agent when and how often the job needs to fire. **If I mess up a queue, can I delete it using `delete_queue`?** Yes, the `delete_queue` tool removes the entire processing queue from your workspace. Be careful; this is irreversible and stops all jobs associated with that name. **What's the difference between `enqueue_request` and scheduling?** `Enqueue_request` sends a job to run at some point, but it’s not tied to a recurring clock. Scheduling uses `create_schedule` for tasks that must repeat over time. **What happens if I lose access to a token created with `create_token`?** You'll need to generate a fresh one. First, use the `list_tokens` tool to see what credentials you have available. Then, running `create_token` again provides your agent with brand new keys for secure operation. **If I suspect an error in my background process, how do I debug it using `list_queue_logs`?** Run `list_queue_logs` and filter the results by job ID or date range. This provides a paginated history of requests, showing exactly what data flowed through your queue and pinpointing where the failure occurred. **How can I check the overall performance or size of my queues using `get_queue`?** The `get_queue` tool gives you detailed metrics on resource usage, including current pending job counts and processing throughput. This helps you gauge if your background job system is running smoothly or needs scaling. **If a scheduled task is no longer needed, how do I properly remove it with `delete_schedule`?** You just call `delete_schedule`. This permanently removes the schedule definition from your workspace. It ensures that resources aren't wasted running tasks you set up and then forgot about. **Can I schedule a job to run at a specific time in the future?** Yes! Use the `enqueue_job` tool and specify a delay or a schedule parameter. You can tell the AI 'Schedule this request for tomorrow at 10am' and it will handle the timestamp conversion for Zeplo. **How do I check why a specific background job failed?** You can use the `get_job` tool with the Job ID. The AI will retrieve the full execution log, including the response body and status code from your endpoint, helping you debug the failure instantly. **Is it possible to cancel a job that hasn't run yet?** Absolutely. Use the `cancel_job` tool with the target Job ID. This is useful for stopping scheduled tasks or queued jobs that are no longer necessary.