Como criar um servidor cliente MCP usando Langchain

O mundo da IA ​​e Modelos de idiomas grandes (LLMS) se transfer rapidamente. A integração de ferramentas externas e dados em tempo actual é very important para criar aplicativos verdadeiramente poderosos. O Mannequin Context Protocol (MCP) oferece uma maneira padrão de preencher essa lacuna. Este guia fornece uma explicação clara e amigável para iniciantes para criar um servidor cliente MCP usando o Langchain. Compreender a arquitetura do servidor do cliente MCP ajuda a criar agentes robustos de IA. Abordaremos os itens essenciais, incluindo o que é a funcionalidade do servidor MCP, e fornecemos um servidor cliente prático do MCP usando o exemplo de Langchain.

Compreendendo o Modelo Contexto Protocolo (MCP)

Então, o que é o servidor MCP e a interação do cliente? O Mannequin Context Protocol (MCP) é um sistema de padrão aberto. A antropia o desenvolveu para conectar LLMs a ferramentas externas e fontes de dados de maneira eficaz. Ele usa uma abordagem estruturada e reutilizável. O MCP ajuda os modelos de IA a conversar com diferentes sistemas. Isso lhes permite acessar informações atuais e executar tarefas além do treinamento inicial. Pense nisso como um tradutor common entre a IA e o mundo exterior, formando o núcleo da arquitetura do servidor do cliente MCP.

Principais recursos do MCP

MCP se destaca devido a vários recursos importantes:

1. Integração padronizada: O MCP fornece uma maneira única e consistente de conectar o LLMS a muitas ferramentas e fontes de dados. Isso take away a necessidade de código exclusivo para cada conexão. Ele simplifica o servidor do cliente MCP usando a configuração do Langchain.
2. Gerenciamento de contexto: O protocolo garante que o modelo de IA acompanha o contexto da conversa durante várias etapas. Isso impede a perda de informações importantes quando as tarefas exigem várias interações.
3. Segurança e isolamento: O MCP inclui fortes medidas de segurança. Ele controla o acesso estritamente e mantém as conexões do servidor separadas usando limites de permissão. Isso garante comunicação segura entre o cliente e o servidor.

Papel do MCP em aplicativos baseados em LLM

Os aplicativos LLM geralmente precisam de dados externos. Eles podem precisar consultar bancos de dados, buscar documentos ou usar APIs da Internet. O MCP atua como uma camada intermediária essential. Ele permite que os modelos interajam com esses recursos externos sem problemas, sem precisar de etapas manuais. O uso de um servidor cliente MCP usando o Langchain permite que os desenvolvedores criem agentes mais inteligentes da IA. Esses agentes se tornam mais capazes, trabalham mais rapidamente e operam com segurança dentro de uma arquitetura de servidor de clientes MCP bem definida. Essa configuração é elementary para assistentes avançados de IA. Agora vamos olhar para a parte da implementação.

Configurando o ambiente

Antes de criar nosso servidor cliente MCP usando Langchain, vamos preparar o ambiente. Você precisa desses itens:

• Python versão 3.11 ou mais recente.
• Configure um novo ambiente digital (opcional)
• Uma chave da API (por exemplo, OpenAI ou Groq, dependendo do modelo escolhido).
• Bibliotecas Python específicas: Langchain-MCP-AdAptersAssim, Langgraphe uma biblioteca LLM (como Langchain-openai ou Langchain-Groq) de sua escolha.

Instale as bibliotecas necessárias usando PIP. Abra seu terminal ou immediate de comando e execute:

pip set up langchain-mcp-adapters langgraph langchain-groq # Or langchain-openai

Certifique -se de ter a versão python correta e as teclas necessárias prontas.

Construindo o servidor MCP

O trabalho do servidor MCP é oferecer ferramentas que o cliente pode usar. Em nosso servidor cliente MCP usando o exemplo de Langchain, criaremos um servidor simples. Este servidor lidará com operações matemáticas básicas, bem como a API climática complexa para obter detalhes climáticos de uma cidade. Compreender o que é a funcionalidade do servidor MCP começa aqui.

Crie um arquivo python chamado mcp_server.py:

1. Vamos importar as bibliotecas necessárias

import math

import requests

from mcp.server.fastmcp import FastMCP

2. Inicialize o objeto FastMCP

mcp= FastMCP("Math")

3. Vamos definir as ferramentas de matemática

@mcp.instrument()

def add(a: int, b: int) -> int:

   print(f"Server acquired add request: {a}, {b}")

   return a + b

@mcp.instrument()

def multiply(a: int, b: int) -> int:

   print(f"Server acquired multiply request: {a}, {b}")

   return a * b

@mcp.instrument()

