MCP DB Analyzer

Servidor MCP de análise multi-banco de dados (PostgreSQL, MySQL, SQLite). Inspeciona esquemas, detecta problemas de índice, analisa inchaço de tabelas e explica planos de consulta para otimização acionável de banco de dados.

GitHub

Documentação

MCP DB Analyzer

Um servidor Model Context Protocol (MCP) que dá aos assistentes de IA visibilidade profunda em seus bancos de dados. Ele inspeciona esquemas, detecta problemas de índices, analisa inchaço/fragmentação de tabelas e explica planos de consulta — para que sua IA possa dar conselhos acionáveis de otimização de banco de dados em vez de sugestões genéricas.

Suporta PostgreSQL, MySQL e SQLite.

Por que Esta Ferramenta?

Existem dezenas de servidores MCP de banco de dados — a maioria são gateways CRUD (executam consultas, listam tabelas). Esta ferramenta analisa seu banco de dados: problemas de esquema, índices ausentes, tabelas inchadas, consultas lentas, saúde do vacuum.

Outros servidores MCP analíticos (CrystalDBA, pg-dash, MCP-PostgreSQL-Ops) cobrem apenas PostgreSQL. MCP DB Analyzer é o único servidor MCP analítico que suporta PostgreSQL, MySQL e SQLite em uma única instalação npx — sem Python, sem Go, sem Docker.

Recursos

9 ferramentas MCP para análise abrangente de banco de dados
Suporte a PostgreSQL + MySQL + SQLite via flag --driver
Somente leitura por design — todas as consultas envolvidas em transações READ ONLY
Saída em Markdown otimizada para consumo por LLM
Zero configuração — basta definir DATABASE_URL

Nível Pro

Gere relatórios de diagnóstico exportáveis (HTML + PDF) com uma chave de licença Pro.

Relatório completo de análise de thread dump JVM com recomendações acionáveis
Exportação em PDF para compartilhar com sua equipe
Suporte prioritário

US$ 9,00/mês — Obter Licença Pro

A chave de licença Pro ativa a ferramenta MCP generate_report no mcp-jvm-diagnostics.

Instalação

npx mcp-db-analyzer

Ou instale globalmente:

npm install -g mcp-db-analyzer

Configuração

Defina a variável de ambiente DATABASE_URL:

export DATABASE_URL="postgresql://user:password@localhost:5432/mydb"

Ou use variáveis PG individuais: PGHOST, PGPORT, PGDATABASE, PGUSER, PGPASSWORD.

MySQL

Defina DATABASE_URL com uma string de conexão MySQL e passe --driver mysql:

export DATABASE_URL="mysql://user:password@localhost:3306/mydb"
mcp-db-analyzer --driver mysql

Ou use variáveis MySQL individuais: MYSQL_HOST, MYSQL_PORT, MYSQL_DATABASE, MYSQL_USER, MYSQL_PASSWORD.

Você também pode definir DB_DRIVER=mysql como variável de ambiente em vez de passar a flag.

SQLite

Passe um caminho de arquivo via DATABASE_URL e use --driver sqlite:

export DATABASE_URL="/path/to/database.db"
mcp-db-analyzer --driver sqlite

Claude Desktop (PostgreSQL)

Adicione a ~/.claude/claude_desktop_config.json:

{
  "mcpServers": {
    "db-analyzer": {
      "command": "npx",
      "args": ["-y", "mcp-db-analyzer"],
      "env": {
        "DATABASE_URL": "postgresql://user:password@localhost:5432/mydb"
      }
    }
  }
}

Claude Desktop (MySQL)

{
  "mcpServers": {
    "db-analyzer": {
      "command": "npx",
      "args": ["-y", "mcp-db-analyzer", "--driver", "mysql"],
      "env": {
        "DATABASE_URL": "mysql://user:password@localhost:3306/mydb"
      }
    }
  }
}

Claude Desktop (SQLite)

{
  "mcpServers": {
    "db-analyzer": {
      "command": "npx",
      "args": ["-y", "mcp-db-analyzer", "--driver", "sqlite"],
      "env": {
        "DATABASE_URL": "/path/to/database.db"
      }
    }
  }
}

Demonstração Rápida

Depois de configurado, experimente estes prompts no Claude:

"Mostre-me o esquema e como as tabelas estão relacionadas" — Retorna estruturas de tabelas, chaves estrangeiras e identifica tabelas órfãs
"Há alguma consulta lenta ou índices ausentes?" — Classifica consultas lentas por tempo de execução e sugere índices a adicionar
"Quantas conexões estão ativas? Alguma consulta está bloqueada?" — Mostra utilização do pool de conexões, sessões ociosas em transação e consultas bloqueadas

Ferramentas

`inspect_schema`

Liste todas as tabelas com contagens de linhas e tamanhos, ou aprofunde-se nas colunas, tipos, restrições e chaves estrangeiras de uma tabela específica.

Parâmetros:

table (opcional) — Nome da tabela a inspecionar. Omita para listar todas as tabelas.
schema (padrão: "public") — Esquema do banco de dados.

