Home
Login
langchain-ai/langchain-mcp-adaptersPlease refer to the latest official releases for information GitHub Homepage

Wrapper leve que torna as ferramentas do Protocolo de Conteúdo do Modelo Antrópico (MCP) compatíveis com LangChain e LangGraph

MITPython 2.0klangchain-ai Last Updated: 2025-06-09

Adaptador LangChain MCP - Detalhes do Projeto

Visão Geral do Projeto

O Adaptador LangChain MCP é uma biblioteca wrapper leve projetada para integrar perfeitamente as ferramentas do Protocolo de Conteúdo de Modelos (MCP) da Anthropic com os ecossistemas LangChain e LangGraph. Este projeto resolve problemas de compatibilidade entre diferentes frameworks de ferramentas de IA, permitindo que os desenvolvedores usem ferramentas MCP diretamente em ambientes LangChain/LangGraph, construindo aplicações de agentes de IA mais poderosas e flexíveis.

Endereço do Projeto: https://github.com/langchain-ai/langchain-mcp-adapters

Funcionalidades e Características Principais

🔧 Conversão e Adaptação de Ferramentas

  • Conversão de Ferramentas MCP para LangChain: Converte automaticamente ferramentas MCP para o formato de ferramentas LangChain.
  • Integração Perfeita: As ferramentas convertidas podem ser usadas diretamente em agentes LangGraph.
  • Segurança de Tipo: Mantém as informações de tipo e a validação de parâmetros das ferramentas originais.
  • Suporte Assíncrono: Suporte completo para operações de ferramentas assíncronas.

📦 Cliente Multi-Servidor

  • Conexão Multi-Servidor: Conecta-se simultaneamente a múltiplos servidores MCP.
  • Gerenciamento Unificado de Ferramentas: Carrega e gerencia ferramentas de diferentes servidores.
  • Configuração de Servidor: Suporta configuração flexível de parâmetros do servidor.
  • Gerenciamento de Pool de Conexões: Gerenciamento eficiente de recursos de conexão.

🌐 Suporte a Protocolos de Transporte

  • Transporte STDIO: Suporta o protocolo de transporte de entrada e saída padrão.
  • Transporte SSE: Suporta o protocolo de transporte de eventos enviados pelo servidor (Server-Sent Events).
  • Mistura de Múltiplos Protocolos: Diferentes servidores podem usar diferentes protocolos de transporte.
  • Reconexão Automática: Mecanismo de reconexão automática em caso de desconexão.

🤖 Integração LangGraph

  • Agente React: Integração perfeita com o agente React do LangGraph.
  • Agente Assíncrono: Suporta execução assíncrona de agentes.
  • Combinação de Cadeias de Ferramentas: Suporta cadeias de ferramentas e fluxos de trabalho complexos.
  • Gerenciamento de Estado: Mantém o estado de execução do agente.

Arquitetura Técnica

Componentes Principais

Aplicação LangChain/LangGraph
         ↓
Adaptadores LangChain MCP
         ↓
Implementação do Cliente MCP
         ↓
Múltiplos Servidores MCP (Matemática, Clima, etc.)

Fluxo de Conversão de Ferramentas

  1. Descoberta de Ferramentas MCP: Obtém a lista de ferramentas disponíveis do servidor MCP.
  2. Análise de Metadados da Ferramenta: Analisa o nome, descrição e parâmetros da ferramenta.
  3. Criação de Ferramenta LangChain: Cria objetos de ferramenta LangChain compatíveis.
  4. Integração do Agente: Registra as ferramentas no agente LangGraph.
  5. Encaminhamento da Execução: Encaminha as chamadas de ferramenta LangChain para o servidor MCP.

Instalação e Uso

Instalação Rápida

# Instalação básica
pip install langchain-mcp-adapters

# Ambiente de desenvolvimento completo
pip install langchain-mcp-adapters langgraph langchain-openai

Configuração do Ambiente

# Defina a chave da API OpenAI
export OPENAI_API_KEY=<sua_api_key>

Exemplos de Uso

Exemplo Básico: Servidor de Matemática

1. Criar Servidor MCP

# math_server.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Math")

