MCP Server na Prática

Bem-vindo(a) à aula inaugural do nosso curso prático de MCP Server! Nesta introdução, vamos apresentar a jornada completa que você irá percorrer: a construção de um sistema do zero. Você aprenderá a desenvolver um mini-framework em Python que se comunica com um banco de dados e a expor essa funcionalidade como um MCP Server, permitindo que uma Inteligência Artificial o controle. Apresentaremos a estrutura do curso, desde a criação de uma interface de linha de comando (CLI) para testes funcionais até a configuração final, deixando claro que nosso foco está no desenvolvimento do servidor e na sua interação com o ecossistema de IA.

Prepare-se para descobrir o futuro da interação com software, pois demonstraremos como você utilizará o VS Code Insiders e o GitHub Copilot para "conversar" com sua aplicação usando linguagem natural. O ponto alto que exploraremos é a capacidade do agente de IA de realizar operações complexas que não foram diretamente programadas, um resultado que o instrutor descreve como "maravilhoso". Esta aula define o cenário para uma experiência de aprendizado prática, na qual você não apenas codificará, mas testemunhará o poder da IA em ação, com o nosso compromisso de apoiar sua jornada e manter o conteúdo sempre atualizado.

Esta aula teórica aborda os seguintes conceitos fundamentais sobre o Model-Context-Protocol (MCP):

• A desmistificação do termo "MCP Server" e a explicação de por que ele pode ser ambíguo em comparação com um servidor de infraestrutura tradicional.

• A apresentação da analogia que compara o MCP ao "USB-C para IA", para ilustrar seu propósito de padronização.

• A definição da arquitetura de três peças do ecossistema: o MCP Host, o MCP Client e o MCP Server.

• A explicação sobre a origem do nome "Model Context Protocol" e sua provável inspiração no Language Server Protocol (LSP).

• Uma introdução às polêmicas e às questões de segurança que envolvem o framework.

• Um encerramento que prepara o aluno para a próxima aula, que será focada na codificação prática.

Nesta primeira aula prática, começamos a preparar nosso ambiente de desenvolvimento para construir o MCP Server. O instrutor, Igor Medeiros, guia o passo a passo da instalação das ferramentas pré-requisito essenciais para o curso.

Tópicos abordados nesta aula:

• Instalação do VS Code Insiders: Você aprenderá a baixar e instalar o VS Code Insiders, que é a versão de desenvolvimento do editor e será o nosso "MCP Host". O vídeo demonstra o processo completo:

  • Pesquisar e encontrar a página oficial de download.

  • Fazer o download do instalador correto para o sistema operacional (neste caso, Windows x64).

  • Executar o instalador, aceitar os termos e seguir as etapas de configuração, incluindo a criação de um atalho na área de trabalho e a adição das opções de menu de contexto.

• Contextualização do NodeJS: O instrutor menciona que a instalação do NodeJS também é um pré-requisito. Ele esclarece que, embora o NodeJS não seja estritamente necessário para o projeto específico que construiremos neste curso, ele é fundamental para quem deseja instalar outros MCPs no futuro.

• Referência da Wiki: Durante a instalação, é mencionado que todos os passos seguem um guia disponível na Wiki do projeto, que pode servir como material de consulta para você.

Ao final desta aula, você terá o VS Code Insiders corretamente instalado e estará pronto para a próxima etapa, que será configurar o editor para começar a interagir com o ecossistema MCP.

Esta aula rápida foca na instalação de um pré-requisito essencial para o ambiente de desenvolvimento do curso: o gerenciador de pacotes uv.

Tópicos abordados nesta aula:

• Comando de Instalação: O instrutor abre um terminal PowerShell e executa o comando pip install uv para instalar a ferramenta.

• Justificativa do Uso do uv: Após a instalação bem-sucedida, é explicado que o uv é utilizado no lugar do pip por ser mais moderno e rápido, além de implementar funcionalidades que o pip não possui por ser baseado em uma PEP mais antiga.

Nesta aula, o instrutor demonstra como verificar e habilitar as configurações necessárias no VS Code Insiders para que ele possa descobrir e interagir com MCP Servers.

Tópicos abordados nesta aula:

• Acesso às Configurações: O vídeo mostra como acessar o painel de configurações (Settings) do VS Code.

• Busca pela Configuração MCP: É demonstrado como pesquisar por "mcp" para encontrar as configurações relevantes.

• Verificação da Habilitação do Agente: O ponto principal é a verificação da configuração Chat > Agent: Msp Discovery Enabled, que deve estar marcada para permitir a descoberta de servidores MCP. O instrutor também mostra que essa configuração corresponde a uma entrada no arquivo settings.json.

• Confirmação Visual no Chat: A confirmação de que a configuração está correta é a aparição do ícone de engrenagem (tools) no painel de Chat, que só fica visível quando o "Agent mode" está ativo. Ao clicar neste ícone, é possível ver as ferramentas já configuradas e adicionar novas.

