4,500+ servers built on MCP Fusion
Vinkius

Neon MCP. Orchestrate your serverless Postgres infrastructure via AI.

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 (Serverless PostgreSQL) MCP on Cursor AI Code Editor MCP Client Neon (Serverless PostgreSQL) MCP on Claude Desktop App MCP Integration Neon (Serverless PostgreSQL) MCP on OpenAI Agents SDK MCP Compatible Neon (Serverless PostgreSQL) MCP on Visual Studio Code MCP Extension Client Neon (Serverless PostgreSQL) MCP on GitHub Copilot AI Agent MCP Integration Neon (Serverless PostgreSQL) MCP on Google Gemini AI MCP Integration Neon (Serverless PostgreSQL) MCP on Lovable AI Development MCP Client Neon (Serverless PostgreSQL) MCP on Mistral AI Agents MCP Compatible Neon (Serverless PostgreSQL) MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Neon (Serverless PostgreSQL) MCP Server manages your entire serverless Postgres stack through conversation. Spawn zero-copy branches for isolated testing, audit project resource usage, and provision new databases without touching the CLI.

It lets you manage connection endpoints, roles, and schemas by talking to your AI client.

What your AI agents can do

Create branch

Makes a zero-copy clone (Branch) of an existing PostgreSQL dataset for isolated testing queries.

Create project

Provisions and initializes an empty Neon Project Serverless Workspace.

Delete project

Permanently wipes out all data, connection strings, and physical storage for a complete Neon Postgres ecosystem.

+ 7 more capabilities included
Create isolated testing environments

Instantly clones the entire production dataset into a new, read-only branch (CoW) for safe feature testing.

Audit resource usage and connections

Retrieves detailed deployment metrics, storage caps, and active connection endpoints across all your projects.

Manage project lifecycles

Initializes brand new serverless workspaces or completely destroys existing database ecosystems with one command.

Identify schemas and users

Lists all internal SQL databases within a branch, plus enumerates every PostgreSQL user role for access control checks.

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 (Serverless PostgreSQL) MCP Server: 10 Tools for Infra Ops

These tools let your agent handle every stage of Postgres infrastructure management—from provisioning entire workspaces to cloning test branches and auditing user roles.

create019d75dc

create branch

Makes a zero-copy clone (Branch) of an existing PostgreSQL dataset for isolated testing queries.

create019d75dc

create project

Provisions and initializes an empty Neon Project Serverless Workspace.

delete019d75dc

delete project

Permanently wipes out all data, connection strings, and physical storage for a complete Neon Postgres ecosystem.

get019d75dc

get branch

Deconstructs the execution footprint of one specific database branch to see its history and changes.

get019d75dc

get project

Analyzes a core Neon Project ID, reporting on regional deployment metrics and storage caps.

list019d75dc

list branches

Lists all Copy-on-Write (CoW) branches linked to a specific project ID.

list019d75dc

list databases

Identifies internal SQL database schemas mapped inherently to a given branch, like 'main_db'.

list019d75dc

list endpoints

Discovers all active connection routing endpoints needed by your application drivers for the project.

list019d75dc

list projects

Lists every architectural Neon Serverless PostgreSQL Project you have set up.

list019d75dc

list roles

Extracts all active PostgreSQL user roles and identities operating on a specific branch.

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 (Serverless PostgreSQL), 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 connect your AI client to this Neon MCP Server, and you get full command over your whole serverless PostgreSQL stack through simple conversation. Forget running a dozen cryptic CLI commands—you just tell your agent what you need done.

This thing handles the heavy lifting for modern Postgres deployments: it lets you provision entire environments, clone them safely for testing, audit every connection point, and manage user roles without ever touching the terminal.

Project Lifecycle Management

To start a new workspace or clear out an old one, you don't need to mess with setup scripts. You can ask your agent to list_projects to see every architectural Neon Serverless PostgreSQL Project you've got running. If you need a brand-new blank slate, it runs create_project, provisioning and initializing an empty serverless workspace instantly.

