# How to Connect Cursor to Kuberns via MCP and Debug Builds

> Connect Kuberns MCP to Cursor, authorize deployment access, and combine build logs with repository context to find and resolve failed deployments faster.
- **Author**: harsh-kanani
- **Published**: 2026-09-26
- **Modified**: 2026-09-26
- **Category**: AI & DevOps
- **URL**: https://kuberns.com/blogs/connect-cursor-to-kuberns/

---

To connect Cursor to Kuberns, add the Kuberns remote MCP endpoint to Cursor, authenticate your Kuberns account, and confirm that its tools are available to Cursor Agent. Cursor can then combine its understanding of your repository with supported Kuberns deployment information, including deployment status, build history, logs, and non-secret configuration.

Use this endpoint:

```text
https://mcp.kuberns.cloud/mcp
```

The main benefit is not simply managing Kuberns without leaving Cursor. **Cursor already understands your codebase. Kuberns gives it the missing deployment context.** When a build fails, Cursor can examine the deployment evidence from Kuberns and compare it with the source files, dependencies, and configuration in your repository.

This guide connects Cursor to the existing Kuberns MCP service. It does not explain how to build or host an MCP server. If you created your own server and need to make it remotely accessible, follow the guide to [deploy your MCP server to production](https://kuberns.com/blogs/deploy-mcp-server/).

## What Can Cursor Do After Connecting to Kuberns?

The connection gives Cursor access only to the tools published by Kuberns and approved for your account. Based on the authorization flow used for this guide, the practical workflows include inspecting deployment status, reviewing build and runtime logs, checking non-secret configuration, and diagnosing application failures.

| Task in Cursor | Example request |
|---|---|
| Check deployment status | “Use Kuberns to check the status of my latest deployment.” |
| Review build history | “Summarize the latest builds for this application.” |
| Diagnose a failed build | “Inspect the latest failed build and compare the error with this repository.” |
| Review runtime errors | “Check recent runtime logs for recurring application errors.” |
| Inspect safe configuration | “List the configured environment-variable names without showing their values.” |
| Review resources | “Show the resource configuration available for this service.” |

Always review the current tool list before relying on an operation. A connected MCP server does not automatically mean every deployment action is supported.

## Why Connect Kuberns When Cursor Already Understands the Repository?

Cursor can inspect the code, package files, dependencies, application structure, and configuration in the active repository. That context helps it explain how the application is intended to work, but the repository alone does not show what happened during a remote build or after the application started running.

Kuberns provides the deployment side of the investigation through its authorized MCP tools. That can include deployment status, build history, build and runtime logs, and non-secret environment or resource configuration. The combination lets Cursor compare what the code expects with the evidence produced during deployment.

For example, a build log may report a missing dependency, unsupported command, or absent environment-variable name. Cursor can retrieve that error through Kuberns, locate the relevant manifest or source file in the repository, and explain the smallest likely correction. The developer still reviews the evidence and approves any change.

[Kuberns](https://kuberns.com/) is an Agentic AI platform for deployment designed for full-stack and complex backend projects. Connecting Kuberns to Cursor brings supported deployment context into the editor where the application is already being built and debugged.

## What Do You Need Before Connecting Cursor to Kuberns?

Prepare the following:

- Cursor installed and signed in.
- A Kuberns account you are permitted to authorize.
- A project deployed on Kuberns for a meaningful test.
- Permission to add or use an MCP server in Cursor.
- A browser available for the OAuth authorization flow.
- The Kuberns endpoint: `https://mcp.kuberns.cloud/mcp`.

You do not need to install an MCP package, run a local MCP process, create an API key, add a token to the URL, or build an OAuth implementation. Kuberns is configured as a remote HTTP server and authentication is completed in the browser.

> **Still working only in Cursor?** [Deploy your full-stack application with Kuberns](https://kuberns.com/blogs/deploy-full-stack-app-with-ai/) first. Once the application is live, return here to connect Cursor for deployment inspection and debugging.

## How Do You Connect Cursor to Kuberns?

Cursor's current MCP documentation supports remote servers through `mcp.json` and OAuth for servers that require authentication. The supplied screenshots show the current **Customize → MCPs** interface and the Kuberns browser authorization flow.

### Step 1: Open Cursor's MCP Settings

Open **Customize** in Cursor, select **MCPs**, and choose **New MCP Server**. This area lists connected servers and integrations that require attention.

![Open Cursor MCP settings to add the Kuberns server](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/open-mcp-settings-in-cursor.jpg)

**Expected result:** Cursor opens the MCP management view and offers an option to add a custom server.

### Step 2: Add the Kuberns Remote MCP Endpoint

Cursor supports two configuration locations:

- **Global:** `~/.cursor/mcp.json`, for tools available across your projects.
- **Project:** `.cursor/mcp.json`, for a server associated with one repository.

Add this configuration:

```json
{
  "mcpServers": {
    "kuberns": {
      "url": "https://mcp.kuberns.cloud/mcp"
    }
  }
}
```

Do not add a personal password, OAuth token, or undocumented authorization header. Save the file, return to Cursor, and reload the application if the server does not appear.

Cursor's <a href="https://prod.cursor.com/help/customization/mcp" target="_blank" rel="noopener noreferrer">official MCP integration documentation</a> states that global and project configurations are merged. When both locations define a server with the same name, the project-level entry takes priority.

### Step 3: Authenticate Kuberns in Cursor

After Cursor detects the endpoint, Kuberns can appear under **Needs Attention** with an **Authenticate** action. Select **Authenticate** to begin the browser-based authorization flow.

![Kuberns MCP server awaiting authentication in Cursor](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/authenticate-kuberns-mcp-in-cursor.jpg)

Do not treat **Needs authentication** as proof that the endpoint is broken. It means Cursor knows about the server but does not yet have an authorized Kuberns session.

### Step 4: Review the Kuberns Permissions

The supplied Kuberns consent screen requests permission to:

- View deployment status and build history.
- View build and runtime logs.
- View environment and resource configuration without secret values.
- View billing and credits information.
- Create and update support tickets.
- Debug the application.

![Review the permissions requested by Kuberns in Cursor](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/review-kuberns-mcp-permissions-in-cursor.jpg)

The authorization screen is the authoritative description of the access being requested. Confirm the signed-in account, application name, and permissions before selecting **Approve**. The visible email address must be redacted before the screenshot is published.

### Step 5: Return to Cursor

After approval, the browser should confirm that authorization is complete. Select **Return to Cursor** or close the tab and reopen Cursor.

![Kuberns MCP authorization completed for Cursor](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/kuberns-mcp-authorization-complete-in-cursor.jpg)

### Step 6: Verify the Server and Available Tools

Authorization alone does not prove the entire integration works. Verify all of the following:

1. Kuberns appears in Cursor's MCP list.
2. The server is enabled or connected.
3. The authentication warning is gone.
4. Kuberns tools are visible to Cursor Agent.
5. A read-only tool request returns information from the authorized account.

Start a new Agent conversation if the existing conversation was open before the server connected. Then use this test prompt:

> Use Kuberns to show the status and recent build history of my latest deployment. Do not make any changes.

## Should You Configure Kuberns Globally or Per Project?

Choose the narrowest configuration that still supports your workflow.

| Configuration | Best for | Important consideration |
|---|---|---|
| Global | One developer using Kuberns across several repositories | The server becomes available throughout that user's Cursor projects |
| Project-specific | One repository or a team-standard endpoint | The endpoint can be committed, but personal credentials must not be shared |
| Both | Different endpoints or deliberate overrides | A project entry with the same name takes priority |

Use the global configuration when you personally manage several Kuberns applications. Use `.cursor/mcp.json` when the endpoint is relevant to a specific repository or the team wants the server definition documented with the codebase.

Sharing `.cursor/mcp.json` should share only the endpoint configuration. Each developer should complete OAuth using their own Kuberns account. Never commit access tokens, refresh tokens, passwords, or private credentials.

## How Do You Test the Kuberns Connection Safely?

Start with a read-only request that names the source and the expected result:

> Use Kuberns to check the latest deployment status for this application. Summarize the build result and any actionable error. Do not change the deployment or create a support ticket.

A successful response should show that Cursor selected an appropriate Kuberns tool and returned deployment information from the authorized account. Confirm the application identity before acting on the result, especially when the account contains several projects.

Review the selected tool before approving it. Avoid unrestricted execution for sensitive actions merely to make testing faster. If Cursor asks to use a tool that can create or update external data, inspect its name, inputs, and effect before proceeding.

## How Can Cursor Diagnose a Failed Kuberns Build?

Failed-build diagnosis is where the two contexts become especially useful. Kuberns supplies the remote build evidence, while Cursor can inspect the exact repository that produced the build.

### 1. Retrieve the failed-build evidence

Ask Cursor to inspect the latest failed build without making changes:

> Use Kuberns to inspect the latest failed build for this application. Summarize the first actionable error and include the relevant build stage. Do not modify anything.

### 2. Compare the error with the repository

Once Cursor has the error, ask it to locate the related code or configuration:

> Compare that build error with the files in this repository. Identify the most likely cause, cite the relevant file, and explain why the deployment failed.

### 3. Request the smallest safe correction

Before allowing an edit, ask for a plan:

> Explain the smallest code or configuration change that could resolve the failure. Show the proposed change and any tradeoffs before editing files.

This workflow keeps the evidence chain clear. Kuberns reports what happened during the build, Cursor connects the error to the repository, and the developer decides whether the proposed correction is appropriate. For additional debugging context, see [why applications work locally but fail in production](https://kuberns.com/blogs/app-works-locally-fails-in-production/) and the [common causes of deployment failures](https://kuberns.com/blogs/why-do-software-deployments-fail/).

## Can Cursor See Kuberns Secret Values?

The Kuberns authorization screen used for this guide states that access to environment and resource configuration excludes secret values. Cursor may be able to inspect supported configuration metadata, such as environment-variable names, without receiving the protected values themselves.

Treat this as one layer of protection, not permission to share credentials elsewhere. Do not paste Kuberns passwords, private tokens, database credentials, or environment secret values into Cursor chat. Do not store personal credentials in a project-level `mcp.json` file.

When comparing repository requirements with deployed configuration, use a prompt such as:

> List the environment-variable names available through Kuberns without showing their values. Compare those names with the variables referenced in this repository.

For production configuration practices, see how to [manage production environment variables safely](https://kuberns.com/blogs/environment-variables-in-production/).

## How Do You Fix Common Cursor and Kuberns Connection Problems?

Use the stage where setup stopped to narrow the problem.

| Problem | Likely cause | What to do |
|---|---|---|
| Kuberns does not appear in MCP settings | Wrong file location or invalid JSON | Check `.cursor/mcp.json` or `~/.cursor/mcp.json`, validate the JSON, and reload Cursor |
| Kuberns remains under Needs Attention | OAuth has not completed or the saved session is invalid | Select Authenticate and complete the browser flow again |
| Authorization completes but tools are missing | Tool discovery or the Agent session is stale | Start a new Agent conversation, toggle the server, and reload Cursor |
| Cursor does not select Kuberns | The request does not identify the required source | Begin the prompt with “Use Kuberns to” and name the deployment task |
| The project configuration works in only one repository | `.cursor/mcp.json` is project-specific | Add the endpoint globally when it should be available across projects |
| The server shows a connection error | Endpoint, network, protocol, or authentication problem | Confirm the URL, inspect MCP logs, and retry authentication |
| Cursor shows an older tool list | Cached connection state | Disable and re-enable the server or restart Cursor |
| Authentication repeatedly expires | The saved OAuth session is no longer valid | Disconnect Kuberns and complete a new authorization flow |

### Check Cursor MCP logs

Open Cursor's Output panel and select **MCP Logs**. Look for evidence that Cursor contacted the endpoint, requested authentication, discovered tools, or received an HTTP or transport error.

Redact tokens, account identifiers, deployment information, private domains, and other sensitive data before sharing logs with another person or a support team.

## How Do You Disconnect Kuberns From Cursor?

Open **Customize → MCPs**, select Kuberns, and disable or remove the server. If you added the server manually, delete its entry from the appropriate `mcp.json` file and reload Cursor.

Removing the configuration prevents Cursor from loading that server, but configuration removal and authorization revocation may be separate actions. If Kuberns provides a connected-app or authorization control in the account, revoke the grant there when you want to end account access completely.

## Cursor Understands the Code; Kuberns Explains the Deployment

Cursor is most useful for production troubleshooting when it can compare the code in the repository with real deployment evidence. Connecting Kuberns through MCP gives Cursor access to supported deployment status, build history, logs, and non-secret configuration in the same editor workflow.

Deploy the application on Kuberns, connect the remote MCP endpoint, and begin with a read-only request. When a build fails, use Kuberns to retrieve the error and Cursor to trace that evidence back to the responsible code or configuration.

[![Deploy your application with Kuberns and connect its deployment context to Cursor](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/CTA_banner.png)](https://dashboard.kuberns.com/)

## Frequently Asked Questions

### How do I connect Cursor to Kuberns?

Add the Kuberns URL `https://mcp.kuberns.cloud/mcp` to Cursor as a remote MCP server, select **Authenticate**, complete the Kuberns OAuth flow, and verify the connection with a read-only tool request.

### What is the Kuberns MCP URL for Cursor?

The Kuberns remote MCP endpoint used in this guide is `https://mcp.kuberns.cloud/mcp`. Verify the endpoint against current Kuberns documentation before configuring it.

### Should I add Kuberns globally or per project in Cursor?

Use the global configuration when you want Kuberns available across your Cursor projects. Use `.cursor/mcp.json` when the endpoint is relevant to one repository or the team should share the server definition. Each developer should authenticate their own account.

### What can Cursor access in my Kuberns account?

The authorization screen used for this guide requests access to deployment status, build history, build and runtime logs, non-secret environment and resource configuration, billing and credit information, support-ticket operations, and application debugging. Review the live consent screen before approval.

### Can Cursor see Kuberns environment secret values?

The Kuberns authorization screen used for this guide states that environment and resource configuration does not include secret values. Do not paste secrets into Cursor chat or store personal credentials in a committed MCP configuration.

### Why is Kuberns connected but unavailable to Cursor Agent?

Start a new Agent conversation, confirm that the Kuberns server is enabled, and check whether its tools are visible. If the state remains stale, disable and re-enable the server or reload Cursor before authenticating again.

### Can Cursor deploy or modify my application through Kuberns?

This guide verifies connection, inspection, and troubleshooting workflows only. Do not assume Cursor can deploy, redeploy, roll back, restart, scale, or change an application unless the live Kuberns tool inventory explicitly provides and authorizes that operation.

### How do I disconnect Kuberns from Cursor?

Open Cursor's MCP settings and disable or remove the Kuberns server. If it was added manually, remove its entry from the appropriate `mcp.json` file. Revoke the authorization separately if Kuberns provides an account-side connection control.

---
- [More AI & DevOps articles](https://kuberns.com/blogs/category/ai-devops/1/)
- [All articles](https://kuberns.com/blogs/)