面向生产环境的 MCP 服务器 for PostgreSQL，将数据库操作暴露给 MCP 客户端（Claude Desktop、VS Code Copilot、Cursor 和兼容的主机）。
查询执行（SELECT、INSERT、UPDATE、DELETE）
数据库发现与模式自省
表元数据检查（列、类型、可空性、默认值、主键）
索引与外键发现
环境驱动配置，确保安全部署
Related MCP server: Azure Database for PostgreSQL MCP Server
工具 | 描述 |
| 执行 SQL 语句并返回行数或受影响的行数 |
| 从 |
| 返回表列元数据及主键标记 |
| 列出所有 PostgreSQL 数据库 |
| 列出表索引，包含定义及主键/唯一标志 |
| 列出表外键及引用的目标 |
Node.js 18 及以上
能够访问 PostgreSQL 实例
MCP 主机到 PostgreSQL 的网络连接（host:port）
使用环境变量设置连接参数：
变量 | 必填 | 默认值 | 描述 |
| 否 |
| PostgreSQL 主机或 IP |
| 否 |
| PostgreSQL TCP 端口 |
| 否 |
| 默认数据库 |
| 是 | — | 数据库用户 |
| 是 | — | 数据库密码 |
| 否 |
| 启用 SSL/TLS |
| 否 |
| 最大连接池连接数 |
| 否 |
| 连接池空闲超时（毫秒） |
| 否 |
| 传输模式： |
| 否 |
| HTTP 服务器端口（仅当 |
| 否 |
| HTTP 服务器绑定地址（仅当 |
npx github:ferronicardoso/mcp-postgresqlclaude mcp add postgresql --scope user -- npx -y github:ferronicardoso/mcp-postgresql--scope 控制服务器注册的存储位置：
作用域 | 存储位置 | 可见范围 |
| 项目本地，未跟踪 | 仅你自己，仅在此项目中 |
| 项目根目录下的 | 任何克隆该仓库的人（提交以共享） |
| 你的全局 Claude Code 配置 | 你，跨所有项目 |
环境变量可以通过在 -- 前重复 --env KEY=VALUE 标志传递，例如：
Bash（Linux/macOS/WSL）：
claude mcp add postgresql --scope user \
--env PGHOST=localhost \
--env PGPORT=5432 \
--env PGDATABASE=postgres \
--env PGUSER=postgres \
--env PGPASSWORD=your-password \
-- npx -y github:ferronicardoso/mcp-postgresqlPowerShell：
claude mcp add postgresql --scope user `
--env PGHOST=localhost `
--env PGPORT=5432 `
--env PGDATABASE=postgres `
--env PGUSER=postgres `
--env PGPASSWORD=your-password `
-- npx -y github:ferronicardoso/mcp-postgresqlBash（Linux/macOS/WSL）：
codex mcp add postgresql \
--env PGHOST=localhost \
--env PGPORT=5432 \
--env PGDATABASE=postgres \
--env PGUSER=postgres \
--env PGPASSWORD=your-password \
npx -- -y github:ferronicardoso/mcp-postgresqlPowerShell：
codex mcp add postgresql `
--env PGHOST=localhost `
--env PGPORT=5432 `
--env PGDATABASE=postgres `
--env PGUSER=postgres `
--env PGPASSWORD=your-password `
npx -- -y github:ferronicardoso/mcp-postgresql这将注册服务器到 ~/.codex/config.toml。要移除，运行 codex mcp remove postgresql。
%APPDATA%\\Claude\\claude_desktop_config.json：
{
"mcpServers": {
"postgresql": {
"command": "npx",
"args": ["github:ferronicardoso/mcp-postgresql"],
"env": {
"PGHOST": "localhost",
"PGPORT": "5432",
"PGDATABASE": "postgres",
"PGUSER": "postgres",
"PGPASSWORD": "your-password"
}
}
}
}.vscode/mcp.json：
{
"servers": {
"postgresql": {
"command": "npx",
"args": ["github:ferronicardoso/mcp-postgresql"],
"env": {
"PGHOST": "localhost",
"PGPORT": "5432",
"PGDATABASE": "postgres",
"PGUSER": "postgres",
"PGPASSWORD": "your-password"
}
}
}
}发布的镜像默认以 Streamable HTTP 模式运行，用作远程 MCP 端点（例如从 n8n 的 MCP 客户端工具节点或任何兼容 Streamable HTTP 的客户端）：
Bash（Linux/macOS/WSL）：
docker run -d --name mcp-postgresql \
-p 3002:3002 \
-e PGHOST=host.docker.internal \
-e PGPORT=5432 \
-e PGDATABASE=postgres \
-e PGUSER=postgres \
-e PGPASSWORD=your-password \
ghcr.io/ferronicardoso/mcp-postgresql:latestPowerShell：
docker run -d --name mcp-postgresql `
-p 3002:3002 `
-e PGHOST=host.docker.internal `
-e PGPORT=5432 `
-e PGDATABASE=postgres `
-e PGUSER=postgres `
-e PGPASSWORD=your-password `
ghcr.io/ferronicardoso/mcp-postgresql:latest然后 MCP 端点可通过 http://localhost:3002/mcp 访问。
git clone https://github.com/ferronicardoso/mcp-postgresql
cd mcp-postgresql
npm install
npm run build启动编译后的服务器：
npm start本仓库有意跟踪 dist/ 以支持 npx github:user/repo 的使用。
项目使用 Husky 的 pre-commit 钩子来：
构建 TypeScript（npm run build）
暂存生成的工件（git add dist）
手动回退：
npm run build
git add dist切勿提交真实凭据或 .env 文件。
生产环境优先使用最小权限数据库用户。
对于公共或不受信任的网络，启用加密（PGSSL=true）并适当配置证书。
MIT © Raphael Augusto Ferroni Cardoso
Returns table structure: columns, types, nullability, defaults, and PK markers.
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Table name | |
| schema | No | Table schema (default: public) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It clearly indicates a read operation ('Returns') with no destructive behavior, but lacks explicit mention of read-only nature, idempotency, or performance implications. Adequate but could be more explicit.
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?
A single sentence that front-loads the purpose and includes specific output elements. Every word adds value, and there is no redundancy or 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 tool with two parameters and no output schema, the description sufficiently explains the return value and implies the parameters. It is complete given the tool's complexity and the context provided by sibling tools.
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 coverage is 100% with both parameters documented. The description adds value by specifying the output's constituents (columns, types, etc.), which goes beyond the parameter descriptions. However, it does not elaborate on parameter usage or constraints 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 tool's function with a specific verb ('Returns') and resource ('table structure'), and lists the components (columns, types, nullability, defaults, PK markers). It distinguishes from siblings like get_foreign_keys and get_table_indexes by focusing on overall table structure.
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?
No guidance is provided on when to use this tool versus alternatives like execute_query or get_foreign_keys. The description does not include context about when it's appropriate or when to choose another sibling tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Executes a SQL query in PostgreSQL and returns rows or affected row count.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | SQL query to execute |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description does not disclose potential side effects (e.g., write operations), required permissions, or error behavior. Only minimally mentions return type.
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, front-loaded with key action and result. No wasted words.
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 tool with one parameter and no output schema, description covers the return type but lacks guidance on error handling, result size, or constraints, leaving agents underinformed for critical execution tasks.
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 coverage is 100%, so the schema already documents the parameter. Description adds no extra meaning beyond restating that the query is SQL.
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?
Clearly states the action (execute), the resource (SQL query in PostgreSQL), and the result (rows or affected row count). Distinguishes from sibling introspection tools.
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?
Implies usage for arbitrary SQL execution but lacks explicit guidance on when to use vs alternatives, prerequisites, or safety warnings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Lists foreign keys of a table and their referenced targets.
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Table name | |
| schema | No | Table schema (default: public) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry the full burden. It only states the basic function without disclosing any side effects, performance implications, or error behavior.
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 sentence that conveys the essential information without any unnecessary words or repetitions.
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?
Given the lack of annotations and output schema, the description is minimal but covers the core purpose. However, it omits details like return format and potential edge cases, leaving room for improvement.
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 coverage is 100% for its two parameters, so the description adds no extra meaning. The baseline score of 3 is appropriate as it adequately documents parameters.
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 lists foreign keys of a table and includes the referenced targets, which is specific and distinct from sibling tools like describe_table or get_table_indexes.
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?
No guidance is provided on when to use this tool versus alternatives like describe_table, which may also show foreign keys. The description lacks context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Lists indexes for a table with index definition and PK/uniqueness flags.
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Table name | |
| schema | No | Table schema (default: public) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must disclose behavioral traits. It only says it lists indexes with certain details, but does not mention read-only nature, permissions, side effects, or other important behaviors.
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 sentence with no wasted words. It is front-loaded with the main action. However, it could be slightly more informative without being wordy.
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?
Given the simplicity (2 params, no output schema), the description lacks completeness. It does not explain the return format, pagination, or that the schema defaults to public, leaving the agent with many unknowns.
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%, so the base is 3. The description adds no additional meaning beyond the schema's parameter descriptions (e.g., table name, schema with default).
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 lists indexes for a table, with specific details about the output (index definition and PK/uniqueness flags). This differentiates it from sibling tools like describe_table or get_foreign_keys.
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?
No guidance on when to use this tool versus alternatives (e.g., describe_table, get_foreign_keys) or when not to use it. The description simply states what it does without providing context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Lists all PostgreSQL databases in the server.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description accurately states the tool's action but does not disclose any behavioral traits such as permission requirements, performance impact, or return value details. With no annotations, the description carries the full burden and provides only basic information.
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 sentence that efficiently conveys the tool's purpose. It is concise without being verbose, though it could be slightly more informative.
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?
Given the tool's simplicity (no parameters, no output schema, no annotations), the description provides sufficient context for an AI agent to understand its function. It could mention the listing scope but is otherwise complete.
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 tool has no parameters, and the description adds no additional semantics beyond the empty schema. This is appropriate for a parameterless tool, earning the baseline score of 4.
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 verb 'lists' and the resource 'all PostgreSQL databases', which uniquely identifies the tool's function. It distinguishes from siblings like 'list_tables' by specifying the database level.
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?
No guidance is provided on when to use this tool versus alternatives like 'list_tables' or 'describe_table'. There are no conditions for usage or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Lists tables in the current database, optionally filtered by schema.
| Name | Required | Description | Default |
|---|---|---|---|
| schema | No | Schema to filter (default: all non-system schemas) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits like whether system tables are excluded by default or pagination behavior. The filtering behavior is implied but not elaborated.
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, front-loaded sentence with no wasted words. It is efficient but could benefit from slight expansion on default behavior.
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 with a single optional parameter, the description is adequate but does not indicate the return format or default schema behavior beyond the parameter description. It is minimally viable.
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 coverage is 100% (one parameter), and the description does not add extra meaning beyond the schema's description. The baseline of 3 is appropriate since the schema already documents the parameter.
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 verb 'Lists' and the resource 'tables' with context 'in the current database' and optional schema filtering, distinguishing it from sibling tools like describe_table or execute_query.
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?
No explicit guidance on when to use this tool versus alternatives such as describe_table or list_databases. The description only mentions optional filtering without advising on use cases.
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.
v1.0.0describe_tableexecute_queryget_foreign_keysget_table_indexeslist_databaseslist_tablesScored across 6 tools
Each tool targets a distinct database operation: describe structure, run queries, list foreign keys, list indexes, list databases, and list tables. No overlap in functionality.
All tool names follow a consistent verb_noun pattern with underscores (e.g., describe_table, execute_query). No mixing of conventions.
With 6 tools, the set is well-scoped for a PostgreSQL server, covering essential schema exploration and query execution without being bloated.
Covers core introspection and querying, but lacks tools for DDL operations (create/alter/drop) or listing users/roles. Minor gap for power users.
Text-to-SQL MCP server: read-only queries on PostgreSQL, MySQL and SQL Server with your real schema
Xata MCP server lets AI agents interact with your Xata projects, and Postgres database branches.
MCP server for interacting with the Supabase platform
