프로덕션 지향적인 PostgreSQL용 MCP 서버로, MCP 클라이언트(Claude Desktop, VS Code Copilot, Cursor 및 호환 호스트)에 데이터베이스 작업을 노출합니다.
쿼리 실행 (SELECT, INSERT, UPDATE, DELETE)
데이터베이스 검색 및 스키마 분석
테이블 메타데이터 검사 (열, 유형, null 허용 여부, 기본값, PK)
인덱스 및 외래 키 검색
안전한 배포를 위한 환경 변수 기반 구성
Related MCP server: Azure Database for PostgreSQL MCP Server
도구 | 설명 |
| SQL 문을 실행하고 행 또는 영향받은 행 수를 반환합니다 |
|
|
| 테이블 열 메타데이터와 기본 키 표시를 반환합니다 |
| 모든 PostgreSQL 데이터베이스를 나열합니다 |
| 정의 및 PK/고유 플래그와 함께 테이블 인덱스를 나열합니다 |
| 테이블 외래 키와 참조 대상을 나열합니다 |
Node.js 18+
PostgreSQL 인스턴스에 대한 액세스
MCP 호스트에서 PostgreSQL(host:port)까지의 네트워크 연결
환경 변수를 사용하여 연결 설정을 구성합니다:
변수 | 필수 | 기본값 | 설명 |
| 아니오 |
| PostgreSQL 호스트 또는 IP |
| 아니오 |
| PostgreSQL TCP 포트 |
| 아니오 |
| 기본 데이터베이스 |
| 예 | — | 데이터베이스 사용자 |
| 예 | — | 데이터베이스 비밀번호 |
| 아니오 |
| SSL/TLS 활성화 |
| 아니오 |
| 최대 풀 연결 수 |
| 아니오 |
| 풀 유휴 시간 초과 (ms) |
| 아니오 |
| 전송 모드: |
| 아니오 |
| 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 Client Tool 노드 또는 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이 저장소는 npx github:user/repo 사용을 지원하기 위해 의도적으로 dist/를 추적합니다.
프로젝트는 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
