Erstellen eines MCP -Clientservers mit Langchain

Die Welt der KI und Großspracher Modelle (LLMs) bewegt sich schnell. Die Integration externer Instruments und Echtzeitdaten ist für den Aufbau von wirklich leistungsstarken Anwendungen von entscheidender Bedeutung. Das Modellkontextprotokoll (MCP) bietet eine Standardmethode, um diese Lücke zu schließen. Dieser Leitfaden bietet eine klare, anfängerfreundliche Walkthrough für die Erstellung eines MCP-Consumer-Servers mit Langchain. Das Verständnis der MCP -Consumer -Serverarchitektur hilft, robuste AI -Agenten aufzubauen. Wir werden die Necessities abdecken, einschließlich der MCP -Serverfunktionalität und einen praktischen MCP -Consumer -Server mit Langchain -Beispiel zur Verfügung stellen.

Verständnis des Modellkontextprotokolls (MCP)

Worum geht es bei MCP Server und Consumer -Interaktion? Das Modellkontextprotokoll (MCP) ist ein offenes Standardsystem. Anthropisch entwickelte es, um LLMs mit externen Instruments und Datenquellen effektiv zu verbinden. Es verwendet einen strukturierten und wiederverwendbaren Ansatz. MCP hilft AI -Modellen, mit verschiedenen Systemen zu sprechen. Auf diese Weise können sie auf aktuelle Informationen zugreifen und Aufgaben über das erste Coaching hinaus ausführen. Betrachten Sie es als einen universellen Übersetzer zwischen der KI und der Außenwelt und bilden Sie den Kern der MCP -Consumer -Serverarchitektur.

Schlüsselmerkmale von MCP

MCP sticht aufgrund mehrerer wichtiger Merkmale heraus:

1. Standardisierte Integration: MCP bietet eine einzelne und konsistente Möglichkeit, LLMs mit vielen Instruments und Datenquellen zu verbinden. Dadurch wird die Notwendigkeit eines eindeutigen Codes für jede Verbindung entfernt. Es vereinfacht den MCP -Clientserver mithilfe von Langchain -Setup.
2. Kontextverwaltung: Das Protokoll stellt sicher, dass das KI -Modell den Konversationskontext in mehreren Schritten im Auge behält. Dies verhindert, dass wichtige Informationen beim Verlust von Aufgaben mehrere Interaktionen erfordern.
3. Sicherheit und Isolation: MCP enthält starke Sicherheitsmaßnahmen. Es steuert den Zugriff streng und hält die Serververbindungen mithilfe von Berechtigungsgrenzen getrennt. Dies gewährleistet eine sichere Kommunikation zwischen Consumer und Server.

Rolle von MCP in LLM-basierten Anwendungen

LLM -Anwendungen benötigen häufig externe Daten. Möglicherweise müssen sie Datenbanken abfragen, Dokumente abrufen oder Net -APIs verwenden. MCP wirkt als entscheidende mittlere Schicht. Mit diesem können Modelle reibungslos mit diesen externen Ressourcen interagieren, ohne manuelle Schritte zu benötigen. Durch die Verwendung eines MCP -Clientservers mit Langchain können Entwickler intelligentere AI -Agenten erstellen. Diese Agenten werden fähiger, arbeiten schneller und arbeiten sicher in einer intestine definierten MCP-Consumer-Serverarchitektur. Dieses Setup ist für fortgeschrittene AI -Assistenten von grundlegender Bedeutung. Schauen wir uns nun den Implementierungsteil an.

Einrichten der Umgebung

Vor dem Erstellen unseres MCP -Clientservers mit Langchain bereiten wir die Umgebung vor. Sie brauchen diese Artikel:

• Python Model 3.11 oder neuer.
• Richten Sie eine neue virtuelle Umgebung ein (optionally available)
• Ein API -Schlüssel (z. B. OpenAI oder GROQ, abhängig von dem von Ihnen gewählten Modell).
• Spezifische Python -Bibliotheken: Langchain-MCP-AdapterAnwesend Langgraphund eine LLM -Bibliothek (wie Langchain-Openai oder Langchain-Groq) Ihrer Wahl.

Installieren Sie die benötigten Bibliotheken mit PIP. Öffnen Sie Ihr Terminal oder Eingabeaufforderung und führen Sie aus:

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

Stellen Sie sicher, dass Sie die richtige Python -Model und die erforderlichen Schlüssel bereit haben.

Erstellen des MCP -Servers

