4,500+ servers built on MCP Fusion
Vinkius

Neon MCP. Manage Postgres Infrastructure Via Conversation.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Neon MCP on Cursor AI Code Editor MCP Client Neon MCP on Claude Desktop App MCP Integration Neon MCP on OpenAI Agents SDK MCP Compatible Neon MCP on Visual Studio Code MCP Extension Client Neon MCP on GitHub Copilot AI Agent MCP Integration Neon MCP on Google Gemini AI MCP Integration Neon MCP on Lovable AI Development MCP Client Neon MCP on Mistral AI Agents MCP Compatible Neon MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Neon MCP Server lets you manage serverless PostgreSQL databases entirely through your AI agent. Provision projects, clone branches instantly, set up compute endpoints, and generate connection URIs—all from chat.

It gives DBAs full control over complex Postgres infrastructure without touching the console.

What your AI agents can do

Create branch

Clones a full, isolated PostgreSQL branch instantly from an existing parent branch in the project.

Create database

Creates and registers a new database within a specific Neon branch using the name you provide.

Create endpoint

Provisions either a read-write or read-only compute host for your selected Neon branch.

+ 14 more capabilities included
Provisioning Workspaces

Use create_project to set up an entirely new Neon project workspace with defined regions and PostgreSQL versions.

Cloning Isolated Branches

Run create_branch to instantly clone a feature branch from any parent, providing immediate isolation for development.

Securing Database Access

Establish new users and permissions using create_role, which generates secure passwords and owns the necessary resources.

Setting Up Compute Hosts

Provision read-write or read-only compute endpoints with create_endpoint to connect applications securely to your branch data.

Retrieving Connection Strings

Get a ready-to-use connection URI for any specific project or branch using get_connection_uri.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Neon: 17 Tools for Database & Endpoint Management

These tools let your AI client perform every core function of a PostgreSQL DBA—from creating new projects to setting up endpoints and managing users—all programmatically.

create019d845e

create branch

Clones a full, isolated PostgreSQL branch instantly from an existing parent branch in the project.

create019d845e

create database

Creates and registers a new database within a specific Neon branch using the name you provide.

create019d845e

create endpoint

Provisions either a read-write or read-only compute host for your selected Neon branch.

create019d845e

create project

Sets up an entirely new, scoped Neon project workspace and automatically provisions the initial default resources within it.

create019d845e

create role

Creates a new database user role (and auto-generates its password) for secure access to a specific branch.

delete019d845e

delete branch

Permanently destroys all data and resources associated with a specified Neon branch. Use this carefully.

delete019d845e

delete project

Deletes an entire Neon project, wiping out all associated branches, databases, and infrastructure (Note: Data is recoverable for 7 days).

get019d845e

get branch

Fetches specific details about a single existing branch within a given project.

get019d845e

get connection uri

Generates the complete, ready-to-use PostgreSQL connection URI for any specified Neon project or primary branch.

get019d845e

get project

Retrieves all metadata and details about a specific Neon project ID.

list019d845e

list branches

Lists every existing, isolated PostgreSQL branch within the current Neon project workspace.

list019d845e

list databases

Queries and lists all databases present in a specific Neon branch scope.

list019d845e

list endpoints

Lists all compute endpoints for a given branch, noting their type (read-only/write) and status.

list019d845e

list projects

Provides an overview of every Neon project workspace you have access to.

list019d845e

list roles

Displays all defined database user roles and their associated privilege metadata within a branch.

set019d845e

set primary branch

Designates one existing branch as the default or primary source for future cloning operations in the project.

update019d845e

update project

Changes only the human-readable name of a Neon project; it does not affect any underlying resources like branches or databases.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with Neon, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

You gotta know this server. It lets your AI client handle every single piece of complex Postgres infrastructure without you even touching a dashboard. You run it straight from chat, treating your agent like a dedicated DBA that knows Neon inside and out.

🛠️ Setting Up Your Environment

When you need to scope out a whole new workspace, use create_project to set up an entirely scoped Neon project. This process automatically provisions the initial default resources, including necessary branches, databases, and read-write endpoints for that region and Postgres version. If you ever just need to change the name of the project—say, it was 'Test' but now it's 'Production v2'—you can use update_project to adjust only the human-readable label; this move won't mess with any underlying resources like your branches or databases.

To see what projects are available, you'll run list_projects, and if you need full metadata on one specific workspace, you fetch it using get_project. If things get messy and you gotta wipe the slate clean, delete_project vaporizes the entire Neon project, wiping out all associated branches, databases, and infrastructure—remember, the data is recoverable for seven days.

