# Deno Deploy MCP for AI Agents MCP

> Deno Deploy MCP gives your AI agent control over your entire edge computing infrastructure. You can list, manage, and deploy serverless applications written in Deno, all through natural conversation with any compatible client.

## Overview
- **Category:** ship-it
- **Price:** Free
- **Tags:** deno, serverless, edge-computing, deployment, javascript-runtime

## Description

Managing an edge network is usually a CLI nightmare. This connection lets you talk to your Deno Deploy account using your preferred AI agent. Instead of running complex sequences of commands, you just ask your agent what you need done—whether it's listing every app in the organization or deploying a fresh revision.

For example, you can tell your agent to fetch details on an application, then immediately request its build logs for debugging. It handles the whole process, giving you visibility into everything from shared environment variables (layers) to custom domains. This makes it possible to run complex deployment and monitoring workflows without ever leaving your chat interface. By connecting this through Vinkius, you get a single point of access to orchestrate all your serverless applications.

## Tools

### create_app
Sets up a brand new Deno Deploy application in your account.

### create_deployment
Triggers a new deployment (revision) for an existing app, updating the live code.

### create_layer
Creates a shared environment layer to hold variables used across multiple applications.

### create_project_deployment
Deploys a new revision specifically for an entire project, rather than just one application.

### get_app_logs
Queries historical logs for an application based on specific time frames and error levels.

### get_app
Fetches detailed metadata and configuration settings for a single Deno Deploy app.

### get_build_logs
Streams real-time build logs, showing the process as the application is compiled into a new revision.

### get_organization
Retrieves high-level details about your entire Deno Deploy organization account.

### get_revision_progress
Streams the progress of a deployment revision, showing its current status (e.g., uploading assets).

### get_revision
Retrieves the current operational status and metadata for a specific deployed revision ID.

### list_apps
Lists all applications in your organization, supporting filtering by labels to narrow down results.

### list_domains
Retrieves a list of custom domains registered and associated with the organization.

### list_projects
Shows all defined projects within your Deno Deploy account structure.

### list_revisions
Lists every historical revision for a specific application, providing version history.

### update_layer
Modifies existing shared environment layers to update variables without affecting other apps.

## Prompt Examples

**Prompt:** 
```
I need to know if my 'api-gateway' service is running correctly and what its latest build logs were.
```

**Response:** 
```
Okay, I checked the status for api-gateway. It appears operational. Here are the last 10 entries from the build log: 

| Timestamp | Level | Message |
| :--- | :--- | :--- |
| 2024-06-12T10:05Z | INFO | Build started successfully.
| 2024-06-12T10:07Z | WARN | Deprecation warning on module X. Upgrade needed. |
| 2024-06-12T10:10Z | SUCCESS | Deployment finished. App ready for traffic. |

Looks clean, but keep an eye on that deprecation warning.
```

**Prompt:** 
```
List all my current apps and tell me which ones are using custom domains.
```

**Response:** 
```
**Deno Deploy Apps Overview**

*   `auth-service`: Running. Domain: `auth.yourdomain.com`.
*   `web-frontend`: Deploying (65%). Domain: N/A.
*   `payment-api`: Running. Domain: `payments.yourcompany.net`.

I also found the following custom domains registered to your account: 
*   `support.yourdomain.com`
*   `dev.yourcompany.net`
```

**Prompt:** 
```
Can you help me update the database URL for all my services?
```

**Response:** 
```
Got it. I'm updating the shared environment layer now. This affects all apps drawing from this layer. 

✅ **Success:** Layer 'global-env' updated.
*   **Variable:** `DATABASE_URL`
*   **New Value:** `postgresql://newuser:s3cur3p@prod-db.com/main`

Please trigger a redeployment for critical apps like the payment API to ensure they pick up the new connection string.
```

## Capabilities

### Manage Applications
List all deployed applications within an organization or fetch deep configuration details for a specific app.

### Control Deployment Cycles
Start new deployments (revisions) by uploading assets, or create project-specific deployments using the latest code base.

### Monitor Live Logs and Status
Stream build logs for new revisions or query historical application errors with filtering options.

### Handle Infrastructure Layers
Create or update shared environment variables using layers, centralizing configs across multiple apps.

### Inspect Organization Details
Get organization metadata, list associated custom domains, and view project-specific configurations.

## Use Cases

### A new feature deployment fails and needs debugging
A full-stack developer runs into a 500 error after pushing code. Instead of running `deno deploy --log` manually, they ask their agent to check the logs for that specific app using `get_app_logs`, immediately spotting the database timeout error.

### Platform team needs to audit all deployed services
A platform engineer needs a list of every service and its current status across 20 projects. They use their agent to run `list_apps` and then loop through the results, gathering metadata for an inventory report.

### Need to update shared credentials across multiple apps
The team needs to change a database API key used by five different services. They use their agent to `create_layer` and push the updated variable once, knowing all associated applications will pick it up.

### Checking if an old deployment was successful
A DevOps engineer needs confirmation on a revision from last week. Instead of guessing which ID to check, they ask their agent to `list_revisions` and then request the status using `get_revision`.

## Benefits

- Stop manually checking deployment status. You can use `get_revision_progress` to stream real-time updates right in your chat interface.
- Debugging is faster than ever. Use `get_build_logs` or `get_app_logs` to query specific error types and timeframes without leaving your workflow.
- Centralize configurations. Create shared environment variables using `create_layer`, ensuring consistency across every app in the organization.
- Get a full picture of your infrastructure by listing all apps with `list_apps` and checking out custom domains via `list_domains`—all in one go.
- Manage complex projects efficiently. You can deploy an entire group using `create_project_deployment`, which is often faster than managing individual app deployments.

## How It Works

The bottom line is you talk to your AI client like talking to a teammate, and it handles all the underlying API calls for Deno Deploy.

1. First, subscribe to this MCP in Vinkius and provide your Deno Deploy Personal Access Token.
2. Next, prompt your AI agent with a clear request—for example, 'List all apps and show the logs for api-gateway'.
3. Finally, your agent executes the necessary tools, gathering real-time deployment status or historical log data directly into the chat.

## Frequently Asked Questions

**How do I use Deno Deploy MCP if my deployment fails?**
If your deployment breaks, you don't need to guess what went wrong. You can ask the agent for the logs and it will fetch real-time or historical build logs, showing exactly where the failure occurred.

**Can Deno Deploy MCP help me manage multiple projects?**
Absolutely. The MCP allows you to list all your defined projects and then target deployments or configuration changes across them using project-specific tools. It keeps your multi-app setup clean.

**What if I need to change a variable that 10 different apps use?**
Instead of logging into every app's dashboard, you manage shared variables through the 'layers' feature. You update the layer once, and your agent handles propagating that change across all dependent services.

**Does Deno Deploy MCP only work for new deployments?**
No. It gives you full historical visibility. You can list all past revisions and check the status or logs of any specific, older deployment ID.

**Is this connection better than using the command line CLI?**
Yes. The primary difference is conversation flow. Instead of running `list_apps` then copying the name for `get_app`, you just ask your agent to 'List apps and show me the details for X,' getting everything in a single, conversational step.