> inspect_schema

## Tables in schema 'public'

| Table       | Rows (est.) | Total Size |
|-------------|-------------|------------|
| users       | 12,450      | 3.2 MB     |
| orders      | 89,100      | 18.4 MB    |
| order_items | 245,000     | 12.1 MB    |

> inspect_schema table="users"

## Table: public.users

- **Rows (est.)**: 12,450
- **Total size**: 3.2 MB

### Columns
| # | Column | Type          | Nullable | Default |
|---|--------|---------------|----------|---------|
| 1 | id     | integer       | NO       | nextval |
| 2 | email  | varchar(255)  | NO       | -       |
| 3 | name   | varchar(100)  | YES      | -       |

`analyze_indexes`

Encontre índices não utilizados que desperdiçam espaço em disco e índices ausentes que causam varreduras sequenciais lentas. Também detecta chaves estrangeiras sem índice.

Parâmetros:

schema (padrão: "public") — Esquema do banco de dados.
mode ("usage" | "missing" | "all", padrão: "all") — Modo de análise.

> analyze_indexes

### Unused Indexes (2 found)
| Table | Index              | Size   | Definition                    |
|-------|--------------------|--------|-------------------------------|
| users | idx_users_legacy   | 1.2 MB | CREATE INDEX ... (old_col)    |

### Unindexed Foreign Keys (1 found)
| Table       | Column  | FK →   | Constraint        |
|-------------|---------|--------|-------------------|
| order_items | user_id | users  | fk_items_user_id  |

`explain_query`

Execute EXPLAIN em uma consulta SQL e obtenha um plano de execução formatado com estimativas de custo, tipos de nó e avisos de otimização. Opcionalmente, execute EXPLAIN ANALYZE para tempos reais (apenas consultas SELECT).

Parâmetros:

sql — A consulta SQL a ser explicada.
analyze (padrão: false) — Executar EXPLAIN ANALYZE (executa a consulta; apenas SELECT).

> explain_query sql="SELECT * FROM orders WHERE status = 'pending'"

## Query Plan Analysis

- **Estimated Total Cost**: 1234.56
- **Estimated Rows**: 500

### Plan Tree
→ Seq Scan on orders (cost=0..1234.56 rows=500)
  Filter: (status = 'pending')

### Potential Issues
- **Sequential Scan** on `orders` (~500 rows). Consider adding an index.

`analyze_table_bloat`

Analise o inchaço de tabelas verificando proporções de tuplas mortas, histórico de vacuum e tamanhos de tabela. Recomenda VACUUM ANALYZE para tabelas com >10% de tuplas mortas.

Parâmetros:

schema (padrão: "public") — Esquema do banco de dados.

> analyze_table_bloat

### Tables Needing VACUUM (1 found)
| Table     | Live Tuples | Dead Tuples | Bloat % | Size  | Last Vacuum |
|-----------|-------------|-------------|---------|-------|-------------|
| audit_log | 8,000       | 2,000       | 20.0%   | 10 MB | Never       |

### Recommended Actions
VACUUM ANALYZE public.audit_log;

`suggest_missing_indexes`

Encontre tabelas com altas contagens de varredura sequencial e zero uso de índice, referenciadas cruzadamente com índices não utilizados que desperdiçam espaço. Fornece recomendações acionáveis de CREATE INDEX e DROP INDEX.

Parâmetros:

schema (padrão: "public") — Esquema do banco de dados.

> suggest_missing_indexes

### Tables Missing Indexes (1 found)
| Table  | Seq Scans | Index Scans | Rows   | Size  |
|--------|-----------|-------------|--------|-------|
| events | 5,000     | 0           | 50,000 | 25 MB |

### Unused Indexes (1 found)
| Table | Index            | Size | Definition                       |
|-------|------------------|------|----------------------------------|
| users | idx_users_legacy | 8 kB | CREATE INDEX ... (legacy_col)    |

DROP INDEX public.idx_users_legacy;

`analyze_slow_queries`

Encontre as consultas mais lentas usando pg_stat_statements (PostgreSQL) ou performance_schema (MySQL). Mostra tempos de execução, contagens de chamadas e identifica candidatos a otimização.

Parâmetros:

schema (padrão: "public") — Esquema do banco de dados.
limit (padrão: 10) — Número de consultas lentas a retornar.

> analyze_slow_queries

## Slow Query Analysis (by avg execution time)

| # | Avg Time | Total Time | Calls | Avg Rows | Query |
|---|----------|------------|-------|----------|-------|
| 1 | 150.0ms  | 750000ms   | 5000  | 5        | `SELECT * FROM orders WHERE status = $1` |
| 2 | 200.0ms  | 40000ms    | 200   | 2        | `SELECT u.* FROM users u JOIN orders o...` |

### Recommendations
- **2 high-impact queries** — called >100 times with >100ms avg
- **2 queries returning few rows but slow** — likely missing indexes

`analyze_connections`

Analise conexões ativas do banco de dados. Detecta sessões ociosas em transação, consultas de longa duração, contenção de locks e utilização do pool de conexões. Apenas PostgreSQL e MySQL.

