Ferramentas de IA são fantásticas, mas percebi que, para o aprendizado, elas podem se tornar um obstáculo, entregando respostas prontas e inibindo o processo de descoberta.
Eu sempre serei a favor de um pair-programming bem-feito, com alguém que guie os alunos na resolução de problemas, em vez de simplesmente dar a solução.
Foi com esse objetivo que criei o youmentor: um projeto para transformar um agente de IA, como o Gemini, em um assistente de mentoria usando o Model Context Protocol (MCP).
A ideia era criar um ‘modo mentor’ que incentivasse o raciocínio e a criatividade, ajudando o aluno a dar o próximo passo, sem revelar o final do caminho.
Neste artigo, vou compartilhar como utilizei o Spring AI e o MCP para construir essa ferramenta para os meus cursos.
🤔 O que eu queria alcançar?#
Aprender a programar, ou a aprimorar nossas habilidades, muitas vezes nos leva a um ciclo de tutoriais e documentações. O problema é que a maioria desses recursos nos entrega a solução pronta.
É como aprender a cozinhar apenas lendo a receita, sem nunca pegar nos ingredientes.
Eu queria algo diferente. Um ambiente de aprendizado onde meus alunos pudessem:
- Praticar com exercícios reais: Ter um catálogo de exercícios para colocar a mão na massa.
- Receber orientação, não respostas: Ter um mentor que os ajudasse a pensar, a depurar o código e a entender os conceitos por trás, sem dar a solução de graça.
- Aprender no seu ritmo: Um mentor paciente que estivesse sempre disponível quando precisassem.
Eu já tinha os exercícios, as boas práticas e os exemplos de soluções. Precisava que o Gemini CLI entendesse o ‘modo mentor’, e foi aí que decidi utilizar o MCP junto com o Spring AI para criar essa funcionalidade.
🧩 O que é MCP e como ele resolve o problema?#
O MCP (Model Context Protocol) é um padrão de protocolo de comunicação open-source que serve como uma ponte entre aplicações de IA e sistemas externos.
Sabe quando você quer que o Claude ou o ChatGPT conversem com seus arquivos, um banco de dados ou até mesmo usem uma calculadora?
O MCP torna isso possível. Ele permite que a IA acesse fontes de dados, ferramentas e até fluxos de trabalho específicos para que ela possa executar tarefas e buscar informações por conta própria.
Pense no MCP como uma porta USB-C para aplicações de IA. Assim como o USB-C virou o padrão para conectar praticamente qualquer eletrônico, o MCP oferece um jeito padronizado de plugar sistemas externos em uma IA.
Simples assim.
No nosso caso, o youmentor é um servidor que ‘fala’ MCP.
Ele usa esse protocolo para enviar um pacote de contexto para o Gemini, transformando-o em um mentor de programação.
Esse pacote de contexto inclui:
- A Persona do Mentor: Instruções claras de como ele deve se comportar.
- Ferramentas (Tools): Funções que o mentor pode usar, como
listar_exerciciosouiniciar_mentoria. - Recursos (Resources): Os dados que o mentor pode consultar, como o conteúdo de uma lição.
Com o MCP, conseguimos ‘programar’ o comportamento do agente de IA em tempo real, garantindo que ele atue como um verdadeiro mentor para os alunos.
🚀 Como implementar com Spring AI#
Para colocar tudo isso de pé, usei o Spring AI, um projeto da Spring que facilita a integração de aplicações Java com AI Agents.
Criei um servidor MCP com um serviço principal, o ContentService, que expõe duas ferramentas para o Gemini:
list_exercises: Lista os exercícios disponíveis para o aluno.start_mentoring: Inicia uma sessão de mentoria de um exercício específico.
Veja uma versão simplificada do ContentService:
@Service
public class ContentService {
// ...
@Tool(description = """
Switch the LLM into mentor mode for a specific programming exercise.
This tool loads the mentoring instructions, exercise materials, and reference solutions,
then returns everything needed to conduct a guided programming mentoring session.
CRITICAL: After calling this tool, the LLM MUST adopt the mentor persona defined in prompt.xml
and follow these mentoring principles:
- NEVER give direct solutions or complete code answers
- Help debug by asking about thought process and error analysis
- Encourage problem-solving skills rather than providing answers
- Use the exercise content as teaching framework
- Reference the solution files ONLY for your own understanding, never reveal them directly
After this tool is called and the context is loaded, your first action is to greet the user with a brief, encouraging message in Brazilian Portuguese, like 'bom exercicio! se precisar de ajuda pergunte para mim ou chame o mentor!'. Then, wait for the user to ask a question or provide code.
Use this when a learner wants to work on a specific programming exercise and needs guided mentoring.
Always call list_exercises first to let the user choose an exercise.
""", name = "start_mentoring")
public ExerciseContent startMentoring(@ToolParam(description = """
The unique identifier of the exercise to mentor.
Must be one of the exercise IDs returned by list_exercises.
Example: 'solid/01-basic-algorithms' or 'java-basics/15-data-structures'
"""
) String exerciseId) {
// ...
}
@Tool(description = """
Browse the complete catalog of available programming exercises.
Returns all exercises with their technical IDs and human-readable titles.
Use this when:
- A learner wants to see what exercises are available
- You need to help a learner choose an appropriate exercise
- A learner asks "what can I work on?" or "show me available exercises"
After getting the list, present the exercises to the user and let them choose one.
Then use start_mentoring with their chosen exercise ID.
""", name = "list_exercises")
public ListOfExercises listAvailableExercises() {
// ...
}
// ...
}
A anotação @Tool do Spring AI é o que faz a mágica acontecer, expondo esses métodos como “ferramentas” que o Gemini pode usar.
Percebam que a descrição da ferramenta é bem extensa e completa. Isso é uma das dicas mais importantes para criar um MCP, pois é essa descrição que o agente de IA utiliza para decidir quando usar a ferramenta.
A diferença é clara:
- Com uma descrição simples: Você precisaria ser explícito.
$ Você pode listar os exercícios usando o list_exercises? - Com uma descrição detalhada: O agente infere a intenção.
$ Quero começar uma mentoria!
Uma boa descrição torna a interação mais natural e poderosa. Fica a dica!
Com o ContentService pronto, a ‘mágica’ do Spring Boot continua.
Tudo se conecta na classe principal da aplicação, a YoureadyApplication. Graças à anotação @SpringBootApplication, o Spring escaneia o projeto, encontra componentes como o nosso ContentService e os gerencia para nós.
Na classe principal, o passo final é expor o ContentService como um conjunto de ferramentas para o agente de IA.
@SpringBootApplication
public class YoureadyApplication {
public static void main(String[] args) {
SpringApplication.run(YoureadyApplication.class, args);
}
@Bean
public ToolCallbackProvider mentorTools(ContentService contentService) {
return MethodToolCallbackProvider.builder().toolObjects(contentService).build();
}
}
A linha que utiliza o MethodToolCallbackProvider é crucial aqui.
Essa classe do Spring AI permite registrar qualquer objeto (neste caso, nosso contentService) que contenha métodos anotados com @Tool.
Dessa forma, o Spring AI consegue:
Identificar os métodos.
Expor esses métodos via MCP como ferramentas que o agente de IA pode invocar.
É como dizer ao Spring AI: “Ei, esses são os superpoderes que o meu ContentService tem. Disponibilize-os para o agente de IA!”
Com essa estrutura, o Gemini CLI se tornou a minha interface para interagir com o mentor. A partir da linha de comando, eu podia listar os exercícios, escolher um e começar a praticar.
Colocando para Rodar: Configuração e Teste#
A configuração final envolve duas etapas principais:
1. Configurar o Servidor MCP
O Spring AI oferece flexibilidade na comunicação com o agente de IA. No projeto, utilizei SSE (Server-Sent Events).
Para isso, basta ajustar o arquivo application.properties:
# Enables the reactive web server (WebFlux) for the streamable SSE transport.
spring.main.web-application-type=reactive
# Sets the server type to ASYNC, recommended for reactive applications.
spring.ai.mcp.server.type=ASYNC
# Standard web server port.
server.port=8080
# Graceful shutdown configuration.
server.shutdown=graceful
2. Conectar o Servidor ao Gemini CLI
Em seguida, precisamos informar ao Gemini CLI onde encontrar nosso servidor. Isso é feito no arquivo settings.json.
Você pode editar o arquivo em diferentes escopos:
- Global (Usuário):
~/.gemini/settings.json - Local (Projeto):
.gemini/settings.json(na raiz do projeto) - Sistema (Linux):
/etc/gemini-cli/settings.json
A configuração é simples:
{
"mcpServers": {
"youmentor": {
"url": "http://localhost:8080/sse"
}
}
}
3. Subir o Servidor e Testar
Com tudo configurado, basta subir o servidor:
./gradlew bootRun
E iniciar o Gemini CLI. Se tudo estiver ok, o CLI será capaz de utilizar o MCP Server e se transformar no seu novo mentor!
✨ Dicas e Truques#
Durante essa jornada, aprendi algumas lições que podem ser úteis:
- Use o MCP Inspector para depurar: Essa ferramenta foi essencial para visualizar a comunicação entre o Gemini e meu servidor, facilitando a identificação de problemas.
- Capriche na descrição das ferramentas: A descrição na anotação
@Toolé o que o agente de IA usa para decidir quando usar sua ferramenta. Quanto mais clara e detalhada, mais autônomo e preciso ele se torna. - Esteja preparado para ‘alucinações’: Mesmo com um contexto bem definido, os modelos de linguagem podem, ocasionalmente, desviar do comportamento esperado. Ajustes e monitoramento contínuo são importantes.**
Conclusão#
Criar um mentor de programação com Spring AI e Gemini CLI foi uma experiência incrível. Mais do que apenas um projeto de programação, foi um exercício de como podemos usar AI Agents para criar ferramentas de aprendizado mais eficazes e personalizadas.
Ainda estou no começo da jornada, mas o potencial é enorme. Imagina ter um mentor para qualquer linguagem ou framework, disponível a qualquer hora do dia?
O que você achou da ideia? Já pensou em criar suas próprias ferramentas de aprendizado com IA?
Comenta aí e vamos trocar uma ideia!
🥒🥒 Espero que tenham curtido e até o próximo artigo! 🥒🥒