# Neon MCP for AI Agents AI Agent Connect

> Neon (Serverless PostgreSQL) MCP. Manage your serverless database infrastructure, handle zero-copy branching, audit projects, and monitor compute endpoints directly through your AI agent.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_Wyz38ZBi3SeTs6Rve6ru1Zk6eusbP8f3rO1EXQtp/ai-agent-connect
- **Tags:** postgresql, serverless, database-branching, cloud-native, autoscaling, infrastructure-as-code

## Description

You're tired of jumping between a web console and your terminal just to spin up a new database branch or check a project's storage caps. This Connector lets you handle all that heavy lifting through a simple conversation with your AI agent. Instead of hunting for connection strings or manually auditing roles, you can just ask your agent to find the right endpoint or list the schemas for a specific branch. It makes managing your database feel like talking to a teammate who knows the infrastructure inside out. Since Vinkius hosts this Connector, you can connect it to your existing setup and start managing your serverless Postgres environment without the usual friction of manual CLI commands. You can quickly spin up isolated testing environments that share your production schema without the wait time of traditional cloning. Whether you're trying to debug a production issue in a safe sandbox or you need to provision a fresh workspace for a new microservice, you can do it all without leaving your editor. It turns a series of tedious clicks and copy-paste jobs into a single, coherent workflow where you just describe what you need and the agent handles the rest.

## Tools

### create_branch
Create a new database branch using zero-copy links for isolated testing. This allows you to test features without affecting production data.

### delete_project
Permanently delete a project and all its associated storage blocks. This is useful for cleaning up old test environments.

### get_branch
Inspect the storage deltas and timeline points for a specific branch. Use this to see exactly when a branch split from its parent.

### get_project
Analyze the core routing logic and storage caps for a specific project. This helps you monitor your project's resource limits.

### list_databases
Identify all internal SQL database schemas mapped to a branch. Use this to verify your connection logic.

### list_endpoints
Discover the connection routing endpoints for your project. This provides the exact strings needed for your application drivers.

### list_projects
List all managed serverless PostgreSQL projects in your account. This helps you audit your entire infrastructure footprint.

### list_roles
Extract the PostgreSQL user roles operating on a specific branch. Use this to audit permissions and security.

### create_project
Provision a new, empty Neon Project serverless workspace. Use this to set up a fresh environment for a new application.

### list_branches
View all branches mapped to a specific project. This gives you a clear overview of your experimental environments.

## Prompt Examples

**Prompt:** 
```
List all the serverless projects I have right now.
```

**Response:** 
```
I've retrieved your Neon projects. Currently, you have 3 workspaces:

| Project Name | Region | Storage Cap |
| :--- | :--- | :--- |
| prod-cluster | AWS us-east-1 | 500GB |
| staging-env | AWS us-east-1 | 100GB |
| dev-sandbox | AWS us-east-1 | 50GB |

Would you like to see the active branches for the production cluster?
```

**Prompt:** 
```
Make a new branch called 'dev-test' from my main branch.
```

**Response:** 
```
Spawning zero-copy clone… Success.

I've created the **dev-test** branch (ID: br-98765) from your main source. This branch is now isolated and ready for queries.

**New Compute Endpoint:** `ep-dev-test-456.us-east-1.aws.neon.tech`
```

**Prompt:** 
```
What roles are allowed to query my dev branch?
```

**Response:** 
```
Retrieving branch inventory for your dev branch…

I've identified 3 active roles:
*   `neondb_owner` (Full Access)
*   `app_writer` (Read/Write)
*   `readonly_user` (Read Only)

I can help you verify the specific permissions for any of these roles if you'd like.
```

## Capabilities

### Spin up isolated database branches
Create brand new database branches instantly using zero-copy links for isolated testing.

### List all serverless project workspaces
Retrieve a full list of your managed serverless PostgreSQL projects in one go.

### Find specific compute connection strings
Discover the exact connection routing endpoints required for your application drivers.

### Audit PostgreSQL user roles
Extract and audit all user identities and credential roles operating on a specific branch.

### Provision new serverless workspaces
Initialize fresh serverless workspaces or wipe out entire database ecosystems with simple commands.

### Monitor storage and routing logic
Analyze core routing logic and storage consumption caps for any specific project ID.

## Use Cases

### Isolated Feature Testing
A developer needs to test a new auth flow. They ask their agent to use create_branch to spin up a 'feat-auth' branch from the main source.

### Security Role Auditing
A DBA needs to verify permissions on a production branch. They ask the agent to use list_roles to extract all active user identities.

### Rapid Workspace Provisioning
A platform engineer needs to set up a new staging environment. They ask the agent to use create_project to initialize a fresh workspace.

### Storage Cap Monitoring
A developer is seeing performance issues and asks the agent to use get_project to check the current storage consumption and limits.

## Benefits

- Stop manual CLI work by using create_branch to spin up test environments instantly without affecting your main data.
- Find connection strings faster with list_endpoints instead of hunting through the dashboard for the right URL.
- Secure your data by auditing permissions with list_roles to see exactly which identities have access to your branches.
- Manage infrastructure at scale by using list_projects to see your entire footprint across different regions.
- Save time on environment setup by using create_project to provision new workspaces through simple conversation.
- Keep your production safe by using get_branch to audit storage deltas and LSN points to understand your branch history.

## How It Works

The bottom line is you get full database infrastructure control through a natural chat interface.

1. Subscribe to the Neon MCP on the Vinkius Marketplace.
2. Enter your Neon API Key into the configuration settings.
3. Start managing your Postgres projects from Claude, Cursor, or any other MCP-compatible client.

## Frequently Asked Questions

**Can the Neon MCP help me manage my serverless databases?**
Yes, it lets you manage your projects, branches, and roles through a natural chat interface. You can do all the heavy lifting without leaving your AI client.

**How does the Neon MCP handle database branching?**
It uses zero-copy links to create isolated branches instantly. This means you get a new testing ground with your production schema without the wait time of a full copy.

**Can I use the Neon MCP to find connection strings?**
Yes, it can list all your compute endpoints so you can get the correct URLs for your application drivers immediately.

**Is the Neon MCP good for auditing my database roles?**
Yes, it can pull a list of all user identities and roles for your branches, making it much easier to audit your security posture.

**Can I provision new projects using the Neon MCP?**
Yes, you can tell your agent to initialize new serverless workspaces or wipe out old ones using simple commands.

**Does the Neon MCP work with Cursor or Claude?**
Yes, it connects to any MCP-compatible client, including Claude, Cursor, Windsurf, and VS Code.

**What is Neon's 'Zero-Copy Branching' and how do I use it through the agent?**
Zero-copy branching allows you to clone a multi-terabyte database instantly using Copy-on-Write (CoW). Use the `create_branch` tool by providing a parent branch ID. Your agent will trigger the backend to generate an isolated clone in milliseconds, perfect for running migrations or testing features against production-like data.

**Can my agent retrieve the exact connection strings for my compute endpoints?**
Yes. Use the `list_endpoints` tool with your Project ID. Your agent will retrieve the explicit hostnames (e.g., `ep-misty-water-123.aws.neon.tech`) used to actively ingest real query traffic to your serverless Postgres branches.

**How do I check the storage consumption for a specific Neon branch?**
The `get_branch` tool retrieves the deconstructed execution footprint of an individual branch. Your agent will report the storage limits and exact number of bytes consumed uniquely by that branch's data delta since it split from its parent.