def sine(a: int) -> int:

   print(f"Server acquired sine request: {a}")

   return math.sin(a)

4. Agora, vamos definir uma ferramenta meteorológica, verifique se você tem API de aqui.

WEATHER_API_KEY = "YOUR_API_KEY"

@mcp.instrument()

def get_weather(metropolis: str) -> dict:

   """

   Fetch present climate for a given metropolis utilizing WeatherAPI.com.

   Returns a dictionary with metropolis, temperature (C), and situation.

   """

   print(f"Server acquired climate request: {metropolis}")

   url = f"http://api.weatherapi.com/v1/present.json?key={WEATHER_API_KEY}&q={metropolis}"

   response = requests.get(url)

   if response.status_code != 200:

       return {"error": f"Didn't fetch climate for {metropolis}."}

   knowledge = response.json()

   return {

       "metropolis": knowledge("location")("identify"),

       "area": knowledge("location")("area"),

       "nation": knowledge("location")("nation"),

       "temperature_C": knowledge("present")("temp_c"),

       "situation": knowledge("present")("situation")("textual content")

   }

   5. Now, instantiate the mcp server 

if __name__ =="__main__":

   print("Beginning MCP Server....")

   mcp.run(transport="stdio")

Explicação:

Este script configura um servidor MCP simples chamado “Math”. Ele usa o FastMCP para definir quatro ferramentas, adicionar, multiplicar, seno e get_weather marcado pelo @mcp.instrument () decorador. Dicas de tipo informam o MCP sobre as entradas e saídas esperados. O servidor é executado usando o STDIO de entrada/saída padrão (STDIO) para comunicação quando executado diretamente. Isso demonstra o que é o servidor MCP em uma configuração básica.

Execute o servidor: Abra seu terminal e navegue até o diretório que contém mcp_server.py. Em seguida, corra:

python mcp_server.py

O servidor deve começar sem nenhum aviso. Este servidor continuará sendo executado para o cliente acessar as ferramentas

Saída:

Construindo o cliente MCP

O cliente se conecta ao servidor, envia solicitações (como pedir ao agente para executar um cálculo e buscar o clima ao vivo) e lida com as respostas. Isso demonstra o lado do cliente do servidor cliente MCP usando o Langchain.

Crie um arquivo python chamado shopper.py:

1. Importar as bibliotecas necessárias primeiro

# shopper.py

from mcp import ClientSession, StdioServerParameters

from mcp.shopper.stdio import stdio_client

from langchain_mcp_adapters.instruments import load_mcp_tools

from langgraph.prebuilt import create_react_agent

from langchain_groq import ChatGroq

from langchain_openai import ChatOpenAI

import asyncio

import os

2. Configure a chave da API para o LLM (Groq ou OpenAI) e inicialize o modelo LLM

# Set your API key (change along with your precise key or use surroundings variables)

GROQ_API_KEY = "YOUR_GROQ_API_KEY" # Substitute along with your key

os.environ("GROQ_API_KEY") = GROQ_API_KEY

# OPENAI_API_KEY = "YOUR_OPENAI_API_KEY"

# os.environ("OPENAI_API_KEY") = OPENAI_API_KEY

# Initialize the LLM mannequin

mannequin = ChatGroq(mannequin="llama3-8b-8192", temperature=0)

# mannequin = ChatOpenAI(mannequin="gpt-4o-mini", temperature=0)

3. Agora, defina os parâmetros para iniciar o processo do servidor MCP.

server_params = StdioServerParameters(

   command="python",      # Command to execute

   args=("mcp_server.py") # Arguments for the command (our server script)

)

4. Vamos definir a função assíncrona para executar a interação do agente

async def run_agent():

   async with stdio_client(server_params) as (learn, write):

       async with ClientSession(learn, write) as session:

           await session.initialize()

           print("MCP Session Initialized.")

           instruments = await load_mcp_tools(session)

           print(f"Loaded Instruments: {(instrument.identify for instrument in instruments)}")

           agent = create_react_agent(mannequin, instruments)

           print("ReAct Agent Created.")

           print(f"Invoking agent with question")

           response = await agent.ainvoke({

               "messages": (("person", "What's (7+9)x17, then give me sine of the output recieved after which inform me What is the climate in Torronto, Canada?"))

           })

           print("Agent invocation full.")

           # Return the content material of the final message (normally the agent's ultimate reply)

           return response("messages")(-1).content material

5. Agora, execute esta função e aguarde os resultados no Terminal TH

# Normal Python entry level test

if __name__ == "__main__":

   # Run the asynchronous run_agent operate and await the end result

   print("Beginning MCP Consumer...")

   end result = asyncio.run(run_agent())

   print("nAgent Remaining Response:")

   print(end result)