@mcp.tool()
def add(a: int, b: int) -> int:
    """Adiciona dois números"""
    return a + b

@mcp.tool()
def multiply(a: int, b: int) -> int:
    """Multiplica dois números"""
    return a * b

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

2. Criar Agente LangGraph

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# Inicializa o modelo
model = ChatOpenAI(model="gpt-4o")

# Configura os parâmetros do servidor
server_params = StdioServerParameters(
    command="python",
    args=["/path/to/math_server.py"],
)

# Cria o agente e executa
async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()
        
        # Carrega as ferramentas MCP
        tools = await load_mcp_tools(session)
        
        # Cria o agente
        agent = create_react_agent(model, tools)
        
        # Executa a consulta
        response = await agent.ainvoke({
            "messages": "quanto é (3 + 5) x 12?"
        })

Exemplo Avançado: Integração Multi-Servidor

1. Servidor de Clima

# weather_server.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Weather")

@mcp.tool()
async def get_weather(location: str) -> str:
    """Obtém o clima para a localização."""
    return f"Está sempre ensolarado em {location}"

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

2. Cliente Multi-Servidor

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4o")

# Configuração multi-servidor
async with MultiServerMCPClient({
    "math": {
        "command": "python",
        "args": ["/path/to/math_server.py"],
        "transport": "stdio",
    },
    "weather": {
        "url": "http://localhost:8000/sse",
        "transport": "sse",
    }
}) as client:
    # Cria o agente
    agent = create_react_agent(model, client.get_tools())
    
    # Operação matemática
    math_response = await agent.ainvoke({
        "messages": "quanto é (3 + 5) x 12?"
    })
    
    # Consulta de clima
    weather_response = await agent.ainvoke({
        "messages": "qual é o clima em Nova York?"
    })

Integração com Servidor API LangGraph

1. Arquivo de Configuração do Gráfico

# graph.py
from contextlib import asynccontextmanager
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-3-5-sonnet-latest")

@asynccontextmanager
async def make_graph():
    async with MultiServerMCPClient({
        "math": {
            "command": "python",
            "args": ["/path/to/math_server.py"],
            "transport": "stdio",
        },
        "weather": {
            "url": "http://localhost:8000/sse",
            "transport": "sse",
        }
    }) as client:
        agent = create_react_agent(model, client.get_tools())
        yield agent

2. Configuração LangGraph

{
  "dependencies": ["."],
  "graphs": {
    "agent": "./graph.py:make_graph"
  }
}

Cenários de Aplicação e Vantagens

🎯 Cenários de Aplicação

Agentes de IA de Nível Empresarial

  • Integração Multifuncional: Integra várias ferramentas e APIs de negócios.
  • Automação de Fluxo de Trabalho: Constrói automação de processos de negócios complexos.
  • Processamento de Dados: Integra diferentes fontes de dados e ferramentas de processamento.

Cadeia de Ferramentas para Desenvolvedores

  • Geração de Código: Integra ferramentas de geração e análise de código.
  • Automação de Testes: Constrói agentes de teste inteligentes.
  • Integração DevOps: Automatiza a implantação e o monitoramento.

Pesquisa e Educação

  • Cálculo Científico: Integra ferramentas de matemática e cálculo científico.
  • Análise de Dados: Constrói assistentes inteligentes de análise de dados.
  • Assistente de Ensino: Cria ferramentas de aprendizado interativas.

✨ Vantagens Técnicas

Interoperabilidade do Ecossistema

  • Interface Padronizada: Segue o protocolo padrão MCP.
  • Ampla Compatibilidade: Integra-se perfeitamente com o ecossistema LangChain.
  • Extensibilidade: Suporta ferramentas personalizadas e extensões de protocolo.

Aumento da Eficiência do Desenvolvimento

  • Integração Rápida: Integra ferramentas MCP com poucas linhas de código.
  • Segurança de Tipo: Dicas de tipo e validação completas.
  • Tratamento de Erros: Tratamento de erros e mecanismos de repetição abrangentes.

Desempenho e Confiabilidade

  • Suporte Assíncrono: Operações assíncronas de alto desempenho.
  • Gerenciamento de Conexões: Pool de conexões inteligente e mecanismos de reconexão.
  • Otimização de Recursos: Uso e gerenciamento eficientes de recursos.