🌿 Branching and Database Management

For development work, list_branches shows you every isolated branch currently hanging around in your workspace. To get details on one specific branch, run get_branch. The core feature here is create_branch; this tool instantly clones a full, isolated PostgreSQL branch from any existing parent branch, giving you immediate isolation for whatever development task you're tackling.

If you need to designate the main source of truth for future cloning operations, use set_primary_branch.

When it comes to databases inside a project, you first list everything with list_databases, and if you need details on a specific branch, you can run get_connection_uri. To set up a new database within an existing Neon branch scope, simply use create_database and give it the name. For full visibility into what databases exist where, list_databases does the heavy lifting.

🔗 Connection Strings and Endpoints

Connecting your app is straightforward. Run get_connection_uri to grab a complete, ready-to-use PostgreSQL connection URI for any specified project or primary branch. For connectivity endpoints, first check what's available using list_endpoints. To provision compute access, use create_endpoint; this tool lets you set up either a read-write host—perfect for testing data changes—or a read-only host—ideal for analytics replication—for your selected Neon branch.

🔑 Security and Access Control

If you're dealing with credentials, the server handles it. To establish new user access, create_role generates a brand-new database user role and automatically creates its secure password, giving you ownership over those necessary resources. You can check who has rights by running list_roles, which displays all defined database user roles along with their specific privilege metadata within a branch.

These tools give your agent full control over securing access for development teams.

🗑️ Cleanup and Deletion

If you're done with a particular feature environment, don't just delete the data manually; use delete_branch to permanently destroy all associated resources from a specified Neon branch. Be careful here—that action is irreversible for the data itself. You can also list endpoints using list_endpoints and manage them via the other creation tools.

This server gives your agent full command over the entire Postgres lifecycle, letting you move from project scoping to connection URI generation without ever leaving the chat window.

How Neon MCP Works

  1. 1 First, you subscribe to the Neon server and provide your API key.
  2. 2 Next, you prompt your AI agent with a complex request (e.g., 'I need a dev branch for feature X').
  3. 3 The agent runs the necessary tools (create_branch, list_endpoints, etc.) sequentially and returns actionable data like the connection URI.

The bottom line is, your AI client talks directly to Neon's API, allowing you to execute multi-step database operations through simple conversation.

Who Is Neon MCP For?

This server is for the developer who doesn't want to leave their IDE. It’s for the DevOps engineer tired of navigating 10 different dashboards just to audit a single environment. If managing Postgres infrastructure involves copying and pasting credentials or running multiple CLI commands, you need this.

Backend Developer

You use it to instantly provision isolated development branches (create_branch) for feature testing and get the required connection URI without leaving your code editor.

DevOps Engineer

You audit project configurations by listing all endpoints or managing branch lifecycles across CI/CD pipelines using tools like list_endpoints and set_primary_branch.

Database Administrator (DBA)

You manage the security layer, creating new roles (create_role) and overseeing database structure across multiple isolated projects using conversational prompts.

What Changes When You Connect

  • No more console clicking. You get connection URIs directly using get_connection_uri, which is a massive time saver when setting up local dev environments.
  • Instant isolation via create_branch. You can spin up a clean feature branch from main in seconds, perfect for testing without ever polluting the primary environment.
  • Better security management. Use create_role to set up specific users and roles immediately, ensuring every connection has defined boundaries.
  • Auditability is easy. Listing everything with list_endpoints or list_databases lets you see the entire state of a project without deep diving into multiple tabs.
  • Full lifecycle control. From initial scoping (create_project) to cleanup (delete_project), manage every resource in one conversation flow.

Real-World Use Cases

01

Starting a New Service Feature

A developer needs to test an authentication fix without touching the live staging data. They prompt their agent: 'Create a branch called auth-test from primary, then give me its connection URI.' The agent runs create_branch and get_connection_uri, solving the problem in two steps instead of manually cloning in the dashboard and copying credentials.

02

Auditing Production Dependencies

A DevOps engineer needs to verify if a specific service is using an up-to-date compute endpoint. They ask: 'List all endpoints for the analytics project.' The agent runs list_endpoints and reports the status, allowing the engineer to confirm scaling or access issues immediately.

03

Onboarding a New Team Member

A DBA needs to set up a dedicated environment for training. They use create_project to scope the new workspace and then use create_role to provision specific, limited user access for the new team member—all without leaving their terminal.

04

Preparing for Disaster Recovery