Die Aufgabe des MCP -Servers besteht darin, Instruments anzubieten, die der Consumer verwenden kann. Auf unserem MCP -Consumer -Server mit Langchain -Beispiel erstellen wir einen einfachen Server. Dieser Server übernimmt grundlegende mathematische Operationen sowie eine komplexe Wetter -API, um Wetterdetails einer Stadt zu erhalten. Das Verstehen, was die MCP -Server -Funktionalität ist, beginnt hier.

Erstellen Sie eine Python -Datei namens McP_Server.py:

1. Importieren wir die erforderlichen Bibliotheken

import math

import requests

from mcp.server.fastmcp import FastMCP

2. Initialisieren Sie das FastMCP -Objekt

mcp= FastMCP("Math")

3. Definieren wir die Mathematikwerkzeuge

@mcp.device()

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

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

   return a + b

@mcp.device()

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

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

   return a * b

@mcp.device()

def sine(a: int) -> int:

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

   return math.sin(a)

4. Definieren wir nun ein Wetterwerkzeug, stellen Sie sicher, dass Sie API von Hier.

WEATHER_API_KEY = "YOUR_API_KEY"

@mcp.device()

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 obtained 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"Did not 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")

Erläuterung:

Dieses Skript legt einen einfachen MCP -Server mit dem Namen „Math“ ein. Es verwendet Fastmcp, um vier Werkzeuge zu definieren, hinzufügen, multiplizieren, sign get_weather gekennzeichnet durch die @mcp.device () Dekorateur. Kind Tipps Erzählen Sie MCP von den erwarteten Eingängen und Ausgängen. Der Server wird bei direkter Ausführung mit Standardeingabe/Ausgabe (STDIO) für die Kommunikation ausgeführt. Dies zeigt, was MCP Server in einem Foundation -Setup ist.

Führen Sie den Server aus: Öffnen Sie Ihr Terminal und navigieren Sie zum Verzeichnis, das McP_Server.py enthält. Dann rennen:

python mcp_server.py

Der Server sollte ohne Warnungen beginnen. Dieser Server wird für den Consumer weiter ausgeführt, um auf die Instruments zuzugreifen

Ausgabe:

Aufbau des MCP -Kunden

Der Consumer stellt eine Verbindung zum Server her, sendet Anfragen (z. B. den Agenten aufzufordern, eine Berechnung durchzuführen und das Dwell -Wetter abzurufen) und übernimmt die Antworten. Dies zeigt die Consumer -Seite des MCP -Clientservers mit Langchain.

Erstellen Sie eine Python -Datei namens consumer.py:

1. Importieren Sie zuerst die erforderlichen Bibliotheken

# consumer.py

from mcp import ClientSession, StdioServerParameters

from mcp.consumer.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. Richten Sie den API -Schlüssel für LLM (GROQ oder OpenAI) ein und initialisieren Sie das LLM -Modell

# Set your API key (exchange together with your precise key or use surroundings variables)

GROQ_API_KEY = "YOUR_GROQ_API_KEY" # Exchange together 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. Definieren Sie nun die Parameter, um den MCP -Serverprozess zu starten.

server_params = StdioServerParameters(

   command="python",      # Command to execute

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

)

4. Definieren wir die asynchrone Funktion, um die Agenteninteraktion auszuführen

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: {(device.identify for device 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 (often the agent's closing reply)

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

5. Führen Sie nun diese Funktion aus und warten Sie auf die Ergebnisse am TH -Terminal

# Commonplace Python entry level test

if __name__ == "__main__":

   # Run the asynchronous run_agent perform and watch for the end result

   print("Beginning MCP Consumer...")

   end result = asyncio.run(run_agent())

   print("nAgent Last Response:")

   print(end result)

Erläuterung:

Dieses Consumer -Skript konfiguriert ein LLM (mithilfe von ChatGroq hier; denken Sie daran, Ihren API -Schlüssel festzulegen). Es definiert, wie der Server mithilfe von StDiOserverparametern startet. Die Funktion run_agent stellt eine Verbindung zum Server über stdio_client her, erstellt eine Clientsession und initialisiert sie. load_mcp_tools abreißt die Server -Instruments für Langchain. Ein create_react_agent verwendet LLM und Instruments, um eine Benutzerabfrage zu verarbeiten. Schließlich sendet Agent.Ainvoke die Abfrage und lässt den Agenten möglicherweise die Instruments des Servers verwenden, um die Antwort zu finden. Dies zeigt einen vollständigen MCP -Consumer -Server mit Langchain -Beispiel.

Den Kunden ausführen:

python consumer.py

Ausgabe:

Wir können sehen, dass der Consumer den Serverprozess startet, die Verbindung initialisiert, Instruments lädt, den Agenten aufruft und die endgültige Antwort druckt, indem das Add -Instrument des Servers auch als Climate API bezeichnet und die Dwell -Wetterdaten abgerufen werden.

Anwendungen in der Praxis

Die Verwendung eines MCP -Consumer -Servers mit Langchain eröffnet viele Möglichkeiten für die Erstellung hoch entwickelter KI -Agenten. Einige praktische Anwendungen umfassen:

• LLM Unabhängigkeit: Durch die Verwendung von Langchain können wir jetzt jeden LLM in MCP integrieren. Zuvor waren wir
• Datenabruf: Agenten können eine Verbindung zu Datenbankservern über MCP herstellen, um Echtzeit-Kundendaten zu holen oder interne Wissensbasis abzufragen.
• Dokumentverarbeitung: Ein Agent kann MCP -Instruments verwenden, um mit einem Dokumentverwaltungssystem zu interagieren, sodass es die Dokumente zusammenfassen, extrahieren oder die Dokumente basierend auf Benutzeranforderungen aktualisieren kann.
• Aufgabenautomatisierung: Integrieren Sie sich in verschiedenen Geschäftssystemen (wie CRMS, Kalendern oder Projektmanagement -Instruments) über MCP -Server, um Routineaufgaben wie Planung von Besprechungen zu automatisieren oder Verkaufsunterlagen zu aktualisieren. Die MCP -Consumer -Serverarchitektur unterstützt diese komplexen Workflows.

Greatest Practices

Befolgen Sie beim Erstellen Ihres MCP -Clientservers mit Langchain gute Praktiken, um bessere Ergebnisse zu erzielen:

• Nehmen Sie ein modulares Design ein, indem Sie bestimmte Instruments für unterschiedliche Aufgaben erstellen und die Serverlogik von der Consumer -Logik getrennt halten.
• Implementieren Sie eine robuste Fehlerbehandlung sowohl in Server -Instruments als auch im Consumer -Agenten, damit das System Fehler anmutig verwalten kann.
• Priorisieren Sie die Sicherheit, insbesondere wenn der Server smart Daten behandelt, indem die Funktionen von MCP wie Zugriffskontrollen und Berechtigungsgrenzen verwendet werden.
• Geben Sie Ihre MCP -Instruments eindeutige Beschreibungen und Dokusstränge an. Dies hilft dem Agenten, seinen Zweck und seine Verwendung zu verstehen.

Häufige Fallstricke

Achten Sie bei der Entwicklung Ihres Methods potenzielle Probleme. Der Kontextverlust kann in komplexen Gesprächen auftreten, wenn der Agent -Framework den Standing nicht ordnungsgemäß verwaltet und zu Fehlern führt. Eine schlechte Ressourcenverwaltung auf langjährigen MCP-Servern kann Speicherlecks oder Leistungsverschlechterungen verursachen. Verwenden Sie daher Verbindungen und Dateihandles sorgfältig. Stellen Sie sicher, dass die Kompatibilität zwischen Consumer- und Servertransportmechanismen wie Fehlpaarungen (wie eine unter Verwendung von STDIO und die andere erwartet HTTP) die Kommunikation verhindern. Achten Sie schließlich nach dem Instrument -Schema -Missverhältnissen, bei denen die Definition des Server -Instruments nicht mit der Erwartung des Kunden übereinstimmt, wodurch die Ausführung der Instruments blockiert werden kann. Die Behandlung dieser Punkte stärkt Ihren MCP -Consumer -Server mithilfe der Langchain -Implementierung.

Abschluss

Das Nutzung des Modellkontextprotokolls mit Langchain bietet eine leistungsstarke und standardisierte Möglichkeit, fortschrittliche KI -Agenten aufzubauen. Durch das Erstellen eines MCP -Clientservers mit Langchain ermöglichen Sie Ihre LLMs, sicher und effektiv mit externen Instruments und Datenquellen zu interagieren. Dieser Handbuch hat einen grundlegenden MCP -Consumer -Server unter Verwendung von Langchain -Beispiel demonstriert, um die Kernarchitektur der MCP -Clientserver und die Funktionalität von MCP -Server darzustellen. Dieser Ansatz vereinfacht die Integration, steigert die Agentenfunktionen und sorgt für zuverlässige Vorgänge, wodurch der Weg für intelligentere und nützlichere KI -Anwendungen ebnet.

Häufig gestellte Fragen

Harsh Mishra ist ein KI/ML -Ingenieur, der mehr Zeit damit verbringt, mit großen Sprachmodellen zu sprechen als mit tatsächlichen Menschen. Leidenschaft über Genai, NLP und Maschinen schlauer (damit sie ihn noch nicht ersetzen). Wenn er Fashions nicht optimiert, optimiert er wahrscheinlich seine Kaffeeaufnahme. 🚀☕