Nesta aula, o instrutor mostra como iniciar e estruturar o projeto que servirá de base para o MCP Server, utilizando a ferramenta uv e separando as responsabilidades em diferentes módulos.

Tópicos abordados nesta aula:

• Estrutura do Projeto: É explicado que o objetivo é criar uma API simples que conversa com um banco de dados SQLite e que, posteriormente, será exposta via MCP Server.

• Inicialização do Projeto com uv: A aula demonstra o processo de criação e configuração inicial do projeto:

  • Criação do diretório do projeto (mcp-loja).

  • Inicialização do projeto com o comando uv init, que gera o arquivo pyproject.toml.

  • Criação de um ambiente virtual isolado com uv venv.

  • Ativação do ambiente virtual.

• Organização do Código: É criada a pasta src para abrigar o código-fonte da aplicação, e o projeto é aberto no VS Code para as próximas etapas.

Nesta aula, você aprenderá a estruturar o projeto criando os módulos responsáveis pela configuração inicial do banco de dados e pela lógica de negócio que irá interagir com ele.

Tópicos abordados nesta aula:

• Criação do Módulo de Setup do Banco de Dados: É criado o arquivo setup_db.py. Este módulo contém a função create_database, que utiliza sqlite3 para se conectar e executar os comandos SQL CREATE TABLE IF NOT EXISTS para as tabelas customers, cars e sales, definindo o esquema de dados da aplicação.

• Criação do Módulo de API de Negócios: Em seguida, é criado o arquivo sales_api.py, que centralizará todas as funções que manipulam os dados.

• Implementação das Funções da API: O instrutor demonstra o código para as funções de negócio, como add_customer, get_customers, add_car, get_cars, add_sale e get_sales. Cada uma dessas funções encapsula uma operação específica no banco de dados, como INSERT ou SELECT, garantindo que a lógica de acesso aos dados esteja bem definida e separada do resto da aplicação.

Antes de expor nossa lógica de negócio a um agente de IA, é fundamental garantir que ela funcione de forma isolada e testável. Nesta aula, você aprenderá a criar uma Interface de Linha de Comando (CLI) com a biblioteca Typer para atuar como uma camada de "controller" e validar a nossa API.

Tópicos abordados nesta aula:

• Criação do CLI: É criado o arquivo app_cli.py, que importará as funções do módulo sales_api.py e as exporá como comandos no terminal.

• Uso do Decorator @app.command(): Você verá como o decorador da biblioteca Typer transforma funções Python em comandos de terminal, que podem ser facilmente executados e testados.

• Testes Funcionais via Terminal: A aula demonstra o ciclo completo de testes usando a CLI:

  • A tentativa de criar um cliente falha porque o banco de dados não existe.

  • O comando new-database é executado para criar o banco e as tabelas com sucesso.

  • A criação de múltiplos clientes (Igor, Maria Joaquina) agora funciona corretamente.

  • O comando list-customers é executado para verificar que os dados foram persistidos corretamente no banco.

• Validação da Lógica: Ao final, o instrutor reforça que, com a API testada e validada através da CLI, temos a segurança de que a lógica está correta para então prosseguir e expô-la via MCP Server.

Nesta aula, transformamos nossa aplicação em um MCP Server, expondo a lógica de negócio que criamos anteriormente como tools que um agente de IA poderá consumir.

Tópicos abordados nesta aula:

• Adição da Dependência MCP: O primeiro passo prático é adicionar a biblioteca do MCP ao projeto usando o comando uv add "mcp[cli]".

• Criação do Arquivo do Servidor: É criado um novo arquivo server.py na pasta src, que será o ponto de entrada para o nosso servidor.

• Estrutura Básica do Servidor: O instrutor implementa a estrutura mínima de um servidor usando a biblioteca FastMCP. Isso inclui:

  • Importar FastMCP de mcp.server.fastmcp.

  • Criar uma instância do servidor: mcp = FastMCP("mcp-loja").

  • Adicionar o bloco if __name__ == "__main__" para executar o servidor com mcp.run(), especificando o protocolo de transporte stdio.

• Expondo Funções como Ferramentas (Tools): O conceito central da aula é "envelopar" as funções da nossa API com o decorador @mcp.tool().

  • É demonstrado como criar uma função async que atua como um wrapper, por exemplo, new_database(context: Context).

  • Dentro dessa função, chamamos a lógica original (ex: create_database(DB_FILE)) e utilizamos o context para enviar informações de log de volta ao Host.

  • É reforçada a importância de escrever docstrings detalhadas, pois elas são usadas pela LLM para entender o que a ferramenta faz.

Nesta aula, você aprenderá a utilizar a ferramenta mcp dev, também conhecida como MCP Inspector, para testar e depurar seu servidor de forma interativa, antes de conectá-lo a um cliente final como o VS Code.

Tópicos abordados nesta aula:

• Executando o MCP Inspector: A aula demonstra como iniciar a ferramenta com o comando uv run mcp dev src/server.py, que executa o servidor e abre uma interface web para inspeção.