When you’re done with a project—really done—you just tell it to use delete_project. That permanently wipes out all the data, connection strings, and physical storage for that entire Neon Postgres ecosystem.

Auditing Resources and Connectivity

You gotta know what you're running. You can ask your agent about a specific Project ID using get_project; it analyzes the core project and reports back detailed regional deployment metrics and storage caps. To figure out exactly which connection endpoints your application drivers need, you run list_endpoints, discovering all active routing points for that project.

If you're checking internal database structures, running list_databases shows you every inherent SQL schema mapped to a branch, like 'main_db'. You can also use list_roles to extract all current PostgreSQL user roles and identities operating on a specific branch, which is critical for access control checks.

Isolated Testing and Branching

The real time-saver here is branching. When you need to test something risky, you don't mess with production data. You just ask your agent to create_branch, which makes a zero-copy clone (a CoW branch) of the entire live dataset. This gives you a safe, isolated environment for feature testing queries.

If you have multiple clones running, you can use list_branches to see every Copy-on-Write branches tied to your project ID. Need to know what changed in one specific clone? You tell it to run get_branch. It deconstructs the execution footprint of that single database branch, showing you its history and changes.

Inventory and Schema Deep Dive

When you're deep into a project, you can check out every internal SQL database schema mapped inherently to a given branch using list_databases, and if you need to audit who has access, the agent runs list_roles to enumerate all active PostgreSQL user roles.

This server takes the complexity of managing Postgres infrastructure—the kind of job that used to take hours running sequences of terminal commands—and boils it down. You just talk to your AI client, and it handles the provisioning, cloning, auditing, and tearing down for you.

How Neon MCP Works

  1. 1 Subscribe to this server on Vinkius and provide your Neon API Key.
  2. 2 Connect your preferred AI client (Claude, Cursor, etc.) to the MCP Server.
  3. 3 Ask your agent directly: 'I need a new feature branch for user auth.' The agent runs create_branch and provides the new connection endpoint.

The bottom line is that you talk to your AI client about infrastructure problems, and it executes the necessary Neon API calls for you.

Who Is Neon MCP For?

This server is for engineers who spend too much time clicking through cloud dashboards or writing complex CI/CD scripts just to test a database change. It's for the person tired of running npx neon-cli --project staging and having it fail because they forgot one flag.

Backend Developer

Needs to spin up an isolated testing branch (create_branch) from main, run a few queries, verify the schema, and then delete the test environment.

Database Administrator (DBA)

Uses get_project and list_roles to audit storage consumption caps across multiple projects and ensure roles only have minimum necessary permissions.

Platform Engineer

Manages the lifecycle of entire services by running create_project or performing irreversible cleanup with delete_project.

What Changes When You Connect

  • Audit data changes instantly. Instead of manually checking logs, use get_branch to deconstruct the execution footprint and see exactly when a branch split from its parent.
  • Manage connections without guessing endpoints. Use list_endpoints to discover all live connection routing URLs required by your app drivers—no more manual network checks.
  • Scale testing safely. With create_branch, you can clone petabytes of production data instantly, giving developers a risk-free sandbox for feature work.
  • Control the entire environment. Use list_projects to see all workspaces and get_project to check regional storage caps before provisioning more resources.
  • Maintain security boundaries. Run list_roles to list every active PostgreSQL user identity, ensuring nobody has too much access on a specific branch.

Real-World Use Cases

01

Testing a major feature rollout

A developer needs to test changes against production data without impacting live users. They ask their agent: 'Create a test branch called 'feat-billing' from main.' The agent runs create_branch, gives them the new endpoint, and they work in isolation.

02

Cleaning up old environments

The Platform Engineer finished a proof-of-concept project that is no longer needed. They use list_projects to find the ID, confirm it's safe, and run delete_project. The entire ecosystem vanishes instantly.

03

Debugging connectivity issues

The application fails with an unknown connection error. A DBA asks their agent to 'List all endpoints for my main project.' The agent runs list_endpoints and provides the precise, active connection string needed for the driver.

04

Auditing user permissions

