Provides tools for observing Vercel projects and deployments, including listing projects, fetching project details, listing deployments, and fetching deployment details.
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., "@vercel-deployment-mcp show me recent deployments for my Vercel project"
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 reference Model Context Protocol server for observing Vercel projects and deployments over stdio.
This is a community reference implementation focused on deployment-workflow patterns. It is not a replacement for Vercel's own MCP offering. Its purpose is to demonstrate, in a small and readable codebase, how a deployment-focused MCP server can handle configuration cleanly and behave predictably on short-lived infrastructure.
Tool | Description |
| List projects visible to the configured account/team (search, limit) |
| Fetch one project by ID or name |
| List recent deployments (filter by project, state, limit) |
| Fetch one deployment by ID or URL, including current state |
list_projects and list_deployments each return a single page of up to
limit results (default 20, max 100). There is no cursor pagination; narrow
the request with search, projectId, or state to see more specific
results.
Related MCP server: Vercel MCP
From npm:
npm install @addiplus/vercel-deployment-mcpOr run it directly without installing:
npx @addiplus/vercel-deployment-mcpFrom source:
git clone https://github.com/addiplus/vercel-deployment-mcp.git
cd vercel-deployment-mcp
npm install
npm run build
npm testBuilding and testing this repo requires Node 22+ (CI runs 22 and 24); the
published package runs on Node >=18 per engines.
Variable | Required | Purpose |
| yes | Vercel access token (create in account settings) |
| no | Scope requests to a team |
| no | Minimum milliseconds between the start of one Vercel API request and the next (default |
| no | Maximum number of Vercel API requests in flight at once (default |
On an HTTP 429 with a numeric Retry-After header of 10 seconds or less, the
server waits that long and retries the request once; any other 429 is
surfaced as an error on the first attempt.
Example client configuration (Claude Desktop / Claude Code):
{
"mcpServers": {
"vercel-deployment": {
"command": "npx",
"args": ["-y", "@addiplus/vercel-deployment-mcp"],
"env": { "VERCEL_TOKEN": "…" }
}
}
}When running from a source checkout, use "command": "node" with
"args": ["/path/to/vercel-deployment-mcp/dist/index.js"] instead.
Dated 2026-07-10. Each claim below is implemented in code and verified by the
test suite where testable (test/); design properties cite the implementing
code.
Configuration values never appear in output. The access token is read
only from the environment. Error messages are shaped, size-bounded, and
passed through a redaction guard so upstream API messages cannot echo the
value back (src/vercel.ts).
stdout belongs to the protocol. All diagnostics go to stderr
(src/index.ts), so no log line can leak into a tool response.
Minimal footprint. v0.1 tools are read-only observations of projects and deployments; the server requests nothing beyond what those reads need.
Stateless by design. Configuration is re-read from the environment on
every tool call (verified in test/tools.test.ts), so behavior is
identical on long-lived hosts and short-lived workers. The one piece of
module-level state is a request throttle (src/vercel.ts) that spaces out
and caps concurrent Vercel API calls; its interval and concurrency
settings are read once at first use, and it holds no credentials or
response data.
Deployment actions with an explicit out-of-band approval step (exploring the patterns discussed in MCP spec issues #2919/#2920 around multi-round tool results on stateless transports).
Standardizing how server.json describes stdio package install manifests
and how clients convert them into local configuration files (spec issue
#2963, registry issue #749).
MIT
Fetch one deployment by ID or URL, including its current state.
| Name | Required | Description | Default |
|---|---|---|---|
| idOrUrl | Yes | Deployment ID (dpl_…) or deployment URL |
| Name | Required | Description |
|---|---|---|
| item | Yes | |
| receipt | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is clear. The description adds minimal behavioral context ('including its current state'), but this does not go beyond what the output schema likely provides, so the added transparency value is modest.
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, well-structured sentence that leads with the action verb, states the resource and identification method, and adds the key detail about current state. 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?
This is a simple read-only fetch with a single parameter, an output schema, and comprehensive annotations. The description adequately covers what the tool does, how to identify the deployment, and what is returned (current state), and the output schema handles return values, so nothing critical is missing.
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%, with the parameter 'idOrUrl' fully documented as 'Deployment ID (dpl_…) or deployment URL'. The description repeats this idea ('by ID or URL') without adding new semantic detail, so it does not exceed the baseline provided by 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 uses the specific verb 'Fetch' and clearly identifies the resource as a deployment, also specifying the lookup method (by ID or URL) and that it includes current state. This distinguishes it from sibling tools like list_deployments and get_project.
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 implies this is for fetching a single known deployment, but it does not explicitly state when to use it over list_deployments or exclude alternatives. The usage guidance is present only implicitly, not explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch one project by ID or name.
| Name | Required | Description | Default |
|---|---|---|---|
| idOrName | Yes | Project ID or project name |
| Name | Required | Description |
|---|---|---|
| item | Yes | |
| receipt | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral context beyond what annotations already provide (read-only, open-world, idempotent, non-destructive). It does not mention auth, error behavior, or response characteristics, so it fails to add value over the rich annotation set.
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, well-structured sentence that conveys the exact purpose without any fluff. It earns its place and is immediately scannable.
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?
The tool is extremely simple with one parameter and a rich output schema plus strong annotations. The description, while terse, is sufficient for an agent to understand the operation given the structured context; no additional details are necessary.
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%, with 'idOrName' already documented as 'Project ID or project name'. The tool description adds no additional semantic meaning, so the baseline of 3 applies because the schema does the heavy lifting.
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 fetches one project by ID or name, which is a specific verb+resource scope. It implicitly distinguishes from the sibling list_projects by emphasizing 'one project'.
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 implies usage when you know the project ID/name, but it does not explicitly mention when not to use it or how it compares to list_projects. No alternative tools are named, so guidance is only implicit and minimal.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List recent deployments, optionally filtered by project ID and state (e.g. BUILDING, ERROR, READY).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 20) | |
| state | No | Comma-separated states, e.g. READY,ERROR | |
| projectId | No | Limit to one project |
| Name | Required | Description |
|---|---|---|
| items | Yes | |
| receipt | Yes | |
| pageCount | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds minor context like 'recent' (implying ordering) but does not disclose pagination, rate limits, or other behavioral traits beyond what annotations provide.
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 concise sentence that front-loads the core purpose and lists optional filters without unnecessary detail.
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 read-only list tool with a full output schema, complete parameter descriptions, and comprehensive annotations, the description is sufficient. The minor ambiguity of 'recent' is not critical to understanding the tool's function.
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 covers all three parameters with descriptions (100% coverage), so the schema carries the burden. The description adds example state values (BUILDING, ERROR, READY) that complement the schema's example, but this is minimal added value.
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 action (list) and resource (deployments), and the optional filters (project ID, state) are specified. It naturally distinguishes from siblings like get_deployment and list_projects.
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?
Usage is implied by the tool's name and description, but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions. The sibling names hint at distinctions, but the description does not state them.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List projects visible to the configured account or team. Optional text search and result limit.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 20) | |
| search | No | Filter projects by name |
| Name | Required | Description |
|---|---|---|
| items | Yes | |
| receipt | Yes | |
| pageCount | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds the scope note 'visible to the configured account or team', which is useful context beyond the annotations. However, the annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the description does not need to restate safety. It does not disclose additional behavioral traits such as pagination, sorting, or rate limits.
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 that front-loads the core action and resource, then briefly mentions the two optional parameters. There is no redundancy or filler; every word adds value.
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 listing tool, the description is adequately complete when combined with the rich schema (100% parameter coverage) and the output schema. The only minor gap is that it does not hint that get_project can be used for detailed single-project information, but that is not essential for using this tool correctly.
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 schema already provides full descriptions for both parameters (limit: 'Max results (default 20)', search: 'Filter projects by name') with 100% coverage. The description only paraphrases these as 'Optional text search and result limit', adding no 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?
The description clearly states the action ('List') and the resource ('projects') with a scope qualifier ('visible to the configured account or team'). This distinguishes it from sibling tools like get_project (single project) and list_deployments (a different resource).
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 implies the tool is for listing projects and mentions optional search and limit, but it does not explicitly state when to use this over alternatives or provide exclusions. The sibling tool set (get_project, list_deployments) suggests different purposes, but the description itself does not guide selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.2.0get_deploymentget_projectlist_deploymentslist_projectsEach tool is clearly distinct: list vs get for projects and deployments. There is no overlap between listing and fetching individual resources, making selection unambiguous.
All tool names follow a consistent verb_noun pattern with 'get' for single items and 'list' for collections, and nouns are appropriately singular or plural. The naming is predictable and uniform.
With 4 tools, the set is well-scoped for a read-only deployment monitoring server. It covers both projects and deployments with list and get operations, and each tool earns its place without unnecessary bloat.
For the apparent purpose of retrieving project and deployment information, the tool surface is complete. It provides list and get for both resources, with filtering options on deployments, leaving no obvious dead ends.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server for interacting with the Supabase platform
An MCP server that let you interact with Cycloid.io Internal Development Portal and Platform
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/addiplus/vercel-deployment-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