• Conexão e Descoberta de Ferramentas: Você verá como se conectar ao servidor em execução através da interface do Inspector e, em seguida, listar todas as tools que foram expostas no arquivo server.py.

• Ciclo de Teste Interativo: O instrutor realiza um ciclo completo de testes diretamente na interface web para validar a lógica da aplicação:

  • Primeiro, tenta listar clientes e recebe um erro, pois o banco de dados ainda não foi criado.

  • Em seguida, executa a tool new_database para criar o banco de dados e as tabelas, recebendo uma mensagem de sucesso.

  • Executa novamente a listagem de clientes, que agora retorna uma resposta indicando que não há clientes cadastrados.

  • Cria um novo cliente (create_customer) com dados de exemplo.

  • Finalmente, lista os clientes mais uma vez e confirma que o novo cliente foi cadastrado com sucesso.

Nesta aula, você aprenderá o passo a passo para conectar o MCP Server que desenvolvemos ao seu ambiente de desenvolvimento, o VS Code Insiders, que funcionará como o "Host".

Tópicos abordados nesta aula:

• A configuração do MCP Server é feita de forma manual, utilizando o comando completo que executa o servidor através do uv run.

• É demonstrado como adicionar a ferramenta no VS Code através da opção "Add an MCP Server" no painel de Chat em "Agent Mode".

• A aula destaca a importância crucial do argumento --directory na configuração do comando, que especifica o diretório de trabalho correto para que o uv encontre o ambiente virtual e os arquivos do projeto.

• É apresentado um cenário comum de solução de problemas: o instrutor mostra que, após configurar o servidor, a conexão pode falhar e exigir um reinício do VS Code Insiders para que ele reconheça a nova ferramenta corretamente.

• Ao final, você verá o MCP Server (mcp-loja) conectado com sucesso ao Host, exibindo no painel de output as 8 ferramentas que foram desenvolvidas e disponibilizadas para o agente de IA.

Esta é a aula que conecta todo o aprendizado. Você verá na prática como interagir com o MCP Server que criamos, utilizando linguagem natural através do chat do VS Code Insiders com a extensão do GitHub Copilot.

Tópicos abordados nesta aula:

• Ambiente de Interação: O instrutor mostra a configuração com dois desktops virtuais: um para o desenvolvimento do servidor (MCP Server) e outro para a interação com o cliente (MCP Server Host).

• Execução de Ferramentas Simples: É demonstrado como o agente de IA compreende um pedido em linguagem natural, como "cadastre um novo cliente", e executa a ferramenta correta (create_customer), retornando o resultado esperado.

• Raciocínio da IA sobre os Dados: O ponto alto da aula é quando o instrutor faz uma pergunta subjetiva e complexa: "Quais carros que combinam com a 'vibe de dentista'?". O agente de IA utiliza a ferramenta list_cars, analisa os dados retornados e oferece uma sugestão com base em seu próprio raciocínio, selecionando o Toyota Corolla e o Honda Civic.

• Encadeamento de Ferramentas (Tool Chaining): Você verá o agente realizar uma tarefa complexa que exige múltiplas etapas. Ao receber o pedido para "vender o carro mais barato para o Beto", a IA:

  1. Executa a ferramenta para listar todos os carros.

  2. Identifica o carro mais barato (o VW Gol).

  3. Encontra o cliente "Beto" na base de dados.

  4. Executa a ferramenta create_sale passando os IDs corretos do cliente e do carro.

• Geração de Conteúdo Criativo: Ao final, é demonstrado como o agente de IA pode ir além da simples execução de ferramentas, criando mensagens de agradecimento personalizadas para cada cliente com base nas compras que realizaram.

Nesta aula final, o instrutor parabeniza pela conclusão do curso e recapitula os aprendizados, oferecendo um guia prático sobre quando e como utilizar o MCP Server de forma adequada e segura.

Tópicos abordados nesta aula:

• Parabéns e Resumo: Uma mensagem de parabéns por ter completado a jornada de desenvolvimento, teste e interação com o MCP Server.

• Guia de Decisão (Quando usar o MCP): O instrutor apresenta uma matriz de decisão para ajudar a escolher a ferramenta certa para cada caso de uso, com base em um estudo aprofundado. Os cenários incluem:

  • Ideal: Para back-ends de agentes de IA autônomos e ferramentas internas de desenvolvedor (DevTools).

  • Bom: Para microsserviços de IA especializados, onde o MCP serve como um idioma padrão de comunicação.

  • Inadequado/Alto Risco: Para APIs de propósito geral (CRUD), sistemas abertos ao público ou APIs que mudam constantemente. Nesses casos, alternativas como FastAPI ou GraphQL são mais indicadas.

• Considerações Finais: Um reforço sobre a importância de considerar as questões de segurança e o fato de o protocolo ainda ser muito novo (menos de um ano na data de gravação do vídeo), incentivando o aprendizado contínuo.

• Convite para Avaliação: Um pedido para que os alunos considerem avaliar o curso para ajudar a alcançar mais pessoas.