> analyze_connections

## Connection Analysis (PostgreSQL)

### Connection States
| State | Count |
|-------|-------|
| active | 3 |
| idle | 12 |
| idle in transaction | 2 |
| **Total** | **17** |

**Max connections**: 100
**Utilization**: 17.0%

### Idle-in-Transaction Connections
| PID  | User | Duration | Query |
|------|------|----------|-------|
| 1234 | app  | 00:05:30 | UPDATE orders SET status = $1 |

`analyze_table_relationships`

Analise relacionamentos de chaves estrangeiras entre tabelas. Constrói um grafo de dependências mostrando conectividade de entidades, tabelas órfãs (sem FKs), cadeias de exclusão em cascata e entidades centrais.

Parâmetros:

schema (padrão: "public") — Esquema do banco de dados.

> analyze_table_relationships

## Table Relationships

**Tables**: 5
**Foreign Keys**: 4

### Entity Connectivity
| Table | Incoming FKs | Outgoing FKs | Total |
|-------|-------------|-------------|-------|
| users **hub** | 5 | 0 | 5 |
| orders | 1 | 2 | 3 |

### Orphan Tables (no FK relationships)
- `audit_log`

### Cascading Delete Chains
- **users** → cascades to: orders, addresses
  - **orders** → further cascades to: order_items

`analyze_vacuum`

Analise o status de manutenção VACUUM do PostgreSQL. Verifica proporções de tuplas mortas, defasagem do vacuum, configuração de autovacuum e identifica tabelas que precisam de VACUUM manual. Apenas PostgreSQL.

> analyze_vacuum

Detecta:

Tabelas com altas proporções de tuplas mortas (>10% aviso, >20% crítico)
Tabelas nunca submetidas a vacuum ou análise
Autovacuum desabilitado globalmente
Problemas de configuração do autovacuum

A saída inclui:

Descobertas agrupadas por gravidade (CRITICAL / WARNING / INFO)
Tabelas que precisam de VACUUM com porcentagens de tuplas mortas
Histórico completo de vacuum por tabela
Configurações de autovacuum

Segurança

Todas as consultas são envolvidas em transações READ ONLY por padrão
EXPLAIN ANALYZE é restrito a consultas SELECT apenas
Declarações DDL/DML são rejeitadas no modo ANALYZE
Nenhuma consulta de modificação de dados é permitida

Contribuindo

Clone o repositório
npm install
npm run build — Compilação TypeScript
npm test — Execute testes unitários (vitest)
npm run dev — Modo de observação para desenvolvimento

Limitações e Problemas Conhecidos

Somente leitura: Todas as consultas usam conexões somente leitura. Não é possível modificar dados ou esquema.
pg_stat_statements necessário: A análise de consultas lentas no PostgreSQL requer que a extensão pg_stat_statements esteja instalada e carregada.
MySQL performance_schema: Estatísticas de uso de índice e varredura exigem que performance_schema esteja habilitado (desativado por padrão em algumas instalações MySQL).
SQLite: Nenhuma estatística de uso de índice disponível (SQLite não rastreia isso). Análise de varredura sequencial e detecção de consultas lentas não são suportadas para SQLite.
Bancos de dados grandes: A inspeção de esquema em bancos de dados com 500+ tabelas pode produzir saída muito longa. Use o parâmetro schema para limitar o escopo.
Parametrização de nomes de tabela: Declarações PRAGMA do SQLite usam interpolação de strings para nomes de tabela (SQLite não suporta PRAGMAs parametrizados). Os nomes de tabela são obtidos da tabela do sistema sqlite_master.
Consultas entre bancos de dados: Não é possível analisar consultas que abrangem vários bancos de dados ou usam links de banco de dados.
Contagens de linhas estimadas: TABLE_ROWS do MySQL em information_schema é uma estimativa, não exata.
Escopo do esquema: Todas as ferramentas usam o esquema public por padrão. Esquemas não públicos exigem especificação explícita. A análise de múltiplos esquemas requer executar as ferramentas separadamente por esquema.
Análise de conexões: analyze_connections é apenas para PostgreSQL/MySQL. Não disponível para bancos de dados SQLite.
Análise de vacuum: analyze_vacuum é apenas para PostgreSQL. Para MySQL, use OPTIMIZE TABLE ou analyze_table_bloat.

Parte do MCP Java Backend Suite

mcp-spring-boot-actuator — Análise de saúde, métricas e beans do Spring Boot
mcp-jvm-diagnostics — Análise de thread dump e logs de GC
mcp-redis-diagnostics — Diagnósticos de memória, slowlog e clientes do Redis
mcp-migration-advisor — Análise de risco de migração Flyway/Liquibase

Licença

MIT

Fim de vida: 2026-05-10.

Este servidor MCP não é mais mantido ou distribuído. A Corporation mudou para atores do marketplace Apify. Veja irrationalways no Apify e irrcorp/bzp-poland-tenders para o trabalho atual da Corporation.

O pacote npm foi despublicado. O repositório está arquivado apenas para referência histórica.