The team needs a clean snapshot of core data. They prompt: 'Clone the main project now.' The agent runs create_branch, giving them an immediate, isolated copy (the new branch) ready to be reviewed or restored.

The Tradeoffs

The Console Deep Dive

Going into the Neon dashboard. Clicking 'Branches,' then clicking 'Create Branch.' Then switching tabs to 'Endpoints' and copying the URI. This takes five minutes and involves three different views.

Just tell your agent: 'I need a feature branch called X, cloned from primary, with its endpoints and connection URI ready.' The agent runs create_branch, then list_endpoints, and finally get_connection_uri in sequence. It's faster, cleaner, and less error-prone.

Manual Credential Management

Creating a user, noting the auto-generated password on one screen, then having to paste that password into an external environment file or script.

Use create_role and have your agent confirm the role details. Then immediately follow up with 'Give me the connection URI for this new role.' This keeps all credentials scoped and contained in the chat history.

When It Fits, When It Doesn't

Use this MCP Server if your core workflow involves managing Postgres state transitions (branching, roles, endpoints) and you want to avoid repetitive console navigation. It's perfect for Dev/Ops teams who work natively within an IDE or terminal environment.

However, don't use it if your only need is simple monitoring; just reading the current list of projects via list_projects might be enough. More importantly, this server manages infrastructure, not application logic. If you need to write data transformation scripts or complex SQL queries that aren't tied to resource management (like listing schemas), use a dedicated database client tool instead. The boundary is clear: Neon handles the plumbing; your code handles the business logic.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Neon. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 17 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

create_branch create_database create_endpoint create_project create_role delete_branch delete_project get_branch get_connection_uri get_project list_branches list_databases list_endpoints list_projects list_roles set_primary_branch update_project

Managing Postgres infrastructure shouldn't feel like running through an outdated wizard.

Today, setting up a simple isolated environment means logging into the console. You manually navigate to 'Branches,' select a parent, and click 'Clone.' Then you switch views, check if the read-write endpoint exists, and finally copy that URI out so your local machine can talk to it. It's clicks, tabs, and context switching.

With this MCP Server, you just ask for it. Your agent handles the multi-step process: creating the branch (`create_branch`), verifying the endpoints (`list_endpoints`), and returning the full connection string (`get_connection_uri`)—all in one chat response.

Neon MCP Server: Get your project wired up, fast.

The manual steps that vanish? The initial scoping process. You no longer need to create a project, then remember the ID, then go back later to manage databases and endpoints separately. Everything is scoped together from the start using `create_project`.

What's different now is efficiency. Your agent manages the dependency chain for you. It knows that creating a database requires an existing branch, so it handles the order of operations—you just tell it what job needs doing.

Common Questions About Neon MCP

How do I create a Neon API Key? +

Log in to the Neon Console, go to Account Settings > API Keys (or Organization Settings > API Keys), click Create New, choose the scope (Personal, Organization or Project-scoped), and copy the token immediately — it is shown only once.

What is a Neon branch and how does branching work? +

A Neon branch is an isolated PostgreSQL environment with its own compute, databases and roles. Branches are created instantly using copy-on-write cloning from a parent branch (default: primary). This means zero data copy and instant provisioning. Each branch gets its own compute endpoints and can have different PostgreSQL schemas and data.

Can I get a ready-to-use connection URI? +

Yes! Use the get_connection_uri tool with your project_id and optionally a branch_id. It returns a complete PostgreSQL connection string (postgres://user:password@host/dbname) ready to use with psql, ORMs or application clients.

Can the agent delete projects and branches? +

Yes, the agent has tools to delete both projects and branches. Deleting a project marks it for recovery (7-day grace period) but destroys all associated data. Deleting a branch is irreversible and removes all its databases, roles and endpoints. Use caution when executing these actions.

What details can the agent set using the `create_project` tool? +

The agent allows you to specify a human-readable name, AWS region, and PostgreSQL version when running this tool. These parameters let you define the foundational scope of your new Neon project.

What is the difference between read-write and read-only endpoints using `create_endpoint`? +

The agent provisions two types: 'read_write' for full access, which lets applications modify data. 'Read_only' creates replicas that allow querying without risk of accidental modification.

What happens when I use the `create_role` tool? +

It generates a new database role (user) and an auto-generated password, which you can use to control access. You must provide the project ID and branch ID for it to function.

How does the agent scope my query when I use `list_databases`? +

The agent requires both the project ID and the branch ID to list databases accurately. This ensures that you only see metadata from the specific environment you intend to manage.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 17 tools

We've already built the connector for Neon. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 17 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.