MCP Server: Conecte Sua IA ao Banco de Dados em 5 Minutos

Conteúdo
Antes do MCP Server: Por Que Era Tão Difícil?
Problema | Impacto |
---|---|
Prompts extensos para cada endpoint | Tempo perdido e alto risco de erro |
Conhecer parâmetros de API (tokens, filtros…) | Curva de aprendizado íngreme |
Integrações ponto‑a‑ponto | Código repetido e difícil de manter |
Como o MCP Server Resolve o Problema
- Entende a intenção em linguagem natural.
- Mapeia a frase para a tool correta (query SQL, POST, GET).
- Executa a operação e devolve a resposta formatada.
Vantagens do MCP Server
- Simplicidade: nenhuma rota REST para manter.
- Escalabilidade: adicione novas tools sem alterar o cliente.
- Segurança: tokens e logs centralizados.
- Portabilidade: qualquer cliente MCP (chatbot, CLI, IDE) conecta‑se em segundos.
O Que Dá Para Fazer com MCP Server?
Pedido em linguagem natural | Ação do MCP Server |
---|---|
“Quantos clientes existem?” | contar_clientes() → total geral |
“Quantos clientes moram no bairro Centro?” | contar_clientes(bairro="Centro") |
“Existe cliente chamado Maria?” | buscar_cliente_por_nome("Maria") |
“Liste clientes do bairro Jardim Botânico” | buscar_cliente_por_bairro("Jardim Botânico") |
“Mostre estatísticas de clientes” | Recurso clientes://estatisticas → totais e ranking por bairro |
Exemplo Prático
Vamos demonstrar como implementar o MCP Server na prática usando a biblioteca python-sdk do Model Context Protocol. Para nosso exemplo, utilizaremos um banco de dados SQLite no qual criaremos uma tabela de clientes e popularemos com dados de teste. O processo envolve:- Criar um banco SQLite com tabela de clientes
- Configurar o MCP Server com nossas tools
- Conectar um cliente e realizar consultas em linguagem natural
Passo 1: Criar uma tabela de clientes e popular com dados
Primeiro, vamos criar um banco de dados SQLite com uma tabela de clientes e populá-la com 50 registros usando a biblioteca Faker, que gera dados realistas para testes:
import sqlite3
import random
from faker import Faker
fake = Faker('pt_BR')
bairros = ['Centro', 'Jardim América', 'Vila Nova', 'Bela Vista']
def create_database():
conn = sqlite3.connect('clientes.db')
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS clientes (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nome TEXT NOT NULL,
email TEXT,
telefone TEXT,
bairro TEXT NOT NULL,
endereco TEXT
)
''')
for _ in range(50):
nome = fake.name()
email = fake.email()
telefone = fake.phone_number()
bairro = random.choice(bairros)
endereco = fake.street_address()
cursor.execute('''
INSERT INTO clientes (nome, email, telefone, bairro, endereco)
VALUES (?, ?, ?, ?, ?)
''', (nome, email, telefone, bairro, endereco))
conn.commit()
conn.close()
if __name__ == '__main__':
create_database()
print("Database created and populated with 50 sample records!")
Passo 2: Implementar o servidor MCP
Agora vamos criar nosso servidor MCP que permitirá consultas em linguagem natural ao banco de dados:
import sqlite3
import sys
from mcp.server.fastmcp import FastMCP
mcp = FastMCP(
"Servidor de Clientes SQLite",
port=8000,
host="0.0.0.0"
)
# Função para conectar ao banco
def conectar_bd():
import os
script_dir = os.path.dirname(os.path.abspath(__file__))
db_path = os.path.join(script_dir, 'clientes.db')
return sqlite3.connect(db_path)
# Ferramenta 1: Contar clientes
@mcp.tool()
def contar_clientes(bairro: str = None) -> dict:
"""
Conta o número total de clientes, opcionalmente filtrado por bairro.
Args:
bairro: Opcional - Nome do bairro para filtrar a contagem
Returns:
Um dicionário com o total de clientes e o filtro usado
"""
conn = conectar_bd()
cursor = conn.cursor()
if bairro:
cursor.execute("SELECT COUNT(*) FROM clientes WHERE bairro = ?", (bairro,))
else:
cursor.execute("SELECT COUNT(*) FROM clientes")
total = cursor.fetchone()[0]
conn.close()
return {
"total_clientes": total,
"filtro_bairro": bairro
}
# Ferramenta 2: Buscar cliente por nome
@mcp.tool()
def buscar_cliente_por_nome(nome: str) -> dict:
"""
Busca clientes pelo nome (busca parcial).
Args:
nome: Nome ou parte do nome do cliente para buscar
Returns:
Um dicionário com os resultados da busca
"""
if not nome:
return {"erro": "Nome não fornecido", "clientes": []}
conn = conectar_bd()
cursor = conn.cursor()
cursor.execute("SELECT id, nome, email, telefone, bairro, endereco FROM clientes WHERE nome LIKE ?", (f'%{nome}%',))
resultados = cursor.fetchall()
clientes = []
for cliente in resultados:
clientes.append({
"id": cliente[0],
"nome": cliente[1],
"email": cliente[2],
"telefone": cliente[3],
"bairro": cliente[4],
"endereco": cliente[5]
})
conn.close()
return {
"termo_busca": nome,
"resultados_encontrados": len(clientes),
"clientes": clientes
}
# Ferramenta 3: Buscar cliente por bairro
@mcp.tool()
def buscar_cliente_por_bairro(bairro: str) -> dict:
"""
Busca clientes pelo bairro.
Args:
bairro: Nome do bairro para buscar clientes
Returns:
Um dicionário com os resultados da busca
"""
if not bairro:
return {"erro": "Bairro não fornecido", "clientes": []}
conn = conectar_bd()
cursor = conn.cursor()
cursor.execute("SELECT id, nome, email, telefone, bairro, endereco FROM clientes WHERE bairro LIKE ?", (f'%{bairro}%',))
resultados = cursor.fetchall()
clientes = []
for cliente in resultados:
clientes.append({
"id": cliente[0],
"nome": cliente[1],
"email": cliente[2],
"telefone": cliente[3],
"bairro": cliente[4],
"endereco": cliente[5]
})
conn.close()
return {
"termo_busca": bairro,
"resultados_encontrados": len(clientes),
"clientes": clientes
}
@mcp.resource("clientes://estatisticas")
def get_estatisticas_clientes() -> str:
conn = conectar_bd()
cursor = conn.cursor()
cursor.execute("SELECT COUNT(*) FROM clientes")
total = cursor.fetchone()[0]
cursor.execute("SELECT bairro, COUNT(*) as total FROM clientes GROUP BY bairro ORDER BY total DESC")
bairros = cursor.fetchall()
conn.close()
resultado = f"Total de clientes: {total}\n\n"
resultado += "Clientes por bairro:\n"
for bairro in bairros:
resultado += f"- {bairro[0]}: {bairro[1]} clientes\n"
return resultado
try:
import os
cwd = os.getcwd()
print(f"Diretório de trabalho atual: {cwd}", file=sys.stderr)
if os.path.exists('/Users/amaury/Projetos/python/mcp-teste/clientes.db'):
print("O arquivo clientes.db existe no caminho esperado", file=sys.stderr)
else:
print("O arquivo clientes.db NÃO existe no caminho esperado", file=sys.stderr)
conn = conectar_bd()
cursor = conn.cursor()
cursor.execute("SELECT COUNT(*) FROM clientes")
total = cursor.fetchone()[0]
conn.close()
print(f"Banco de dados conectado com sucesso. Total de clientes: {total}", file=sys.stderr)
except Exception as e:
print(f"ERRO: Não foi possível conectar ao banco de dados: {e}", file=sys.stderr)
print("Certifique-se de que o arquivo 'clientes.db' existe e foi populado corretamente.", file=sys.stderr)
import os
script_dir = os.path.dirname(os.path.abspath(__file__))
print(f"Diretório do script: {script_dir}", file=sys.stderr)
exit(1)
if __name__ == "__main__":
print("Iniciando servidor MCP com transporte SSE na porta 8000...", file=sys.stderr)
mcp.run(transport="sse")
Este código registra três ferramentas (tools) que permitem consultar nosso banco de dados: contar clientes, buscar por nome e buscar por bairro. O MCP Server entenderá consultas em linguagem natural e as traduzirá para as chamadas de função apropriadas.
Passo 3: Conectar um cliente e começar a usar
Por fim, vamos conectar o Claude Desktop como cliente para interagir com nosso servidor:
- Abra o terminal ou prompt de comando
- Execute o comando de instalação do servidor MCP, onde “server.py” é o nome do arquivo que criamos no Passo 2:
mcp install server.py --name "ClientesMCP"
Este comando registra nosso servidor MCP no Claude Desktop, criando uma configuração no arquivo JSON do Claude. A configuração ficará similar a esta:
{
"mcpServers": {
"ClientesMCP": {
"command": "uv",
"args": [
"run",
"--with",
"mcp[cli]",
"mcp",
"run",
"/Users/amaury/Projetos/python/mcp-teste/server.py"
]
}
}
}
- “Quantos clientes moram no Centro?”
- “Existe algum cliente chamado Maria?”
- “Liste todos os clientes do Jardim Botânico”
FAQ: Perguntas Frequentes sobre MCP Server
Quem criou o MCP Server?
O protocolo é mantido como open‑source pela Anthropic.Preciso programar para usar um MCP Server?
Não para consumir: basta um cliente MCP. Para criar servidores, poucas linhas de código registram suas tools.Posso conectar qualquer banco de dados?
Sim. Registre tools que executem queries no banco desejado (PostgreSQL, MySQL, SQLite, MongoDB etc.).Quais clientes já suportam MCP?
Chatbots OpenAI (via function calling), Claude, Cursor IDE e CLIs que implementem o protocolo.Como proteger meu MCP Server?
Use HTTPS, tokens de acesso e escopos por tool. O log interno ajuda a auditar cada chamada.Transforme sua Experiência com IA usando MCP Server Hoje
Em 5 minutos você conecta sua IA ao banco de dados usando MCP Server. Menos código, menos manutenção e muito mais velocidade para suas automações. Experimente hoje mesmo e descubra como a integração pode ser realmente simples.
Este artigo faz parte de uma série sobre Inteligência Artificial que venho desenvolvendo em meu blog. Se você gostou deste conteúdo, também pode se interessar por outros temas relacionados, como a integração entre Power BI e ChatGPT para simplificar medidas DAX, onde exploro como a IA pode potencializar suas análises de dados.