Explicação:

Este script do cliente configura um LLM (usando o ChatGroq aqui; lembre -se de definir sua chave da API). Ele outline como iniciar o servidor usando stdioserverParameters. A função run_agent se conecta ao servidor by way of stdio_client, cria uma confissão de clientes e a inicializa. load_mcp_tools busca as ferramentas do servidor para Langchain. Um create_react_agent usa o LLM e as ferramentas para processar uma consulta de usuário. Por fim, o Agent.AinVoke envia a consulta, permitindo que o agente use potencialmente as ferramentas do servidor para encontrar a resposta. Isso mostra um servidor cliente MCP completo usando o exemplo de Langchain.

Execute o cliente:

python shopper.py

Saída:

Podemos ver que o cliente inicia o processo do servidor, inicializa a conexão, carrega ferramentas, chama o agente e imprime a resposta ultimate calculada chamando a ferramenta de adição do servidor, também chamada de API Climate e recuperando os dados do clima ao vivo.

Aplicações do mundo actual

O uso de um servidor cliente MCP usando o Langchain abre muitas possibilidades para criar agentes sofisticados de IA. Algumas aplicações práticas incluem:

• Independência LLM: Ao utilizar o Langchain, agora podemos integrar qualquer LLM ao MCP. Anteriormente, éramos
• Recuperação de dados: Os agentes podem se conectar aos servidores de banco de dados by way of MCP para buscar dados de clientes em tempo actual ou consultar bases de conhecimento interno.
• Processamento de documentos: Um agente pode usar as ferramentas MCP para interagir com um sistema de gerenciamento de documentos, permitindo resumir, extrair informações ou atualizar documentos com base nas solicitações do usuário.
• Automação de tarefas: Integre -se a vários sistemas de negócios (como CRMs, calendários ou ferramentas de gerenciamento de projetos) por meio de servidores MCP para automatizar tarefas de rotina, como agendar reuniões ou atualizar registros de vendas. A arquitetura do servidor do cliente MCP suporta esses fluxos de trabalho complexos.

Práticas recomendadas

Ao criar seu servidor cliente MCP usando Langchain, siga boas práticas para obter melhores resultados:

• Adote um design modular criando ferramentas específicas para tarefas distintas e mantendo a lógica do servidor separada da lógica do cliente.
• Implemente o manuseio robusto de erros nas duas ferramentas do servidor e no agente do cliente para que o sistema possa gerenciar as falhas de forma graciosa.
• Priorize a segurança, especialmente se o servidor lidar com dados confidenciais, usando os recursos do MCP como controles de acesso e limites de permissão.
• Fornecer descrições e documentos claros para suas ferramentas MCP; Isso ajuda o agente a entender seu objetivo e uso.

Armadilhas comuns

Esteja atento aos possíveis problemas ao desenvolver seu sistema. A perda de contexto pode ocorrer em conversas complexas se a estrutura do agente não gerenciar o estado corretamente, levando a erros. O mau gerenciamento de recursos em servidores MCP de longa duração pode causar vazamentos de memória ou degradação do desempenho; portanto, manipule as conexões e as alças de arquivo com cuidado. Garanta a compatibilidade entre os mecanismos de transporte do cliente e do servidor, pois as incompatibilidades (como uma usando o stdio e a outra esperando HTTP) impedirão a comunicação. Por fim, observe as incompatibilidades do esquema de ferramentas, onde a definição da ferramenta do servidor não está alinhada com a expectativa do cliente, que pode bloquear a execução da ferramenta. Abordar esses pontos fortalece o servidor do cliente MCP usando a implementação do Langchain.

Conclusão

A alavancagem do protocolo de contexto do modelo com Langchain fornece uma maneira poderosa e padronizada de criar agentes avançados de IA. Ao criar um servidor cliente MCP usando o Langchain, você permite que seu LLMS interaja de forma segura e eficaz com ferramentas externas e fontes de dados. Este guia demonstrou um servidor cliente básico do MCP usando o exemplo de Langchain, descrevendo a arquitetura do servidor do cliente MCP e o que é a funcionalidade do servidor MCP. Essa abordagem simplifica a integração, aumenta os recursos do agente e garante operações confiáveis, abrindo caminho para aplicativos de IA mais inteligentes e úteis.

Perguntas frequentes

Harsh Mishra é um engenheiro de IA/ML que passa mais tempo conversando com grandes modelos de idiomas do que os humanos reais. Apaixonado por Genai, PNL e tornando as máquinas mais inteligentes (para que ainda não o substituam). Quando não está otimizando os modelos, ele provavelmente está otimizando sua ingestão de café. 🚀☕