Servidor MCP orientado a producción para PostgreSQL, que expone operaciones de base de datos a clientes MCP (Claude Desktop, VS Code Copilot, Cursor y hosts compatibles).
Ejecución de consultas (SELECT, INSERT, UPDATE, DELETE)
Descubrimiento de bases de datos e introspección de esquemas
Inspección de metadatos de tablas (columnas, tipos, nulabilidad, valores por defecto, PK)
Descubrimiento de índices y claves foráneas
Configuración basada en entorno para despliegue seguro
Related MCP server: Azure Database for PostgreSQL MCP Server
Herramienta | Descripción |
| Ejecuta una sentencia SQL y devuelve filas o el número de filas afectadas |
| Lista tablas desde |
| Devuelve metadatos de columnas de tabla y marcadores de clave primaria |
| Lista todas las bases de datos de PostgreSQL |
| Lista índices de tabla con definiciones y banderas PK/único |
| Lista claves foráneas de tabla y destinos referenciados |
Node.js 18+
Acceso a una instancia de PostgreSQL
Conectividad de red desde el host MCP a PostgreSQL (host:puerto)
Configure los ajustes de conexión usando variables de entorno:
Variable | Requerida | Por defecto | Descripción |
| No |
| Host o IP de PostgreSQL |
| No |
| Puerto TCP de PostgreSQL |
| No |
| Base de datos por defecto |
| Sí | — | Usuario de la base de datos |
| Sí | — | Contraseña de la base de datos |
| No |
| Habilita SSL/TLS |
| No |
| Máximo de conexiones del pool |
| No |
| Tiempo de espera de inactividad del pool (ms) |
| No |
| Modo de transporte: |
| No |
| Puerto para el servidor HTTP (solo se usa cuando |
| No |
| Dirección de enlace para el servidor HTTP (solo se usa cuando |
npx github:ferronicardoso/mcp-postgresqlclaude mcp add postgresql --scope user -- npx -y github:ferronicardoso/mcp-postgresql--scope controla dónde se almacena el registro del servidor:
Ámbito | Almacenado en | Visible para |
| local al proyecto, sin seguimiento | solo para ti, solo en este proyecto |
|
| cualquiera que clone el repositorio (haz commit para compartir) |
| tu configuración global de Claude Code | para ti, en todos los proyectos |
Las variables de entorno se pueden pasar con banderas repetidas --env CLAVE=VALOR antes de --, por ejemplo:
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-postgresqlEsto registra el servidor en ~/.codex/config.toml. Para eliminarlo, ejecuta 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"
}
}
}
}La imagen publicada se ejecuta en modo HTTP Streamable por defecto, para usar como endpoint MCP remoto (por ejemplo, desde el nodo Cliente MCP de n8n o cualquier cliente compatible con HTTP Streamable):
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:latestEl endpoint MCP está disponible en http://localhost:3002/mcp.
git clone https://github.com/ferronicardoso/mcp-postgresql
cd mcp-postgresql
npm install
npm run buildInicia el servidor compilado:
npm startEste repositorio rastrea intencionalmente dist/ para soportar el uso de npx github:usuario/repo.
El proyecto utiliza un hook pre-commit de Husky para:
compilar TypeScript (npm run build)
preparar los artefactos generados (git add dist)
Alternativa manual:
npm run build
git add distNunca hagas commit de credenciales reales o archivos .env.
Prefiere usuarios de base de datos con mínimos privilegios para uso en producción.
Para redes públicas o no confiables, habilita el cifrado (PGSSL=true) y configura los certificados adecuadamente.
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
