Banco de DadosInteligência Artificial

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

O MCP Server implementa o Modular Code Protocol, padrão open‑source criado pela Anthropic para que agentes de IA conversem com APIs ou bancos de dados em linguagem natural. Em vez de escrever SQL ou rotas REST, basta perguntar “Quantos clientes moram no bairro Centro?” e o MCP Server traduz a frase na consulta correta — sem prompts extensos nem detalhes de endpoint.

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

  1. Entende a intenção em linguagem natural.
  2. Mapeia a frase para a tool correta (query SQL, POST, GET).
  3. Executa a operação e devolve a resposta formatada.
O resultado são integrações no‑code, rápidas e seguras.

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:
  1. Criar um banco SQLite com tabela de clientes
  2. Configurar o MCP Server com nossas tools
  3. Conectar um cliente e realizar consultas em linguagem natural
Nos passos a seguir, vou mostrar os códigos necessários para configurar o ambiente e implementar as ferramentas que permitirão consultas como “Quantos clientes moram no Centro?” diretamente contra nosso banco de dados.

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!") 
				
			
Este script cria um banco de dados SQLite chamado “clientes.db”, define uma tabela com campos para nome, bairro e outros dados pessoais, e então insere 50 clientes com informações aleatórias, mas realistas.

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:

  1. Abra o terminal ou prompt de comando
  2. 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"
      ]
    }
  }
}
				
			
Esta configuração informa ao Claude exatamente como iniciar e se comunicar com seu servidor MCP. O nome “ClientesMCP” é o identificador que você definiu no comando de instalação e o caminho completo para o arquivo server.py é automaticamente registrado. Após executar este comando, o Claude Desktop estará conectado ao seu servidor MCP e você poderá fazer perguntas como:
  • “Quantos clientes moram no Centro?”
  • “Existe algum cliente chamado Maria?”
  • “Liste todos os clientes do Jardim Botânico”
O Claude interpretará essas perguntas em linguagem natural e usará automaticamente as ferramentas corretas do seu servidor MCP para obter as respostas, sem que você precise escrever uma única linha de SQL!

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.

Artigos relacionados

0 0 votos
Article Rating
Inscrever-se
Notificar de
guest
0 Comentários
mais antigos
mais recentes Mais votado
Feedbacks embutidos
Ver todos os comentários
Botão Voltar ao topo