Especificações Técnicas

Versões de Protocolo Suportadas

  • Protocolo MCP: Compatível com as especificações mais recentes do protocolo MCP.
  • LangChain: Suporta a versão 0.1+ do LangChain.
  • LangGraph: Suporta a versão mais recente do LangGraph.

Protocolos de Transporte

  • STDIO: Transporte de entrada e saída padrão.
  • SSE: Eventos enviados pelo servidor.
  • HTTP: API RESTful baseada em HTTP.
  • WebSocket: Comunicação bidirecional em tempo real (planejado).

Suporte a Tipos de Ferramentas

  • Ferramentas Síncronas: Ferramentas de função síncronas tradicionais.
  • Ferramentas Assíncronas: Ferramentas assíncronas de alto desempenho.
  • Ferramentas de Streaming: Suporta saída de streaming.
  • Ferramentas de Estado: Ferramentas que suportam gerenciamento de estado.

Melhores Práticas

🔧 Recomendações de Desenvolvimento

Design de Ferramentas

  • Função Única: Cada ferramenta deve se concentrar em uma única função.
  • Parâmetros Claros: Forneça descrições e tipos de parâmetros claros.
  • Tratamento de Erros: Implemente uma lógica de tratamento de erros abrangente.
  • Documentação Completa: Forneça documentação detalhada da ferramenta.

Otimização de Desempenho

  • Reutilização de Conexões: Reutilize as conexões do servidor MCP.
  • Prioridade Assíncrona: Use ferramentas e operações assíncronas prioritariamente.
  • Gerenciamento de Recursos: Libere os recursos desnecessários em tempo hábil.
  • Estratégias de Cache: Use o cache de forma razoável para melhorar o desempenho.

Considerações de Segurança

  • Controle de Permissões: Implemente verificações de permissão apropriadas.
  • Validação de Entrada: Valide rigorosamente os parâmetros de entrada.
  • Registro de Log: Registre operações e erros críticos.
  • Gerenciamento de Chaves: Gerencie com segurança as chaves de API e as credenciais.

Resumo

O projeto Adaptador LangChain MCP é uma infraestrutura importante no ecossistema de ferramentas de IA, que preenche com sucesso a lacuna entre o protocolo MCP e o framework LangChain. Através deste adaptador, os desenvolvedores podem:

🎯 Valor Principal

  • Ecossistema de Ferramentas Unificado: Unifica ferramentas de IA sob diferentes protocolos no ecossistema LangChain.
  • Aumento da Eficiência do Desenvolvimento: Reduz significativamente a complexidade e a carga de trabalho do desenvolvimento de agentes de IA.
  • Extensibilidade de Funcionalidades: Integra facilmente várias ferramentas e serviços de terceiros.
  • Suporte Padronizado: Segue os padrões da indústria, garantindo compatibilidade a longo prazo.

🌟 Destaques do Projeto

  • Design Leve: Minimiza as dependências, facilitando a integração e a implantação.
  • Funcionalidade Completa: Cobre todo o processo, desde a conversão de ferramentas até a execução do agente.
  • Pronto para Produção: Fornece estabilidade e desempenho de nível empresarial.
  • Orientado pela Comunidade: Comunidade de código aberto ativa e iteração contínua de funcionalidades.

🔮 Perspectivas de Aplicação

Com o rápido desenvolvimento da tecnologia de agentes de IA, a integração e a interoperabilidade de ferramentas se tornarão cada vez mais importantes. O Adaptador LangChain MCP, como uma ponte que conecta diferentes ecossistemas de ferramentas de IA, desempenhará um papel fundamental no futuro desenvolvimento de aplicações de IA. Ele não apenas simplifica os processos de desenvolvimento atuais, mas também estabelece uma base sólida para a construção de aplicações de agentes de IA mais inteligentes e ricas em funcionalidades.

Seja você um desenvolvedor de aplicações de IA, um tomador de decisões técnicas empresariais ou um pesquisador, este projeto merece ser profundamente compreendido e aplicado. Ele representa as melhores práticas na área de integração de ferramentas de IA e o ajudará a construir soluções de IA mais poderosas e flexíveis.