Before deploying a new service, an engineer needs to know what roles exist. They ask the agent to 'List all roles on the staging branch.' The agent runs list_roles, preventing potential privilege escalation issues.

The Tradeoffs

Manual CLI scripting for branching

Running a complex sequence of local Neon commands (e.g., neon branch create --source=main-db). This is slow, error-prone, and requires managing API keys locally.

Just tell your agent: 'Create a new feature branch called X from the main source.' The agent handles the create_branch call entirely via the MCP Server.

Copy/pasting connection strings

A dev copies an endpoint URL from one dashboard and tries it in another service, leading to runtime failures because the ID or region is wrong.

Use list_endpoints to get a guaranteed, active list of all necessary connections for your project. The agent handles the copy/paste.

Forgetting environment context

Running cleanup commands against the wrong workspace or accidentally wiping out the production database instead of a test sandbox.

Always run list_projects first to confirm which project ID you are targeting. Then, use targeted tools like delete_project only when absolutely necessary.

When It Fits, When It Doesn't

Use this MCP Server if your job involves managing the infrastructure of PostgreSQL—things like creating isolated test environments (create_branch), monitoring resource usage (get_project, list_endpoints), or provisioning/decommissioning entire database services. Don't use it, and stick to a standard SQL client, if you are only performing simple CRUD operations on an already configured, stable database. If your problem is just 'run SELECT * FROM users,' don't overcomplicate it; those tools are for infrastructure architects, not data consumers.

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 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

create_branch create_project delete_project get_branch get_project list_branches list_databases list_endpoints list_projects list_roles

Managing Postgres environments used to be a mess of CLIs and cloud console tabs.

Today, testing a new feature means jumping between the main database's dashboard, running local `neon` commands in your terminal, and then hoping you didn't accidentally point your staging environment at production. It’s tedious, it takes time, and one wrong flag can cost thousands.

With this MCP Server, you talk to your agent. You say, 'I need an isolated copy of the billing schema for testing.' The agent runs `create_branch`, gives you a dedicated endpoint URL, and hands over the keys—no manual scripting required.

Neon MCP Server: Manage Postgres projects, branches, and roles.

Manual project setup requires running multiple commands to provision the workspace, map endpoints, and set up initial role permissions. You're writing boilerplate code just for infrastructure scaffolding.

Now, you simply ask your agent to 'Set up a new staging environment.' It handles `create_project`, lists available roles via `list_roles`, and gives you the full, ready-to-use context instantly.

Common Questions About Neon MCP

How do I list all my serverless projects using list_projects? +

You simply ask your agent to run list_projects. It returns a list of every active Neon Serverless PostgreSQL Project ID you have set up across your account.

What is the difference between get_project and list_projects? +

list_projects gives you an index of all available projects. get_project lets you pick one specific project ID and analyze its core routing logic, storage caps, and regional metrics.

Can I use create_branch to test a schema change? +

Yes. Use create_branch first. This makes an instant zero-copy clone of your production data, giving you a safe, isolated space to run queries and verify the new schema without risk.

How do I check what roles are active on my test branch? +

Use list_roles. It runs against the specific branch ID you provide, giving you a clean list of every PostgreSQL user identity and role currently configured for that isolated environment.

What happens if I use the `delete_project` tool on a Neon workspace? +

It permanently wipes out the entire ecosystem. The command destroys all edge-served connection strings, severs active client connections, and evaporates physical NVMe-backed storage blocks.

How do I find the specific connection routing endpoints using `list_endpoints`? +

The tool discovers connection routing endpoints spanning your Neon project. You use these explicit endpoints in standard PgBouncer drivers to actively ingest real query traffic for an active branch.

What does the `list_databases` tool show me regarding my schemas? +

It enumerates internal SQL database schemas and catalog namespaces. This information is crucial for guiding your connection logic by identifying which schemas are inherently mapped to specific branches.

If I use `get_branch`, what kind of audit details can I retrieve? +

It reconstructs the execution footprint of a single branch. You track storage deltas and timeline points (LSN) to understand exactly when that specific branch split from its parent source.

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.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 10 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 10 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.