LangChain com MCP: Conectando ferramentas com flexibilidade e interoperabilidade

Parte 5 da série "Tudo o Que Você Precisa Saber Sobre LangChain (Antes de Começar um Projeto com IA)"

Bem-vindo(a)s ao quinto post da nossa série sobre LangChain!

No post anterior, vimos como criar agentes com LangChain. Continuando com esse assunto, hoje vamos ver como usar Model Context Protocol (MCP) com LangChain e LangGraph.

Essa integração permite criar agentes mais robustos, com as ferramentas (tools) conectadas via um padrão aberto e interoperável.

Quer mais novidades de IA? Me siga no Linkedin e no Instagram !

O que é o MCP?

O Model Context Protocol é um protocolo padronizado desenvolvido pela Anthropic que permite a comunicação entre modelos de linguagem e ferramentas externas de forma estruturada e segura.

Ele resolve um dos maiores desafios no desenvolvimento de aplicações de IA: a integração consistente com APIs, bancos de dados e outros serviços.

O MCP facilita a reutilização e o acoplamento de tools em ambientes heterogêneos, útil em contextos de produção ou quando há necessidade de interoperar com sistemas externos.

Veja mais: O que é MCP, Criando seu servidor MCP, diferença entre A2Ae MCP.

Por que usar MCP com LangChain?

O LangChain já é conhecido por sua flexibilidade na criação de aplicações com LLMs, e a integração com MCP traz grandes benefícios como:

• Padronização: O MCP oferece uma interface consistente para qualquer ferramenta, eliminando a necessidade de adaptadores personalizados para cada API

• Segurança: O protocolo inclui mecanismos nativos de autenticação e controle de acesso, garantindo interações seguras com sistemas externos

• Flexibilidade: Suporte nativo para diferentes tipos de ferramentas, desde APIs REST simples até sistemas complexos de banco de dados

Por onde começar?

A equipe da LangChain já disponibilizou um repositório com os adaptadores oficiais: langchain-ai/langchain-mcp-adapters.

Com esses adaptadores, é possível registrar ferramentas no padrão MCP e usá-las diretamente nos agentes do LangChain, com suporte para chamadas via stdio, http, entre outros transportes.

Fonte: https://github.com/langchain-ai/langchain-mcp-adapters

Exemplos práticos

Agora, vamos colocar essa integração em prática. Vamos criar alguns exemplos que mostram como nosso agente se conecta a ferramentas externas via MCP. Você verá como o agente interpreta suas perguntas, seleciona automaticamente a ferramenta ideal e entrega a resposta correta.

1) Aplicação para converter medidas de temperatura

Vamos começar com um exemplo simples com uma ferramenta que converte temperatura entre graus Celsius, Fahrenheit e Kelvin.

Primeiro, vamos criar nosso servidor, usando FastMCP. Copie e cole o código abaixo em um arquivo chamado temperature_server.py.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("TemperatureConverter")

@mcp.tool()
def celsius_to_fahrenheit(celsius: float) -> str:
    """Converte temperatura de Celsius para Fahrenheit"""
    fahrenheit = (celsius * 9/5) + 32
    return f"{celsius}°C é igual a {fahrenheit:.2f}°F"

@mcp.tool() 
def fahrenheit_to_celsius(fahrenheit: float) -> str:
    """Converte temperatura de Fahrenheit para Celsius"""
    celsius = (fahrenheit - 32) * 5/9
    return f"{fahrenheit}°F é igual a {celsius:.2f}°C"

@mcp.tool()
def kelvin_to_celsius(kelvin: float) -> str:
    """Converte temperatura de Kelvin para Celsius"""
    celsius = kelvin - 273.15
    return f"{kelvin}K é igual a {celsius:.2f}°C"

if __name__ == "__main__":
    mcp.run(transport="stdio")

Agora, vamos criar nossa aplicação cliente, que vai ter acesso à essas ferramentas.

Vamos usar o Gemini como LLM principal da aplicação, mas você pode optar por outros modelos. No arquivo Langchain-primeiros-passos.ipynb, há exemplos de como integrar diferentes LLMs no LangChain, inclusive rodando localmente com Ollama.