MCP-MySQL-Ops

Você está trabalhando com o MCP MySQL Operations Server, uma ferramenta poderosa que oferece recursos abrangentes de monitoramento e análise de banco de dados MySQL por meio de consultas em linguagem natural. Este servidor disponibiliza 19 ferramentas especializadas para administração de banco de dados, monitoramento de desempenho e análise de sistema.

GitHub

Experimente este MCPPatrocinado

Documentação

Servidor MCP para Operações e Monitoramento de MySQL

Docker Pulls

PyPI PyPI - Downloads

Arquitetura e Internos (DeepWiki)

Visão Geral

Você está trabalhando com o Servidor de Operações MySQL MCP, uma ferramenta poderosa que fornece capacidades abrangentes de monitoramento e análise de banco de dados MySQL através de consultas em linguagem natural. Este servidor oferece 19 ferramentas especializadas para administração de banco de dados, monitoramento de desempenho e análise de sistema. Aproveita o Performance Schema e Information Schema do MySQL para obter insights profundos sobre operações de banco de dados e métricas de desempenho.

Recursos

✅ Configuração Zero: Funciona com MySQL 5.7.9+ e 8.0+ imediatamente, com detecção automática de versão.
✅ Linguagem Natural: Faça perguntas como "Mostre-me consultas lentas" ou "Analise tamanhos de tabelas."
✅ Seguro para Produção: Operações somente leitura, compatível com AWS RDS/Aurora MySQL com permissões regulares de usuário.
✅ Integração com Performance Schema: Análise avançada de consultas usando o Performance Schema integrado do MySQL.
✅ Monitoramento Abrangente de Banco de Dados: Análise de mecanismo de armazenamento, monitoramento de conexões e insights de desempenho.
✅ Análise Inteligente de Consultas: Identificação de desempenho de consultas usando estatísticas do Performance Schema.
✅ Descoberta de Esquema e Estrutura: Exploração da estrutura do banco de dados com análise detalhada de tabelas e índices.
✅ Inteligência do Mecanismo de Armazenamento: Monitoramento InnoDB, recomendações de otimização de tabelas.
✅ Operações Multi-Banco de Dados: Análise e monitoramento contínuos entre bancos de dados.
✅ Pronto para Empresas: Operações seguras somente leitura com compatibilidade AWS RDS/Aurora MySQL.
✅ Amigável para Desenvolvedores: Código simples para fácil personalização e extensão de ferramentas.

🔧 Capacidades Avançadas

Monitoramento e análise de consultas baseados no Performance Schema.
Monitoramento de conexões e processos em tempo real.
Análise de status do mecanismo de armazenamento e otimização.
Análise de capacidade do banco de dados e tamanho de tabelas.
Rastreamento de uso e eficiência de índices.

Exemplos de Uso de Ferramentas

MCP-MySQL-Ops Usage Screenshot

⭐ Início Rápido (5 minutos)

Nota: O contêiner mysql incluído no docker-compose.yml destina-se apenas a fins de teste de início rápido. Você pode conectar-se à sua própria instância MySQL ajustando as variáveis de ambiente conforme necessário.

Se você quiser usar sua própria instância MySQL em vez do contêiner de teste integrado:

Atualize as informações de conexão do MySQL de destino no seu arquivo .env (veja MYSQL_HOST, MYSQL_PORT, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE).

No docker-compose.yml, comente (desative) os contêineres mysql e mysql-init-data para evitar iniciar o banco de dados de teste integrado.

Diagrama de Fluxo do Início Rápido/Tutorial

Flow Diagram of Quickstart/Tutorial

1. Configuração do Ambiente

Nota: O sistema lida automaticamente com permissões de usuário - tanto usuários root quanto usuários regulares são suportados com controle de acesso apropriado.

git clone https://github.com/call518/MCP-MySQL-Ops.git
cd MCP-MySQL-Ops

# Copy and check environment configuration
cp .env.example .env

Configuração padrão (funciona imediatamente):

#### MySQL Root Configuration for Docker:
MYSQL_ROOT_HOST=%
MYSQL_ROOT_PASSWORD=changeme!@34

#### MySQL Host Configuration:
MYSQL_HOST=host.docker.internal
MYSQL_PORT=13306
MYSQL_USER=root
MYSQL_PASSWORD=${MYSQL_PASSWORD}
MYSQL_DATABASE=test_ecommerce

Para seu próprio servidor MySQL:

# Edit .env file with your MySQL connection details
MYSQL_HOST=your-mysql-server.com
MYSQL_PORT=3306
MYSQL_USER=your_username     # Will auto-grant permissions on test DBs
MYSQL_PASSWORD=your_password
MYSQL_DATABASE=your_default_db

# Then disable built-in containers in docker-compose.yml
# Comment out: mysql and mysql-init-data services

Nota: O contêiner MySQL é configurado com mapeamento de volume adequado para persistência de dados e configuração inicial do banco de dados.

Recursos Adicionais:

Recursos de Ferramentas MCP (Swagger): http://localhost:8004/docs
Documentação da API do Proxy MCPO: http://localhost:8004/mysql-ops/docs

2. Executar o Docker Stack

# Start all services (MySQL + MCP server + test interfaces)
docker-compose up -d

# Check container status
docker-compose ps

# Watch the logs (Ctrl+C to exit)
docker-compose logs -f mysql-init-data

⏱️ Sequência de Inicialização do Contêiner e Tempo de Espera:

Contêiner MySQL: Inicia primeiro e inicializa o banco de dados (~30-60 segundos)
Dados de Inicialização MySQL: Gera dados de teste automaticamente (~1-2 minutos)
Servidor MCP: Inicia após o MySQL estar pronto (~10-20 segundos)
OpenWebUI: Inicia por último para garantir que todos os serviços estejam disponíveis (~10-30 segundos)

💡 Por favor, aguarde 2-3 minutos para que todos os contêineres sejam totalmente inicializados antes de acessar a interface web. Você pode monitorar o progresso da inicialização com:

# Monitor all container logs
docker-compose logs -f

# Check if all containers are healthy
docker-compose ps

3. Geração Automática de Dados de Teste

🎉 Nenhuma configuração manual necessária! Os dados de teste são gerados automaticamente durante a primeira inicialização pelo contêiner mysql-init-data.

O que acontece automaticamente:

✅ 4 bancos de dados de teste abrangentes criados (test_ecommerce, test_analytics, test_inventory, test_hr)
✅ ~2.745 registros realistas com relacionamentos de chave estrangeira adequados
✅ Permissões de usuário configuradas automaticamente para seu MYSQL_USER (do .env)
✅ Usuários e funções de teste criados para diferentes cenários de acesso

Execução manual (se necessário):

# Force regenerate test data (optional)
docker-compose run --rm mysql-init-data /scripts/create-test-data.sh

# Check generation logs
docker logs mcp-mysql-ops-mysql-init-data

Verificação:

# Connect and verify test databases exist
docker exec -it mcp-mysql-ops-mysql-8 mysql -u [your_mysql_user] -p -e "SHOW DATABASES;"

4. Acesso ao OpenWebUI

🌐 Interface Web: http://localhost:3004/

⏳ Importante: Por favor, aguarde 2-3 minutos após executar docker-compose up -d para que todos os contêineres sejam totalmente inicializados. O OpenWebUI inicia por último para garantir que todos os serviços de backend (MySQL, geração de dados de teste, servidor MCP) estejam prontos.

Verificação Rápida de Status:

# Verify all containers are running
docker-compose ps

# If any container shows "starting" or "unhealthy", wait a bit longer
# You can watch the startup logs:
docker-compose logs -f

5. Registrando a Ferramenta no OpenWebUI

📌 Nota: As instruções de configuração da Web-UI são baseadas no OpenWebUI v0.6.22. Os locais de menu e configurações podem diferir em versões mais recentes.

Faça login no OpenWebUI com uma conta de administrador
Vá para "Configurações" → "Ferramentas" no menu superior.
Insira o endereço da Ferramenta mysql-ops (por exemplo, http://localhost:8004/mysql-ops) para conectar as Ferramentas MCP.
Configure Ollama ou OpenAI.

6. Concluído!

Parabéns! Seu servidor de Operações MySQL MCP está pronto para uso. Você pode começar a explorar seus bancos de dados com consultas em linguagem natural.

🚀 Experimente Estas Consultas de Exemplo:

"Mostre-me as conexões ativas atuais"
"Quais são o status e a configuração atuais do servidor?"
"Analise tamanhos de tabelas e eficiência de armazenamento"
"Mostre-me informações de tamanho do banco de dados"
"Quais tabelas têm mais linhas?"

Segurança e Autenticação

Autenticação com Token Bearer

Para o modo streamable-http, este servidor MCP suporta autenticação com token Bearer para proteger o acesso remoto. Isso é especialmente importante ao executar o servidor em ambientes de produção.

Configuração

Habilitar Autenticação:

# In .env file
REMOTE_AUTH_ENABLE=true
REMOTE_SECRET_KEY=your-secure-secret-key-here

Ou via CLI:

python -m mcp_mysql_ops --type streamable-http --auth-enable --secret-key your-secure-secret-key-here

Níveis de Segurança

Modo stdio (Padrão): Acesso somente local, sem necessidade de autenticação
streamable-http + REMOTE_AUTH_ENABLE=false: Acesso remoto sem autenticação ⚠️ NÃO RECOMENDADO para produção
streamable-http + REMOTE_AUTH_ENABLE=true: Acesso remoto com autenticação de token Bearer ✅ RECOMENDADO para produção

Configuração do Cliente

Quando a autenticação está habilitada, os clientes MCP devem incluir o token Bearer no cabeçalho Authorization:

{
  "mcpServers": {
    "mcp-mysql-ops": {
      "type": "streamable-http",
      "url": "http://your-server:8000/mcp",
      "headers": {
        "Authorization": "Bearer your-secure-secret-key-here"
      }
    }
  }
}

Melhores Práticas de Segurança

Sempre habilite a autenticação ao usar o modo streamable-http em produção
Use chaves secretas fortes e geradas aleatoriamente (32+ caracteres recomendados)
Use HTTPS quando possível (configure proxy reverso com SSL/TLS)
Restrinja o acesso à rede usando firewalls ou políticas de rede
Rotacione chaves secretas regularmente para maior segurança
Monitore logs de acesso para tentativas de acesso não autorizado

Tratamento de Erros

Quando a autenticação falha, o servidor retorna:

401 Não Autorizado para tokens ausentes ou inválidos
Mensagens de erro detalhadas em formato JSON para depuração

🐛 Uso e Configuração

Este servidor MCP suporta dois modos de conexão: stdio (tradicional) e streamable-http (baseado em Docker). Você pode configurar o modo de transporte usando argumentos de CLI ou variáveis de ambiente.

Prioridade de Configuração: Argumentos de CLI > Variáveis de ambiente > Valores padrão

Argumentos de CLI

--type (-t): Tipo de transporte (stdio ou streamable-http) - Padrão: stdio
--host: Endereço do host para transporte HTTP - Padrão: 127.0.0.1
--port (-p): Número da porta para transporte HTTP - Padrão: 8000
--auth-enable: Habilitar autenticação de token Bearer para modo streamable-http - Padrão: false
--secret-key: Chave secreta para autenticação de token Bearer (necessária quando a autenticação está habilitada)

Variáveis de Ambiente

Variável	Descrição	Padrão	Padrão do Projeto
`PYTHONPATH`	Caminho de busca de módulos Python para importações do servidor MCP	-	`/app/src`
`MCP_LOG_LEVEL`	Nível de detalhamento do log do servidor (DEBUG, INFO, WARNING, ERROR)	`INFO`	`INFO`
`FASTMCP_TYPE`	Protocolo de transporte MCP (stdio para CLI, streamable-http para web)	`stdio`	`streamable-http`
`FASTMCP_HOST`	Endereço de vinculação do servidor HTTP (0.0.0.0 para todas as interfaces)	`127.0.0.1`	`0.0.0.0`
`FASTMCP_PORT`	Porta do servidor HTTP para comunicação MCP	`8000`	`8000`
`REMOTE_AUTH_ENABLE`	Habilitar autenticação de token Bearer para modo streamable-http. Se indefinido/vazio, o padrão é `false`. Aceita: true/false, 1/0, yes/no, on/off (insensível a maiúsculas)	`false`	`false`
`REMOTE_SECRET_KEY`	Chave secreta para autenticação de token Bearer. Se indefinida/vazia, a autenticação será desabilitada mesmo se `REMOTE_AUTH_ENABLE=true`. Recomendado: string aleatória de 32+ caracteres	`""` (vazio)	`your-secret-key-here`
`MYSQL_HOST`	Nome do host ou endereço IP do servidor MySQL	`127.0.0.1`	`host.docker.internal`
`MYSQL_PORT`	Número da porta do servidor MySQL	`3306`	`13306`
`MYSQL_USER`	Nome de usuário para autenticação no servidor MySQL	`root`	`root`
`MYSQL_PASSWORD`	Senha para autenticação no servidor MySQL	-	`changeme!@34`
`MYSQL_DATABASE`	Nome do banco de dados MySQL de destino padrão	-	`test_ecommerce`
`DOCKER_EXTERNAL_PORT_OPENWEBUI`	Mapeamento de porta do host para o contêiner Open WebUI	`8080`	`3004`

Configuração do Ambiente

Copie .env.example para .env e configure seu ambiente:

cp .env.example .env
# Edit .env file with your specific configuration

Política de Valores Padrão de Variáveis de Ambiente

Variáveis de Autenticação:

REMOTE_AUTH_ENABLE: Se indefinida, comentada ou vazia → o padrão é false
REMOTE_SECRET_KEY: Se indefinida, comentada ou vazia → o padrão é "" (string vazia)

Comportamento de Segurança:

A autenticação é somente habilitada quando ambas as condições são atendidas:
1. REMOTE_AUTH_ENABLE está explicitamente definida como um valor verdadeiro (true/1/yes/on)
2. REMOTE_SECRET_KEY está definida como uma string não vazia
Se qualquer condição falhar, o servidor executa sem autenticação
Isso garante padrões seguros e previne bypass acidental de autenticação

Exemplos de configuração:

# Authentication disabled (all equivalent)
# REMOTE_AUTH_ENABLE=            # undefined/commented
REMOTE_AUTH_ENABLE=false         # explicit false
REMOTE_AUTH_ENABLE=""           # empty string

# Authentication enabled (requires both)
REMOTE_AUTH_ENABLE=true         # or 1, yes, on
REMOTE_SECRET_KEY=my-secret-key # non-empty string

🛠️ Desenvolvimento Local e Instalação

Para desenvolvedores que desejam executar o servidor MCP localmente ou integrá-lo em seus próprios projetos:

Método 1: Script de Console (Recomendado)

# Clone and install
git clone https://github.com/call518/MCP-MySQL-Ops.git
cd MCP-MySQL-Ops
pip install -e .

# Run with simple command
mcp-mysql-ops --type stdio
mcp-mysql-ops --type streamable-http --host 127.0.0.1 --port 8000

Método 2: Execução de Módulo

# Clone and set PYTHONPATH
git clone https://github.com/call518/MCP-MySQL-Ops.git
cd MCP-MySQL-Ops
export PYTHONPATH=$(pwd)/src

# Run as module
python -m mcp_mysql_ops --type stdio
python -m mcp_mysql_ops --type streamable-http --host 127.0.0.1 --port 8000

💡 Dica Profissional: Use o Método 1 (script de console) para integração mais limpa. O Método 2 é útil quando você precisa modificar o código-fonte diretamente.

Executando Testes

Duas suítes de teste estão disponíveis:

Suíte	Arquivo	Requer Docker
Testes unitários (lógica de compatibilidade de versão)	`tests/test_version_compat.py`	Não
Testes de integração (todas as ferramentas × MySQL 5.7 / 8.0 / 8.4)	`tests/test_tools_integration.py`	Sim

Execute tudo com um único comando

uv run pytest inicia automaticamente os contêineres de teste Docker (MySQL 5.7, 8.0, 8.4), aguarda a inicialização completa (esquema + dados de seed + Performance Schema), executa todos os testes e depois encerra tudo.

# Install dev dependencies (one-time)
uv sync --extra dev

# Run all tests (unit + integration) — Docker is managed automatically
uv run pytest -v

# Unit tests only (no Docker needed)
uv run pytest tests/test_version_compat.py -v

# Integration tests only
uv run pytest tests/test_tools_integration.py -v

# Run against a specific MySQL version only
uv run pytest -v -k MySQL80

Nota: O Docker deve estar em execução. A stack de testes usa as portas 3357 (MySQL 5.7), 3380 (8.0) e 3384 (8.4) em 127.0.0.1.

Se os contêineres já estiverem em execução (por exemplo, entre execuções repetidas de depuração), o fixture de teste os detecta e pula o ciclo de subida/descida — útil para iteração rápida. Para iniciar manualmente:
docker compose -f tests/docker/docker-compose.test.yml up -d
uv run pytest -v   # reutiliza contêineres em execução, não os derruba

Integração Contínua

Cada push para main e cada pull request aciona .github/workflows/test.yml, que executa a suíte de testes unitários e a matriz completa de integração MySQL 5.7 / 8.0 / 8.4 em runners hospedados no GitHub.

(NOTA) Visão Geral dos Dados de Teste de Exemplo

O sistema de geração de dados de teste segue o padrão do projeto PostgreSQL MCP — usando um contêiner dedicado mysql-init-data que cria automaticamente bancos de dados de teste abrangentes na primeira inicialização.

🚀 Geração Automática de Dados de Teste

O contêiner mysql-init-data (definido no docker-compose.yml) executa automaticamente scripts/create-test-data.sh e scripts/create-test-data.sql na primeira inicialização, gerando dados de negócios realistas para testes das ferramentas MCP.

Banco de Dados	Finalidade	Tabelas	Escala
test_ecommerce	Sistema de e-commerce	categories, products, customers, orders, order_items	10 categorias, 500 produtos, 100 clientes, 1000 pedidos, 2500 itens de pedido
test_analytics	Analytics e relatórios	page_views, sales_summary	500 visualizações de página, 30 resumos de vendas
test_inventory	Gerenciamento de armazém	suppliers, inventory_items, purchase_orders	10 fornecedores, 100 itens, 50 ordens de compra
test_hr	Gerenciamento de RH	departments, employees, payroll	5 departamentos, 50 funcionários, 150 registros de folha de pagamento

Total de Registros: ~2.745 registros em todos os bancos de dados de teste

Usuários de teste criados: app_readonly, app_readwrite, analytics_user, backup_user

Gerenciamento de Permissões de Usuário: O sistema cria automaticamente o MYSQL_USER especificado (a partir do .env) e concede permissões completas apenas nos 4 bancos de dados de teste, garantindo controle de acesso seguro.

Recursos para Testes:

✅ Relacionamentos de chave estrangeira com integridade referencial adequada
✅ Vários mecanismos de armazenamento (otimização InnoDB)
✅ Tipos de índice mistos (usados/não usados para testar ferramentas de análise de índice)
✅ Dados de séries temporais para testes de analytics
✅ Cenários de negócios realistas em múltiplos domínios
✅ Ambiente de teste seguro com permissões de usuário isoladas

📋 Padrão de Inicialização Estilo PostgreSQL

Semelhante ao projeto MCP-PostgreSQL-Ops, esta implementação MySQL usa:

Contêiner de inicialização dedicado (mysql-init-data) para geração única de dados
Dependências de health check garantindo que o MySQL esteja pronto antes da criação de dados
Privilégios de root para criação de banco de dados, seguidos de delegação de permissões ao usuário especificado
Logging abrangente e tratamento de erros durante a inicialização

Matriz de Compatibilidade de Ferramentas

Adaptação Automática: Todas as ferramentas funcionam de forma transparente nas versões suportadas — nenhuma configuração necessária!

🟢 Ferramentas Profissionais MySQL (19 Ferramentas Disponíveis)

Nome da Ferramenta	Versões MySQL	Recursos	Fonte de Informação
`get_server_info`	MySQL 5.7.9+ / 8.0+	✅ Versão do servidor, configuração, variáveis de status	`SHOW VERSION`, `INFORMATION_SCHEMA`
`get_database_list`	MySQL 5.7.9+ / 8.0+	✅ Tamanhos de banco de dados, conjuntos de caracteres, collations	`INFORMATION_SCHEMA.SCHEMATA`, `information_schema.tables`
`get_table_list`	MySQL 5.7.9+ / 8.0+	✅ Informações de tabela, mecanismos de armazenamento, contagens de linhas	`INFORMATION_SCHEMA.TABLES`
`get_table_schema_info`	MySQL 5.7.9+ / 8.0+	✅ Colunas, índices, restrições, chaves estrangeiras	`INFORMATION_SCHEMA.COLUMNS`, `INFORMATION_SCHEMA.STATISTICS`
`get_database_overview`	MySQL 5.7.9+ / 8.0+	✅ Resumo do banco de dados, contagens de tabelas, tamanhos	`INFORMATION_SCHEMA.TABLES`, estatísticas agregadas
`get_user_list`	MySQL 5.7.9+ / 8.0+	✅ Usuários MySQL, hosts, privilégios, status da conta	`mysql.user`, `INFORMATION_SCHEMA.USER_PRIVILEGES`
`get_active_connections`	MySQL 5.7.9+ / 8.0+	✅ Conexões ativas, detalhes de conexão, lista de processos	`performance_schema.processlist`
`get_server_status`	MySQL 5.7.9+ / 8.0+	✅ Variáveis de status do servidor, contadores de desempenho	`SHOW STATUS`, variáveis de status do sistema
`get_table_size_info`	MySQL 5.7.9+ / 8.0+	✅ Tamanhos de tabela, tamanhos de índice, proporções dados/índice	`INFORMATION_SCHEMA.TABLES` (DATA_LENGTH, INDEX_LENGTH)
`get_database_size_info`	MySQL 5.7.9+ / 8.0+	✅ Tamanhos de banco de dados, análise de uso de armazenamento	Dados agregados de `INFORMATION_SCHEMA.TABLES`
`get_index_usage_stats`	MySQL 5.7.9+ / 8.0+	✅ Uso de índice, cardinalidade, análise de eficiência	`INFORMATION_SCHEMA.STATISTICS`, `SHOW INDEX`

🚀 Ferramentas Aprimoradas com Performance Schema (8 Ferramentas Adicionais)

Nome da Ferramenta	Versões MySQL	Recursos	Fonte de Informação
`get_mysql_config`	MySQL 5.7.9+ / 8.0+	✅ Variáveis e configurações do MySQL	`SHOW VARIABLES`, configuração do sistema
`get_slow_queries`	MySQL 5.7.9+ / 8.0+	✅ Análise de consultas lentas e insights de desempenho	`Performance Schema`, log de consultas lentas
`get_table_io_stats`	MySQL 5.7.9+ / 8.0+	✅ Estatísticas de I/O de tabela e padrões de acesso	Monitoramento de I/O `Performance Schema`
`get_lock_monitoring`	MySQL 5.7.9+ / 8.0+	✅ Análise de locks e monitoramento de contenção	Tabelas de locks `Performance Schema`
`get_all_databases_tables`	MySQL 5.7.9+ / 8.0+	✅ Visão geral e análise de tabelas entre bancos de dados	Consultas multi-banco `INFORMATION_SCHEMA`
`get_all_databases_table_sizes`	MySQL 5.7.9+ / 8.0+	✅ Análise global de tamanho de tabelas entre bancos de dados	Estatísticas agregadas de tamanho
`get_connection_info`	MySQL 5.7.9+ / 8.0+	✅ Detalhes de conexão e informações de sessão	`performance_schema.processlist`
`get_current_database_info`	MySQL 5.7.9+ / 8.0+	✅ Contexto e detalhes do banco de dados atual	Informações do banco de dados ativo

🚀 Aprimoramentos Cientes da Versão

Recurso	MySQL 5.7.9+	MySQL 8.0+	Capacidades Aprimoradas
Performance Schema	✅ Básico	✅ Aprimorado	MySQL 8.0+: Monitoramento avançado de consultas, tabelas Performance Schema melhoradas
Information Schema	✅ Padrão	✅ Aprimorado	MySQL 8.0+: Tabelas de metadados adicionais e estatísticas melhoradas
Informações do Mecanismo de Armazenamento	✅ Foco em InnoDB	✅ Multi-Mecanismo	MySQL 8.0+: Estatísticas e monitoramento aprimorados do mecanismo de armazenamento
Suporte a JSON	✅ Básico	✅ Avançado	MySQL 8.0+: Funções JSON melhoradas e capacidades de indexação
Gerenciamento de Usuários	✅ Tradicional	✅ Baseado em Papéis	MySQL 8.0+: Controle de acesso baseado em papéis e recursos de segurança aprimorados

📋 Suporte a Versões MySQL: Requer MySQL 5.7.9 ou mais recente (5.7.9, 8.0+, 8.4+ são suportados). O mínimo é ditado por performance_schema.processlist, introduzido no MySQL 5.7.9 e usado por get_active_connections, get_connection_info e get_lock_monitoring. A compatibilidade com MySQL 8.1+ e 8.2+ será adicionada quando atingirem status de versão estável.

Exemplos de Uso

Integração com Claude Desktop

Método 1: MCP Local (transport="stdio")

{
  "mcpServers": {
    "mcp-mysql-ops": {
      "command": "uvx",
      "args": ["--python", "3.11", "mcp-mysql-ops"],
      "env": {
        "MYSQL_HOST": "127.0.0.1",
        "MYSQL_PORT": "13306",
        "MYSQL_USER": "root",
        "MYSQL_PASSWORD": "changeme!@34",
        "MYSQL_DATABASE": "test_ecommerce"
      }
    }
  }
}

Método 2: MCP Remoto (transport="streamable-http")

No Host do Cliente MCP:

{
  "mcpServers": {
    "mcp-mysql-ops": {
      "type": "streamable-http",
      "url": "http://localhost:18004/mcp"
    }
  }
}

Com Autenticação por Bearer Token (Recomendado para produção):

{
  "mcpServers": {
    "mcp-mysql-ops": {
      "type": "streamable-http", 
      "url": "http://localhost:18004/mcp",
      "headers": {
        "Authorization": "Bearer your-secure-secret-key-here"
      }
    }
  }
}

"Exibir informações de capacidades e versão do servidor MySQL." Claude Desktop Integration

"Desenhar relacionamentos como um diagrama Mermaid" Claude Desktop Integration

(Opcional) Executar com Fonte Local:

{
  "mcpServers": {
    "mcp-mysql-ops": {
      "command": "uv",
      "args": ["run", "python", "-m", "src.mcp_mysql_ops.mcp_main"],
      "env": {
        "PYTHONPATH": "/path/to/MCP-MySQL-Ops",
        "MYSQL_HOST": "127.0.0.1",
        "MYSQL_PORT": "13306",
        "MYSQL_USER": "root",
        "MYSQL_PASSWORD": "changeme!@34",
        "MYSQL_DATABASE": "test_ecommerce"
      }
    }
  }
}

Executar o MCP-Server como Standalone

/w Pypi e uvx (Recomendado)

# Stdio mode
uvx --python 3.11 mcp-mysql-ops \
  --type stdio

# HTTP mode
uvx --python 3.11 mcp-mysql-ops
  --type streamable-http \
  --host 127.0.0.1 \
  --port 8000 \
  --log-level DEBUG

(Opcional) Configurar Múltiplas Instâncias MySQL

{
  "mcpServers": {
    "MySQL-A": {
      "command": "uvx",
      "args": ["--python", "3.11", "mcp-mysql-ops"],
      "env": {
        "MYSQL_HOST": "a.foo.com",
        "MYSQL_PORT": "3306",
        "MYSQL_USER": "root",
        "MYSQL_PASSWORD": "password",
        "MYSQL_DATABASE": "information_schema"
      }
    },
    "MySQL-B": {
      "command": "uvx",
      "args": ["--python", "3.11", "mcp-mysql-ops"],
      "env": {
        "MYSQL_HOST": "b.bar.com",
        "MYSQL_PORT": "3306",
        "MYSQL_USER": "root",
        "MYSQL_PASSWORD": "password",
        "MYSQL_DATABASE": "information_schema"
      }
    }
  }
}

/w Fonte Local

# Method 1: Using installed console script (after pip install -e .)
mcp-mysql-ops --type stdio
mcp-mysql-ops --type streamable-http --host 127.0.0.1 --port 8000 --log-level DEBUG

# Method 2: Using module execution
PYTHONPATH=/path/to/MCP-MySQL-Ops/src
python -m mcp_mysql_ops --type stdio
python -m mcp_mysql_ops --type streamable-http --host 127.0.0.1 --port 8000 --log-level DEBUG

Variáveis de Ambiente

Variável	Descrição	Padrão	Padrão do Projeto
`PYTHONPATH`	Caminho de busca do módulo Python para importações do servidor MCP	-	`/app/src`
`MCP_LOG_LEVEL`	Nível de verbosidade do log do servidor (DEBUG, INFO, WARNING, ERROR)	`INFO`	`INFO`
`FASTMCP_TYPE`	Protocolo de transporte MCP (stdio para CLI, streamable-http para web)	`stdio`	`streamable-http`
`FASTMCP_HOST`	Endereço de bind do servidor HTTP (0.0.0.0 para todas as interfaces)	`127.0.0.1`	`0.0.0.0`
`FASTMCP_PORT`	Porta do servidor HTTP para comunicação MCP	`8000`	`8000`
`MYSQL_VERSION`	Versão principal do MySQL para seleção de imagem Docker	`8.0`	`8.0`
`MYSQL_HOST`	Hostname ou endereço IP do servidor MySQL	`127.0.0.1`	`host.docker.internal`
`MYSQL_PORT`	Número da porta do servidor MySQL	`3306`	`13306`
`MYSQL_USER`	Nome de usuário da conexão MySQL (permissões concedidas automaticamente nos bancos de teste)	`root`	`testuser`
`MYSQL_PASSWORD`	Senha do usuário MySQL (suporta caracteres especiais)	`changeme!@34`	`testpass`
`MYSQL_DATABASE`	Nome padrão do banco de dados para conexões	`information_schema`	`testdb`
`MYSQL_ROOT_HOST`	Padrão de acesso ao host root do MySQL para contêiner Docker	`%`	`%`
`MYSQL_ROOT_PASSWORD`	Senha root do MySQL para inicialização do contêiner Docker	`changeme!@34`	`changeme!@34`
`DOCKER_EXTERNAL_PORT_OPENWEBUI`	Mapeamento de porta do host para contêiner Open WebUI	`8080`	`3004`
`DOCKER_EXTERNAL_PORT_MCP_SERVER`	Mapeamento de porta do host para contêiner do servidor MCP	`8000`	`18004`
`DOCKER_EXTERNAL_PORT_MCPO_PROXY`	Mapeamento de porta do host para contêiner proxy MCPO	`8000`	`8004`

Nota: MYSQL_DATABASE serve como banco de dados alvo padrão para operações quando nenhum banco de dados específico é especificado. Em ambientes Docker, se definido como um nome de banco de dados personalizado, este banco será criado automaticamente durante a inicialização inicial do MySQL.

Gerenciamento de Permissões de Usuário: Ao usar um MYSQL_USER não-root, o processo de inicialização automaticamente:

Cria o usuário especificado se ele não existir
Concede permissões completas nos 4 bancos de dados de teste (test_ecommerce, test_analytics, test_inventory, test_hr)
Mantém a segurança restringindo o acesso apenas aos bancos de dados necessários
Habilita capacidades de monitoramento através de acesso automático a information_schema/performance_schema

Pré-requisitos

Requisitos Mínimos

MySQL 5.7.9 ou mais recente (5.7.9+, 8.0+, 8.4+ suportados; testado com MySQL 8.0.37). Versões anteriores a 5.7.9 não são suportadas porque o servidor depende de performance_schema.processlist, introduzido no 5.7.9.
Python 3.11+
Acesso de rede ao servidor MySQL
Permissões de leitura nos bancos de dados do sistema (information_schema, performance_schema)

Configuração MySQL Recomendada

⚠️ Configurações de Monitoramento de Desempenho: Algumas ferramentas MCP fornecem funcionalidade aprimorada com parâmetros específicos de configuração do MySQL. Essas configurações são opcionais, mas recomendadas para monitoramento abrangente:

Ferramentas aprimoradas por estas configurações:

get_server_status: Estatísticas mais detalhadas com Performance Schema habilitado
get_index_usage_stats: Aprimorado com estatísticas de tabela do Performance Schema
get_connection_info: Rastreamento de conexão melhorado com Performance Schema

Verificação: Após aplicar quaisquer alterações de configuração, verifique as configurações:

SHOW VARIABLES LIKE 'performance_schema';
SHOW VARIABLES LIKE 'information_schema_stats_expiry';

+----------------------------------+-------+
| Variable_name                    | Value |
+----------------------------------+-------+
| performance_schema               | ON    |
| information_schema_stats_expiry  | 86400 |
+----------------------------------+-------+

Método 1: Configuração my.cnf (Recomendado para MySQL Autogerenciado)

Adicione o seguinte ao seu my.cnf ou my.ini:

[mysqld]
# Performance Schema (usually enabled by default in MySQL 8.0+)
performance_schema = ON

# Enhanced statistics collection
information_schema_stats_expiry = 0  # Real-time statistics (use 86400 for cached)

# Optional: Enhanced query logging (use carefully in production)
# slow_query_log = ON
# slow_query_log_file = /var/log/mysql/slow.log
# long_query_time = 2

Em seguida, reinicie o servidor MySQL.

Método 2: Parâmetros de Inicialização do MySQL

Para inicialização do MySQL via Docker ou linha de comando:

# Docker example
docker run -d \
  -e MYSQL_ROOT_PASSWORD=mypassword \
  mysql:8.0 \
  --performance-schema=ON \
  --information-schema-stats-expiry=0

# Direct mysqld command
mysqld \
  --performance-schema=ON \
  --information-schema-stats-expiry=0

Método 3: Configuração Dinâmica (MySQL 8.0+, AWS RDS, Azure, GCP)

Para serviços MySQL gerenciados onde você não pode modificar my.cnf, use comandos SQL para alterar configurações dinâmicas:

-- Enable real-time statistics (requires SUPER privilege or SYSTEM_VARIABLES_ADMIN)
SET GLOBAL information_schema_stats_expiry = 0;

-- Verify Performance Schema status (usually enabled by default)
SHOW VARIABLES LIKE 'performance_schema';

-- Optional: Enable slow query log for enhanced monitoring
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 2;

Nota para testes em nível de sessão:

-- Set for current session only (temporary)
SET SESSION information_schema_stats_expiry = 0;

Compatibilidade com RDS/Aurora MySQL

Este servidor é somente leitura e funciona com funções padrão no AWS RDS MySQL e Aurora MySQL. Toda a funcionalidade principal está disponível através do acesso padrão ao Information Schema e Performance Schema.
O Performance Schema está habilitado por padrão em instâncias RDS/Aurora MySQL 8.0+.

Para capacidades de monitoramento aprimoradas, considere a configuração do Parameter Group:

-- Check Performance Schema status
SHOW VARIABLES LIKE 'performance_schema';

-- Verify Information Schema settings
SHOW VARIABLES LIKE 'information_schema_stats_expiry';

-- Recommended user permissions for monitoring
GRANT SELECT ON *.* TO <monitoring_user>@'%';
GRANT PROCESS ON *.* TO <monitoring_user>@'%';

Exemplos de Consultas

🟢 Ferramentas Principais de Monitoramento MySQL (Sempre Disponíveis)

get_server_info
- "Mostrar versão do servidor MySQL e status de configuração."
- "Verificar variáveis de sistema do servidor e configuração em tempo de execução."
- "Exibir capacidades do servidor MySQL e informações de versão."
- 📋 Recursos: Versão do servidor, variáveis de sistema, status de configuração, disponibilidade de recursos
- 🔧 MySQL 5.7.9+/8.0+: Totalmente compatível, sem configuração adicional necessária
get_database_list
- "Listar todos os bancos de dados e seus tamanhos."
- "Mostrar lista de bancos de dados com informações de conjuntos de caracteres e collation."
- "Exibir uso de armazenamento e contagem de tabelas dos bancos de dados."
- 📋 Recursos: Tamanhos de bancos de dados, conjuntos de caracteres, collations, contagem de tabelas, uso de armazenamento
- 🔧 MySQL 5.7.9+/8.0+: Usa Information Schema para informações abrangentes do banco de dados
get_table_list
- "Listar todas as tabelas no banco de dados test_ecommerce."
- "Mostrar informações de tabelas com mecanismos de armazenamento e contagem de linhas."
- "Exibir datas de criação de tabelas e timestamps de atualização."
- 📋 Recursos: Nomes de tabelas, mecanismos de armazenamento, contagem de linhas, tamanhos, datas de criação/atualização
- ⚠️ Obrigatório: O parâmetro database_name deve ser especificado
- 💡 Uso: Suporta filtragem por padrões de nome de tabela
get_table_schema_info
- "Mostrar informações detalhadas de esquema para a tabela customers no banco de dados test_ecommerce."
- "Obter detalhes de colunas e restrições para a tabela products no banco de dados test_ecommerce."
- "Analisar estrutura de tabela com índices e chaves estrangeiras para a tabela orders no banco de dados test_ecommerce."
- "Mostrar visão geral do esquema para todas as tabelas no banco de dados test_inventory."
- 📋 Recursos: Tipos de colunas, restrições, índices, chaves estrangeiras, metadados de tabela
- ⚠️ Obrigatório: O parâmetro database_name deve ser especificado
- 💡 Uso: Deixe table_name vazio para análise de esquema em todo o banco de dados
get_database_overview
- "Mostrar visão geral abrangente do banco de dados test_ecommerce."
- "Obter resumo detalhado da estrutura e estatísticas do banco de dados test_analytics."
- "Analisar visão geral do banco de dados com contagem de tabelas e tamanhos para o banco de dados test_inventory."
- "Mostrar resumo da estrutura do banco de dados para o banco de dados test_hr."
- 📋 Recursos: Visão geral do banco de dados, estatísticas de tabelas, resumo de armazenamento, análise de esquema
- ⚠️ Obrigatório: O parâmetro database_name deve ser especificado
get_user_list
- "Listar todos os usuários MySQL e seus privilégios."
- "Mostrar contas de usuário com informações de host e status da conta."
- "Exibir resumo de privilégios de usuário e detalhes de autenticação."
- 📋 Recursos: Contas de usuário, padrões de host, privilégios, status da conta, informações de autenticação
- 🔧 MySQL 5.7.9+/8.0+: Informações aprimoradas de gerenciamento de usuários no MySQL 8.0+
get_active_connections
- "Mostrar todas as conexões ativas e seus detalhes."
- "Listar conexões atuais do banco de dados com informações de usuário e host."
- "Monitorar sessões ativas e suas operações atuais."
- "Exibir estatísticas de conexão e informações de processos."
- 📋 Recursos: Conexões ativas, lista de processos, detalhes de conexão, informações de sessão
- 🔧 MySQL 5.7.9+/8.0+: Informações aprimoradas de processos com integração Performance Schema
get_server_status
- "Mostrar variáveis de status do servidor MySQL e contadores de desempenho."
- "Exibir métricas e estatísticas atuais de desempenho do servidor."
- "Monitorar status operacional do servidor e indicadores-chave de desempenho."
- "Analisar métricas de saúde do servidor e utilização de recursos."
- 📋 Recursos: Variáveis de status, contadores de desempenho, estatísticas de conexão, métricas de recursos
- 🔧 MySQL 5.7.9+/8.0+: Monitoramento abrangente de status do servidor
get_table_size_info
- "Mostrar análise de tamanho de tabelas e índices para o banco de dados test_ecommerce."
- "Encontrar maiores tabelas por tamanho de dados e índices."
- "Analisar eficiência de armazenamento e distribuição de tamanho de tabelas."
- "Exibir detalhes de tamanho de tabelas com proporções dados/índices."
- 📋 Recursos: Tamanhos de tabelas, tamanhos de índices, proporções dados/índices, análise de eficiência de armazenamento
- ⚠️ Obrigatório: Parâmetro database_name para análise precisa de tamanho
get_database_size_info
- "Mostrar análise de capacidade do banco de dados e uso de armazenamento."
- "Encontrar os maiores bancos de dados por tamanho total."
- "Exibir estatísticas abrangentes de tamanho de bancos de dados."
- "Analisar distribuição de armazenamento entre bancos de dados."
- 📋 Recursos: Tamanhos de bancos de dados, contagem de tabelas, distribuição de armazenamento, análise de capacidade
- 🔧 MySQL 5.7.9+/8.0+: Cálculo preciso de tamanho usando Information Schema
get_index_usage_stats
- "Analisar estatísticas de uso e eficiência de índices."
- "Mostrar informações de cardinalidade e seletividade de índices."
- "Encontrar índices potencialmente não utilizados ou redundantes."
- "Exibir padrões de desempenho e uso de índices."
- 📋 Recursos: Estatísticas de índices, cardinalidade, seletividade, análise de uso, recomendações de otimização
- ⚠️ Obrigatório: Parâmetro database_name para análise direcionada de índices
- 💡 Aprimorado com: Performance Schema habilitado para estatísticas mais detalhadas

🚀 Ferramentas Aprimoradas por Versão

get_server_info (Aprimorado!)
- "Mostrar versão do servidor e recursos avançados do MySQL 8.0."
- "Verificar compatibilidade do servidor e aprimoramentos disponíveis."
- "Exibir capacidades específicas da versão MySQL e recomendações."
- 📈 MySQL 8.0+: Suporte JSON aprimorado, Performance Schema melhorado, suporte a CTE, funções de janela
- 📊 MySQL 5.7.9+: Funcionalidade principal com suporte básico a JSON e Performance Schema

💡 Exemplos de Consultas em Linguagem Natural

Teste as ferramentas com prompts realistas - nunca use nomes de funções diretamente:

✅ "Mostre-me o status atual do servidor e as principais métricas de desempenho"
❌ "Execute get_server_status"

📊 Exemplos de Monitoramento:

"Quais bancos de dados existem e quanto espaço eles usam?"
"Mostre-me todas as tabelas no banco de dados ecommerce com seus tamanhos"
"Quais tabelas têm mais linhas e maiores índices?"
"Exiba conexões atuais do banco de dados e suas atividades"
"Analise a estrutura do esquema do banco de dados test_ecommerce"
"Mostre-me a configuração do servidor MySQL e o status de desempenho"
"Liste todos os usuários e seus privilégios de banco de dados"
"Encontre tabelas que podem precisar de otimização de índices"

💡 Dica Profissional: Todas as ferramentas suportam operações multi-banco de dados usando o parâmetro database_name. Isso permite que usuários root do MySQL analisem e monitorem múltiplos bancos de dados a partir de uma única instância do servidor MCP.

Solução de Problemas

Problemas de Conexão

Verifique o status do servidor MySQL
Verifique os parâmetros de conexão no arquivo .env
Garanta a conectividade de rede
Verifique permissões de usuário e autenticação

Problemas de Configuração

Erros de "Acesso negado": Verifique os privilégios do usuário

SHOW GRANTS FOR 'username'@'host';

Correção rápida para configuração de usuário de monitoramento:

-- Create monitoring user with necessary permissions
CREATE USER 'monitoring'@'%' IDENTIFIED BY 'secure_password';
GRANT SELECT ON *.* TO 'monitoring'@'%';
GRANT PROCESS ON *.* TO 'monitoring'@'%';

"Tabela não existe" para Performance Schema: Verifique o status do Performance Schema
```
SHOW VARIABLES LIKE 'performance_schema';  -- Should be 'ON'
```
Nota: O Performance Schema está habilitado por padrão no MySQL 8.0+, mas pode estar desabilitado em algumas configurações.

Informações de banco de dados ausentes: Verifique o acesso ao Information Schema

SHOW VARIABLES LIKE 'information_schema_stats_expiry';
SELECT COUNT(*) FROM information_schema.tables;

Correção rápida para estatísticas em tempo real:

SET GLOBAL information_schema_stats_expiry = 0;

Aplicar alterações de configuração:
- Autogerenciado: Adicione configurações ao my.cnf e reinicie o servidor
- Serviços gerenciados: Use SET GLOBAL para variáveis dinâmicas ou Parameter Groups
- Teste temporário: Use SET SESSION apenas para a sessão atual

Problemas de Desempenho

Use parâmetros limit para reduzir o tamanho do resultado
Execute o monitoramento fora dos horários de pico
Verifique a carga do banco de dados antes de executar análises
Considere definir information_schema_stats_expiry para estatísticas em cache

Problemas de Compatibilidade de Versão

Para mais detalhes, consulte a ## Matriz de Compatibilidade de Ferramentas

Execute a verificação de compatibilidade primeiro:

# "Use get_server_info to check version and available features"

Entendendo a disponibilidade de recursos:
- MySQL 8.0+: Todos os recursos disponíveis com Performance Schema aprimorado
- MySQL 5.7.9+: Funcionalidade principal com suporte básico ao Performance Schema
- Versões anteriores (< 5.7.9): Não suportadas — performance_schema.processlist não está disponível
Se os recursos parecerem limitados:
- Verifique a versão do MySQL: SELECT VERSION();
- Verifique o Performance Schema: SHOW VARIABLES LIKE 'performance_schema';
- Considere atualizar o MySQL para capacidades aprimoradas de monitoramento

Problemas Específicos do Docker

Conflitos de porta: A porta padrão do MySQL 3306 pode estar em uso
- O projeto usa a porta 13306 por padrão para evitar conflitos
- Verifique a disponibilidade da porta: netstat -an | grep 13306
Problemas de inicialização do contêiner: Verifique os logs do Docker
```
docker-compose logs mysql
docker-compose logs mcp-server
```
Persistência de dados: Garanta que os volumes montados estejam funcionando
```
docker volume ls
docker volume inspect mcp-mysql-ops_mysql_data
```

🚀 Adicionando Ferramentas Personalizadas

Este servidor MCP foi projetado para fácil extensibilidade. Siga estes 5 passos simples para adicionar suas próprias ferramentas personalizadas:

Guia Passo a Passo

1. Adicionar Funções Auxiliares (Opcional)

Adicione funções de dados reutilizáveis ao src/<package_name>/functions.py:

async def get_your_custom_data(target_resource: str = None) -> List[Dict[str, Any]]:
    """Your custom data retrieval function."""
    # Example implementation - adapt to your service
    data_source = await get_data_connection(target_resource)
    results = await fetch_data_from_source(
        source=data_source,
        filters=your_conditions,
        aggregations=["count", "sum", "avg"],
        sorting=["count DESC", "timestamp ASC"]
    )
    return results

2. Criar Sua Ferramenta MCP

Adicione sua função de ferramenta ao src/<package_name>/mcp_main.py:

@mcp.tool()
async def get_your_custom_analysis(limit: int = 50, target_name: Optional[str] = None) -> str:
    """
    [Tool Purpose]: Brief description of what your tool does
    
    [Exact Functionality]:
    - Feature 1: Data aggregation and analysis
    - Feature 2: Resource monitoring and insights
    - Feature 3: Performance metrics and reporting
    
    [Required Use Cases]:
    - When user asks "your specific analysis request"
    - Your business-specific monitoring needs
    
    Args:
        limit: Maximum results (1-100)
        target_name: Target resource/service name
    
    Returns:
        Formatted analysis results
    """
    try:
        limit = max(1, min(limit, 100))  # Always validate input
        
        results = await get_your_custom_data(target_resource=target_name)
        
        if results:
            results = results[:limit]
        
        return format_table_data(results, f"Custom Analysis (Top {len(results)})")
        
    except Exception as e:
        logger.error(f"Failed to get custom analysis: {e}")
        return f"Error: {str(e)}"

3. Atualizar Imports (Se Necessário)

Adicione sua função auxiliar aos imports em src/<package_name>/mcp_main.py:

from .functions import (
    # ...existing imports...
    get_your_custom_data,  # Add your new function
)

4. Atualizar o Modelo de Prompt (Recomendado)

Adicione a descrição da sua ferramenta ao src/<package_name>/prompt_template.md para melhor reconhecimento em linguagem natural:

### **Your Custom Analysis Tool**

### X. **get_your_custom_analysis**
**Purpose**: Brief description of what your tool does
**Usage**: "Show me your custom analysis" or "Get custom analysis for database_name"
**Features**: Data aggregation, resource monitoring, performance metrics
**Required**: `target_name` parameter for specific resource analysis

5. Testar Sua Ferramenta

# Local testing
./scripts/run-mcp-inspector-local.sh

# Or with Docker
docker-compose up -d
docker-compose logs -f mcp-server

# Test with natural language:
# "Show me your custom analysis"
# "Get custom analysis for target_name"

Pronto! Sua ferramenta personalizada está pronta para uso com consultas em linguagem natural.

Desenvolvimento

Testes e Desenvolvimento

# Test with MCP Inspector
./scripts/run-mcp-inspector-local.sh

# Direct execution methods for debugging
# Method 1: Console script (after pip install -e .)
pip install -e .
mcp-mysql-ops --log-level DEBUG

# Method 2: Module execution
PYTHONPATH=src python -m mcp_mysql_ops --log-level DEBUG

# Test with different MySQL versions
# Modify MYSQL_HOST in .env to point to different MySQL instances

# Run tests (if you add any)
uv run pytest

Testes de Compatibilidade de Versão

O servidor MCP se adapta automaticamente às versões MySQL 5.7.9+ e 8.0+. Para testar entre versões:

Configure bancos de dados de teste: Diferentes versões MySQL (5.7, 8.0, 8.1+)
Execute testes de compatibilidade: Aponte para cada versão e verifique o comportamento das ferramentas
Verifique a detecção de recursos: Garanta a detecção adequada de versão e disponibilidade de recursos
Verifique o desempenho: Confirme o desempenho ideal em todas as versões MySQL

Notas de Segurança

Todas as ferramentas são somente leitura - sem capacidades de modificação de dados
Informações sensíveis (senhas) são mascaradas nas saídas
Sem execução direta de SQL - apenas consultas predefinidas e seguras
Segue o princípio do menor privilégio
Compatível com as melhores práticas de segurança do MySQL

Contribuindo

🤝 Tem ideias? Encontrou bugs? Quer adicionar recursos legais?

Estamos sempre animados em receber novos colaboradores! Seja corrigindo um erro de digitação, adicionando uma nova ferramenta de monitoramento ou melhorando a documentação - cada contribuição torna este projeto melhor.

Formas de contribuir:

🐛 Reporte problemas ou bugs
💡 Sugira novos recursos de monitoramento MySQL
📝 Melhore a documentação
🚀 Envie pull requests
⭐ Dê uma estrela no repositório se achar útil!

Dica profissional: O código foi projetado para ser super amigável para adicionar novas ferramentas. Confira as funções @mcp.tool() existentes em mcp_main.py.

Documentação Swagger MCPO

[URL Swagger MCPO] http://localhost:8004/mysql-ops/docs

MCPO Swagger APIs

Licença

Use, modifique e distribua livremente sob a Licença MIT.

⭐ Outros Projetos

Outros servidores MCP do mesmo autor: