Blog

So integrieren Sie LangChain mit MCP-Servern mithilfe von langchain-mcp-Adaptern

Diese Bibliothek bietet einen leichten Wrapper für MCP-Tools in LangChain-Apps. Lasst uns lernen, wie man sie nutzt.

Leo Schulz

Leo Schulz

5 June 2025

So integrieren Sie LangChain mit MCP-Servern mithilfe von langchain-mcp-Adaptern

Das Model Context Protocol (MCP) zielt darauf ab, die Interaktion von KI-Modellen mit externen Tools und Diensten zu standardisieren. Es definiert eine gemeinsame Schnittstelle, die es verschiedenen Modellen und Tool-Anbietern ermöglicht, effektiv zu kommunizieren. Die direkte Integration dieser MCP-konformen Tools in bestehende KI-Frameworks wie LangChain erfordert jedoch Anpassungen.

Hier kommt die Bibliothek langchain-mcp-adapters ins Spiel. Sie fungiert als entscheidende Brücke und übersetzt MCP-Tools nahtlos in ein Format, das LangChain und sein leistungsstarkes Agent-Framework, LangGraph, verstehen und nutzen können. Diese Bibliothek bietet einen schlanken Wrapper, der es Entwicklern ermöglicht, das wachsende Ökosystem von MCP-Tools innerhalb ihrer LangChain-Anwendungen zu nutzen.

Zu den wichtigsten Funktionen gehören:

Dieses Tutorial führt Sie durch das Einrichten von MCP-Servern, das Herstellen einer Verbindung zu diesen mithilfe der Adapterbibliothek und das Integrieren der geladenen Tools in einen LangGraph-Agenten.

💡
Benötigen Sie ein großartiges API-Testtool, das wunderschöne API-Dokumentation generiert?

Benötigen Sie eine integrierte All-in-One-Plattform für Ihr Entwicklerteam, um mit maximaler Produktivität zusammenzuarbeiten?

Apidog liefert alle Ihre Anforderungen und ersetzt Postman zu einem viel günstigeren Preis!
button

Was ist ein MCP-Server? Wie funktioniert er?

Das Verständnis einiger Kernkonzepte ist unerlässlich, bevor Sie sich in die Beispiele stürzen:

MCP-Server:

MCP-Client (langchain-mcp-adapters):

Tool Conversion:

Prompt Conversion:

Installieren Sie Langchain-mcp-adapter

Installieren Sie zuerst die erforderlichen Pakete:

pip install langchain-mcp-adapters langgraph langchain-openai # Oder Ihre bevorzugte LangChain LLM-Integration

Sie müssen auch API-Schlüssel für Ihren bevorzugten Sprachmodell-Anbieter konfigurieren, typischerweise durch Festlegen von Umgebungsvariablen:

export OPENAI_API_KEY=<your_openai_api_key>
# or export ANTHROPIC_API_KEY=<...> etc.

Erstellen Sie einen schnellen einzelnen MCP-Server mit langchain-mcp-adapters

Erstellen wir ein einfaches Beispiel: einen MCP-Server, der mathematische Funktionen bereitstellt, und einen LangGraph-Agenten, der diese Funktionen verwendet.

Schritt 1: Erstellen Sie den MCP-Server (math_server.py)

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

# Initialisieren Sie den MCP-Server mit einem Namen
mcp = FastMCP("Math")

@mcp.tool()
def add(a: int, b: int) -> int:
    """Addiere zwei Zahlen"""
    print(f"Executing add({a}, {b})") # Server-seitiges Protokoll
    return a + b

@mcp.tool()
def multiply(a: int, b: int) -> int:
    """Multipliziere zwei Zahlen"""
    print(f"Executing multiply({a}, {b})") # Server-seitiges Protokoll
    return a * b

# Beispiel für die Prompt-Definition
@mcp.prompt()
def configure_assistant(skills: str) -> list[dict]:
    """Konfiguriert den Assistenten mit angegebenen Fähigkeiten."""
    return [
        {
            "role": "assistant", # Entspricht AIMessage
            "content": f"Sie sind ein hilfreicher Assistent. Sie haben die folgenden Fähigkeiten: {skills}. Verwenden Sie immer nur ein Tool gleichzeitig.",
        }
    ]

if __name__ == "__main__":
    # Führen Sie den Server mit stdio-Transport aus
    print("Starte Math MCP-Server über stdio...")
    mcp.run(transport="stdio")

Speichern Sie diesen Code als math_server.py.

Schritt 2: Erstellen Sie den Client und Agenten (client_app.py)

import asyncio
import os
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

# --- WICHTIG: Aktualisieren Sie diesen Pfad ---
# Holen Sie sich den absoluten Pfad zur Datei math_server.py
current_dir = os.path.dirname(os.path.abspath(__file__))
math_server_script_path = os.path.join(current_dir, "math_server.py")
# ---

async def main():
    model = ChatOpenAI(model="gpt-4o") # Oder Ihr bevorzugtes Modell

    # Konfigurieren Sie die Parameter, um das Skript math_server.py auszuführen
    server_params = StdioServerParameters(
        command="python", # Der auszuführende Befehl
        args=[math_server_script_path], # Argumente (der Skriptpfad)
        # cwd=..., env=... # Optionales Arbeitsverzeichnis und Umgebungsvariablen
    )

    print("Verbinden mit dem MCP-Server...")
    # Stellen Sie eine Verbindung mithilfe des stdio_client-Kontextmanagers her
    async with stdio_client(server_params) as (read, write):
        # Erstellen Sie eine ClientSession mithilfe der Lese-/Schreib-Streams
        async with ClientSession(read, write) as session:
            print("Initialisiere Sitzung...")
            # Handshake mit dem Server
            await session.initialize()
            print("Sitzung initialisiert.")

            print("Lade MCP-Tools...")
            # Rufen Sie MCP-Tools ab und konvertieren Sie sie in LangChain-Tools
            tools = await load_mcp_tools(session)
            print(f"Geladene Tools: {[tool.name for tool in tools]}")

            # Erstellen Sie einen LangGraph ReAct-Agenten mithilfe des Modells und der geladenen Tools
            agent = create_react_agent(model, tools)

            print("Agenten aufrufen...")
            # Führen Sie den Agenten aus
            inputs = {"messages": [("human", "was ist (3 + 5) * 12?")]}
            async for event in agent.astream_events(inputs, version="v1"):
                 print(event) # Stream-Ereignisse zur Beobachtbarkeit

            # Oder erhalten Sie die endgültige Antwort direkt
            # final_response = await agent.ainvoke(inputs)
            # print("Agentenantwort:", final_response['messages'][-1].content)

if __name__ == "__main__":
    asyncio.run(main())

Speichern Sie dies als client_app.py im selben Verzeichnis wie math_server.py.

Zum Ausführen:

Führen Sie das Client-Skript aus:

python client_app.py

Das Client-Skript startet automatisch math_server.py als Subprozess, stellt eine Verbindung her, lädt die Tools add und multiply und verwendet den LangGraph-Agenten, um das mathematische Problem zu lösen, indem es diese Tools über den MCP-Server aufruft. Sie sehen Protokolle sowohl vom Client als auch vom Server.

Verbinden mit mehreren MCP-Servern

Oft möchten Sie Tools von verschiedenen spezialisierten Servern kombinieren. MultiServerMCPClient macht dies unkompliziert.

Schritt 1: Erstellen Sie einen weiteren Server (weather_server.py)

Erstellen wir einen Wetterserver, der den SSE-Transport verwendet.

# weather_server.py
from mcp.server.fastmcp import FastMCP
import uvicorn # Benötigt: pip install uvicorn

mcp = FastMCP("Weather")

@mcp.tool()
async def get_weather(location: str) -> str:
    """Holen Sie sich das Wetter für den Standort."""
    print(f"Executing get_weather({location})")
    # In einem realen Szenario würde dies eine Wetter-API aufrufen
    return f"Es ist immer sonnig in {location}"

if __name__ == "__main__":
    # Führen Sie den Server mit SSE-Transport aus (erfordert einen ASGI-Server wie uvicorn)
    # Die mcp-Bibliothek erstellt implizit eine FastAPI-App für SSE.
    # Standardmäßig wird sie an Port 8000 am /sse-Endpunkt ausgeführt.
    print("Starte Weather MCP-Server über SSE an Port 8000...")
    # uvicorn.run(mcp.app, host="0.0.0.0", port=8000) # Sie können manuell ausführen
    mcp.run(transport="sse", host="0.0.0.0", port=8000) # Oder verwenden Sie die mcp.run-Annehmlichkeit

Speichern Sie dies als weather_server.py.

Schritt 2: Aktualisieren Sie den Client zur Verwendung von MultiServerMCPClient (multi_client_app.py)

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

# --- WICHTIG: Pfade aktualisieren ---
current_dir = os.path.dirname(os.path.abspath(__file__))
math_server_script_path = os.path.join(current_dir, "math_server.py")
# Der Wetterserver wird separat ausgeführt, Verbindung über URL
# ---

async def main():
    model = ChatOpenAI(model="gpt-4o")

    # Definieren Sie Verbindungen für mehrere Server
    server_connections = {
        "math_service": { # Eindeutiger Name für diese Verbindung
            "transport": "stdio",
            "command": "python",
            "args": [math_server_script_path],
            # Fügen Sie bei Bedarf andere StdioConnection-Parameter hinzu (env, cwd usw.)
        },
        "weather_service": { # Eindeutiger Name für diese Verbindung
            "transport": "sse",
            "url": "http://localhost:8000/sse", # URL, unter der weather_server ausgeführt wird
            # Fügen Sie bei Bedarf andere SSEConnection-Parameter hinzu (Headers, Timeout usw.)
        }
    }

    print("Verbinden mit mehreren MCP-Servern...")
    # Verwenden Sie den MultiServerMCPClient-Kontextmanager
    async with MultiServerMCPClient(server_connections) as client:
        print("Verbindungen hergestellt.")

        # Holen Sie sich *alle* Tools von *allen* verbundenen Servern
        all_tools = client.get_tools()
        print(f"Geladene Tools: {[tool.name for tool in all_tools]}")

        # Erstellen Sie einen Agenten mit der kombinierten Toolliste
        agent = create_react_agent(model, all_tools)

        # --- Interagieren Sie mit dem Agenten ---
        print("\nAufrufen des Agenten für eine mathematische Abfrage...")
        math_inputs = {"messages": [("human", "was ist (3 + 5) * 12?")]}
        math_response = await agent.ainvoke(math_inputs)
        print("Mathematische Antwort:", math_response['messages'][-1].content)

        print("\nAufrufen des Agenten für eine Wetterabfrage...")
        weather_inputs = {"messages": [("human", "wie ist das Wetter in New York?")]}
        weather_response = await agent.ainvoke(weather_inputs)
        print("Wetterantwort:", weather_response['messages'][-1].content)

        # --- Beispiel: Abrufen eines Prompts ---
        # print("\nAbrufen des Math-Server-Prompts...")
        # prompt_messages = await client.get_prompt(
        #     server_name="math_service", # Verwenden Sie den in den Verbindungen definierten Namen
        #     prompt_name="configure_assistant",
        #     arguments={"skills": "Grundrechenarten"}
        # )
        # print("Prompt:", prompt_messages)


if __name__ == "__main__":
    # Starten Sie zuerst den Wetterserver in einem separaten Terminal:
    # python weather_server.py
    # Führen Sie dann dieses Client-Skript aus:
    asyncio.run(main())

Speichern Sie dies als multi_client_app.py.

Zum Ausführen:

  1. Starten Sie den Wetterserver in einem Terminal: python weather_server.py
  2. Führen Sie die Multi-Client-App in einem anderen Terminal aus: python multi_client_app.py

Der MultiServerMCPClient startet den Subprozess math_server.py (stdio) und stellt eine Verbindung zum laufenden weather_server.py (sse) her. Er aggregiert Tools (add, multiply, get_weather), die dann dem LangGraph-Agenten zur Verfügung stehen.

Integration mit LangGraph API Server

Sie können einen LangGraph-Agenten, der MCP-Tools verwendet, als persistenten API-Dienst mithilfe von langgraph deploy bereitstellen. Der Schlüssel ist die korrekte Verwaltung des MultiServerMCPClient-Lebenszyklus innerhalb des LangGraph-Anwendungskontexts.

Erstellen Sie eine Datei graph.py:

# graph.py
from contextlib import asynccontextmanager
import os
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI # Oder Anthropic usw.

# --- WICHTIG: Pfade aktualisieren ---
# Unter der Annahme, dass die Server relativ zu dem Ort sind, an dem der LangGraph-Server ausgeführt wird
math_server_script_path = os.path.abspath("math_server.py")
# ---

# Definieren Sie Verbindungen (stellen Sie sicher, dass die Pfade/URLs für die Serverumgebung korrekt sind)
server_connections = {
    "math_service": {
        "transport": "stdio",
        "command": "python",
        "args": [math_server_script_path],
    },
    "weather_service": {
        "transport": "sse",
        "url": "http://localhost:8000/sse", # Der Wetterserver muss unabhängig ausgeführt werden
    }
}

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

# Verwenden Sie einen asynchronen Kontextmanager, um die Client-Einrichtung/-Aufräumung zu verarbeiten
@asynccontextmanager
async def lifespan(_app): # LangGraph erwartet diese Struktur für die Lebenszyklusverwaltung
    async with MultiServerMCPClient(server_connections) as client:
        print("MCP-Client innerhalb der Lebensdauer initialisiert.")
        # Erstellen Sie den Agenten *innerhalb* des Kontexts, in dem der Client aktiv ist
        agent = create_react_agent(model, client.get_tools())
        yield {"agent": agent} # Stellen Sie den Agenten zur Verfügung

# Keine Notwendigkeit für eine separate Hauptgraph-Definition, wenn die Lebensdauer sie ergibt

Konfigurieren Sie Ihre langgraph.json (oder pyproject.toml unter [tool.langgraph]), um diese Graphdefinition mit dem Lebenszyklusmanager zu verwenden:

// langgraph.json (Beispiel)
{
  "dependencies": ["."], // Oder geben Sie die erforderlichen Pakete an
  "graphs": {
    "my_mcp_agent": {
      "entrypoint": "graph:agent", // Bezieht sich auf den Schlüssel, der von der Lebensdauer erzeugt wird
      "lifespan": "graph:lifespan"
    }
  }
}

Wenn Sie jetzt langgraph up ausführen, wird die Funktion lifespan ausgeführt, wodurch der MultiServerMCPClient (und der stdio-Math-Server) gestartet wird. Der in diesem Kontext erstellte Agent wird von LangGraph bedient. Denken Sie daran, dass der SSE-Wetterserver weiterhin separat ausgeführt werden muss.

Server-Transports (stdio vs. SSE)

stdio:

sse (Server-Sent Events):

Wählen Sie den Transport basierend auf Ihren Bereitstellungsanforderungen.

Erweiterte Client-Konfiguration für das langchain-mcp-adapters-Setup

Die StdioConnection- und SSEConnection-Wörterbücher innerhalb von MultiServerMCPClient akzeptieren zusätzliche optionale Parameter für eine feinere Steuerung:

Lesen Sie die Definition von MultiServerMCPClient in langchain_mcp_adapters/client.py für Details.

Fazit (100 Wörter)

Die Bibliothek langchain-mcp-adapters überbrückt effektiv die Lücke zwischen dem standardisierten Model Context Protocol und dem flexiblen LangChain-Ökosystem. Durch die Bereitstellung des MultiServerMCPClient und der automatischen Tool-Konvertierung können Entwickler auf einfache Weise vielfältige, MCP-konforme Tools in ihre LangChain-Agenten und LangGraph-Anwendungen integrieren.

Der Kern-Workflow umfasst:

  1. Definieren von Tools (und optional Prompts) in einem MCP-Server mithilfe von @mcp.tool().
  2. Konfigurieren des MultiServerMCPClient mit Verbindungsdetails (stdio oder sse) für jeden Server.
  3. Verwenden des Client-Kontextmanagers (async with ...), um eine Verbindung herzustellen und Tools über client.get_tools() abzurufen.
  4. Übergeben der abgerufenen LangChain-kompatiblen Tools an Ihren Agenten (create_react_agent oder benutzerdefinierte Agenten).

Dies ermöglicht das Erstellen leistungsstarker, modularer KI-Anwendungen, die spezialisierte, externe Tools über ein standardisiertes Protokoll nutzen. Erkunden Sie die Beispiele und Tests im Repository für weitere Einblicke.

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenDownload