Blog

LangChain'i langchain-mcp-adapters kullanarak MCP Sunucularıyla Entegre Etme

Bu kütüphane, LangChain uygulamalarında MCP araçlarını kullanmayı kolaylaştıran hafif bir sarmalayıcı sunar. Hadi kullanalım.

Efe Demir

Efe Demir

5 June 2025

LangChain'i langchain-mcp-adapters kullanarak MCP Sunucularıyla Entegre Etme

Model Context Protocol (MCP), yapay zeka modellerinin harici araçlar ve hizmetlerle nasıl etkileşim kuracağını standartlaştırmayı amaçlar. Farklı modellerin ve araç sağlayıcılarının etkili bir şekilde iletişim kurmasını sağlayan ortak bir arayüz tanımlar. Ancak, bu MCP uyumlu araçların doğrudan LangChain gibi mevcut yapay zeka çerçevelerine entegre edilmesi uyarlama gerektirir.

langchain-mcp-adapters kütüphanesinin devreye girdiği yer burasıdır. MCP araçlarını, LangChain ve güçlü temsilci çerçevesi LangGraph'ın anlayabileceği ve kullanabileceği bir formata sorunsuz bir şekilde çevirerek önemli bir köprü görevi görür. Bu kütüphane, geliştiricilerin LangChain uygulamalarında büyüyen MCP araçları ekosisteminden yararlanmasını sağlayan hafif bir sarmalayıcı sağlar.

Temel özellikleri şunlardır:

Bu eğitim, MCP sunucularını kurma, adaptör kütüphanesini kullanarak bunlara bağlanma ve yüklenen araçları bir LangGraph temsilcisine entegre etme konusunda size rehberlik edecektir.

💡
Harika bir API Test aracı mı istiyorsunuz? güzel API Dokümantasyonu oluşturur?

Geliştirici Ekibinizin maksimum verimlilikle birlikte çalışması için entegre, Hepsi Bir Arada bir platform mu istiyorsunuz?

Apidog tüm taleplerinizi karşılar ve Postman'in yerini çok daha uygun bir fiyata alır!
button

MCP Sunucusu Nedir? Nasıl Çalışır?

Örnekleri incelemeden önce birkaç temel kavramı anlamak önemlidir:

MCP Sunucusu:

MCP İstemcisi (langchain-mcp-adapters):

Araç Dönüşümü:

İstem Dönüşümü:

Langchain-mcp-adapter'ı Yükleyin

İlk olarak, gerekli paketleri yükleyin:

pip install langchain-mcp-adapters langgraph langchain-openai # Veya tercih ettiğiniz LangChain LLM entegrasyonu

Ayrıca, genellikle ortam değişkenleri ayarlayarak, seçtiğiniz dil modeli sağlayıcınız için API anahtarlarını yapılandırmanız gerekir:

export OPENAI_API_KEY=<your_openai_api_key>
# veya export ANTHROPIC_API_KEY=<...> vb.

Langchain-mcp-adapters ile Hızlı Tek MCP Sunucusu Oluşturun

Basit bir örnek oluşturalım: matematik işlevleri sağlayan bir MCP sunucusu ve bu işlevleri kullanan bir LangGraph temsilcisi.

Adım 1: MCP Sunucusunu Oluşturun (math_server.py)

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

# MCP sunucusunu bir adla başlatın
mcp = FastMCP("Math")

@mcp.tool()
def add(a: int, b: int) -> int:
    """İki sayıyı topla"""
    print(f"add({a}, {b}) çalıştırılıyor") # Sunucu tarafı günlüğü
    return a + b

@mcp.tool()
def multiply(a: int, b: int) -> int:
    """İki sayıyı çarp"""
    print(f"multiply({a}, {b}) çalıştırılıyor") # Sunucu tarafı günlüğü
    return a * b

# Örnek istem tanımı
@mcp.prompt()
def configure_assistant(skills: str) -> list[dict]:
    """Yardımcıyı belirtilen becerilerle yapılandırır."""
    return [
        {
            "role": "assistant", # AIMessage'a karşılık gelir
            "content": f"Yardımsever bir assistantsınız. Şu becerilere sahipsiniz: {skills}. Her zaman sadece bir araç kullanın.",
        }
    ]

if __name__ == "__main__":
    # Sunucuyu stdio taşıma kullanarak çalıştırın
    print("Matematik MCP sunucusu stdio üzerinden başlatılıyor...")
    mcp.run(transport="stdio")

Bu kodu math_server.py olarak kaydedin.

Adım 2: İstemci ve Temsilci Oluşturun (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

# --- ÖNEMLİ: Bu yolu güncelleyin ---
# math_server.py dosyasına giden mutlak yolu alın
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") # Veya tercih ettiğiniz model

    # math_server.py betiğini çalıştırmak için parametreleri yapılandırın
    server_params = StdioServerParameters(
        command="python", # Yürütülecek komut
        args=[math_server_script_path], # Argümanlar (betik yolu)
        # cwd=..., env=... # İsteğe bağlı çalışma dizini ve ortam değişkenleri
    )

    print("MCP sunucusuna bağlanılıyor...")
    # stdio_client bağlam yöneticisini kullanarak bağlantı kurun
    async with stdio_client(server_params) as (read, write):
        # Okuma/yazma akışlarını kullanarak bir ClientSession oluşturun
        async with ClientSession(read, write) as session:
            print("Oturum başlatılıyor...")
            # Sunucu ile el sıkışma
            await session.initialize()
            print("Oturum başlatıldı.")

            print("MCP araçları yükleniyor...")
            # MCP araçlarını getirin ve bunları LangChain araçlarına dönüştürün
            tools = await load_mcp_tools(session)
            print(f"Yüklenen araçlar: {[tool.name for tool in tools]}")

            # Modeli ve yüklenen araçları kullanarak bir LangGraph ReAct temsilcisi oluşturun
            agent = create_react_agent(model, tools)

            print("Temsilci çağrılıyor...")
            # Temsilciyi çalıştırın
            inputs = {"messages": [("human", "what's (3 + 5) * 12?")]}
            async for event in agent.astream_events(inputs, version="v1"):
                 print(event) # Gözlemlenebilirlik için akış olayları

            # Veya son yanıtı doğrudan alın
            # final_response = await agent.ainvoke(inputs)
            # print("Temsilci yanıtı:", final_response['messages'][-1].content)

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

Bunu math_server.py ile aynı dizinde client_app.py olarak kaydedin.

Çalıştırmak İçin:

İstemci betiğini çalıştırın:

python client_app.py

İstemci betiği, math_server.py'yi otomatik olarak bir alt süreç olarak başlatacak, ona bağlanacak, add ve multiply araçlarını yükleyecek ve LangGraph temsilcisini kullanarak bu araçları MCP sunucusu aracılığıyla çağırarak matematik problemini çözecektir. Hem istemciden hem de sunucudan günlükleri göreceksiniz.

Birden Fazla MCP Sunucusuna Bağlanma

Genellikle, farklı uzmanlaşmış sunuculardan araçları birleştirmek istersiniz. MultiServerMCPClient bunu kolaylaştırır.

Adım 1: Başka Bir Sunucu Oluşturun (weather_server.py)

SSE taşıma kullanarak çalışan bir hava durumu sunucusu oluşturalım.

# weather_server.py
from mcp.server.fastmcp import FastMCP
import uvicorn # İhtiyaçlar: pip install uvicorn

mcp = FastMCP("Weather")

@mcp.tool()
async def get_weather(location: str) -> str:
    """Konum için hava durumunu alın."""
    print(f"get_weather({location}) çalıştırılıyor")
    # Gerçek bir senaryoda, bu bir hava durumu API'sini çağıracaktır
    return f"{location} her zaman güneşlidir"

if __name__ == "__main__":
    # Sunucuyu SSE taşıma kullanarak çalıştırın (Uvicorn gibi bir ASGI sunucusu gerektirir)
    # mcp kütüphanesi, SSE için örtük olarak bir FastAPI uygulaması oluşturur.
    # Varsayılan olarak, /sse uç noktasında 8000 numaralı portta çalışır.
    print("Hava Durumu MCP sunucusu SSE üzerinden 8000 numaralı portta başlatılıyor...")
    # uvicorn.run(mcp.app, host="0.0.0.0", port=8000) # Manuel olarak çalıştırabilirsiniz
    mcp.run(transport="sse", host="0.0.0.0", port=8000) # Veya mcp.run kolaylığını kullanın

Bunu weather_server.py olarak kaydedin.

Adım 2: İstemciyi MultiServerMCPClient Kullanacak Şekilde Güncelleyin (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

# --- ÖNEMLİ: Yolları güncelleyin ---
current_dir = os.path.dirname(os.path.abspath(__file__))
math_server_script_path = os.path.join(current_dir, "math_server.py")
# Hava durumu sunucusu ayrı olarak çalışır, URL üzerinden bağlanın
# ---

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

    # Birden fazla sunucu için bağlantıları tanımlayın
    server_connections = {
        "math_service": { # Bu bağlantı için benzersiz ad
            "transport": "stdio",
            "command": "python",
            "args": [math_server_script_path],
            # Gerekirse diğer StdioConnection parametrelerini ekleyin (env, cwd, vb.)
        },
        "weather_service": { # Bu bağlantı için benzersiz ad
            "transport": "sse",
            "url": "http://localhost:8000/sse", # Hava durumu sunucusunun çalıştığı URL
            # Gerekirse diğer SSEConnection parametrelerini ekleyin (headers, timeout, vb.)
        }
    }

    print("Birden fazla MCP sunucusuna bağlanılıyor...")
    # MultiServerMCPClient bağlam yöneticisini kullanın
    async with MultiServerMCPClient(server_connections) as client:
        print("Bağlantılar kuruldu.")

        # *Tüm* bağlı *tüm* sunuculardan *tüm* araçları alın
        all_tools = client.get_tools()
        print(f"Yüklenen araçlar: {[tool.name for tool in all_tools]}")

        # Birleştirilmiş araç listesiyle temsilci oluşturun
        agent = create_react_agent(model, all_tools)

        # --- Temsilci ile etkileşim kurun ---
        print("\nMatematik sorgusu için temsilci çağrılıyor...")
        math_inputs = {"messages": [("human", "what's (3 + 5) * 12?")]}
        math_response = await agent.ainvoke(math_inputs)
        print("Matematik Yanıtı:", math_response['messages'][-1].content)

        print("\nHava durumu sorgusu için temsilci çağrılıyor...")
        weather_inputs = {"messages": [("human", "what is the weather in nyc?")]}
        weather_response = await agent.ainvoke(weather_inputs)
        print("Hava Durumu Yanıtı:", weather_response['messages'][-1].content)

        # --- Örnek: Bir istem almak ---
        # print("\nMatematik sunucusu istemi alınıyor...")
        # prompt_messages = await client.get_prompt(
        #     server_name="math_service", # Bağlantılarda tanımlanan adı kullanın
        #     prompt_name="configure_assistant",
        #     arguments={"skills": "basic arithmetic"}
        # )
        # print("İstem:", prompt_messages)


if __name__ == "__main__":
    # Hava durumu sunucusunu önce ayrı bir terminalde başlatın:
    # python weather_server.py
    # Ardından bu istemci betiğini çalıştırın:
    asyncio.run(main())

Bunu multi_client_app.py olarak kaydedin.

Çalıştırmak İçin:

  1. Hava durumu sunucusunu bir terminalde başlatın: python weather_server.py
  2. Çoklu istemci uygulamasını başka bir terminalde çalıştırın: python multi_client_app.py

MultiServerMCPClient, math_server.py alt sürecini (stdio) başlatacak ve çalışan weather_server.py'ye (sse) bağlanacaktır. Daha sonra LangGraph temsilcisi tarafından kullanılabilen araçları (add, multiply, get_weather) toplar.

LangGraph API Sunucusu ile Entegrasyon

MCP araçlarını kullanan bir LangGraph temsilcisini, langgraph deploy kullanarak kalıcı bir API hizmeti olarak dağıtabilirsiniz. Anahtar, MultiServerMCPClient yaşam döngüsünü LangGraph uygulama bağlamında doğru bir şekilde yönetmektir.

Bir graph.py dosyası oluşturun:

# 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 # Veya Anthropic, vb.

# --- ÖNEMLİ: Yolları güncelleyin ---
# Sunucuların LangGraph sunucusunun çalıştığı yere göre göreceli olduğunu varsayıyoruz
math_server_script_path = os.path.abspath("math_server.py")
# ---

# Bağlantıları tanımlayın (sunucu ortamı için yolların/URL'lerin doğru olduğundan emin olun)
server_connections = {
    "math_service": {
        "transport": "stdio",
        "command": "python",
        "args": [math_server_script_path],
    },
    "weather_service": {
        "transport": "sse",
        "url": "http://localhost:8000/sse", # Hava durumu sunucusu bağımsız olarak çalışıyor olmalı
    }
}

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

# İstemci kurulumunu/kaldırılmasını yönetmek için bir async bağlam yöneticisi kullanın
@asynccontextmanager
async def lifespan(_app): # LangGraph, yaşam döngüsü yönetimi için bu yapıyı bekler
    async with MultiServerMCPClient(server_connections) as client:
        print("MCP İstemcisi yaşam döngüsü içinde başlatıldı.")
        # Temsilciyi, istemcinin aktif olduğu bağlam *içinde* oluşturun
        agent = create_react_agent(model, client.get_tools())
        yield {"agent": agent} # Temsilciyi kullanılabilir hale getirin

# Yaşam döngüsü onu verdiğinde ayrı bir ana grafik tanımına gerek yok

langgraph.json'unuzu (veya [tool.langgraph] altında pyproject.toml'nizi) bu grafik tanımını yaşam döngüsü yöneticisiyle kullanacak şekilde yapılandırın:

// langgraph.json (örnek)
{
  "dependencies": ["."], // Veya gerekli paketleri belirtin
  "graphs": {
    "my_mcp_agent": {
      "entrypoint": "graph:agent", // Yaşam döngüsü tarafından verilen anahtara atıfta bulunur
      "lifespan": "graph:lifespan"
    }
  }
}

Şimdi, langgraph up çalıştırdığınızda, lifespan işlevi yürütülecek, MultiServerMCPClient'ı (ve stdio matematik sunucusunu) başlatacaktır. Bu bağlamda oluşturulan temsilci, LangGraph tarafından hizmet verilecektir. SSE hava durumu sunucusunun hala ayrı olarak çalıştırılması gerektiğini unutmayın.

Sunucu Taşımaları (stdio vs. SSE)

stdio:

sse (Sunucu Tarafından Gönderilen Etkinlikler):

Dağıtım ihtiyaçlarınıza göre taşımayı seçin.

Langchain-mcp-adapters Kurulumu için Gelişmiş İstemci Yapılandırması

MultiServerMCPClient içindeki StdioConnection ve SSEConnection sözlükleri, daha ince kontrol için ek isteğe bağlı parametreleri kabul eder:

Ayrıntılar için langchain_mcp_adapters/client.py içindeki MultiServerMCPClient tanımına bakın.

Sonuç (100 kelime)

langchain-mcp-adapters kütüphanesi, standartlaştırılmış Model Context Protocol ile esnek LangChain ekosistemi arasındaki boşluğu etkili bir şekilde kapatır. MultiServerMCPClient'ı ve otomatik araç dönüşümünü sağlayarak, geliştiricilerin çeşitli, MCP uyumlu araçları LangChain temsilcilerine ve LangGraph uygulamalarına kolayca dahil etmelerini sağlar.

Temel iş akışı şunları içerir:

  1. @mcp.tool() kullanarak bir MCP sunucusunda araçları (ve isteğe bağlı olarak istemleri) tanımlama.
  2. Her sunucu için bağlantı ayrıntılarıyla (stdio veya sse) MultiServerMCPClient'ı yapılandırma.
  3. Bağlanmak ve araçları client.get_tools() aracılığıyla getirmek için istemci bağlam yöneticisini (async with ...) kullanma.
  4. Alınan LangChain uyumlu araçları temsilcinize (create_react_agent veya özel temsilciler) geçirme.

Bu, standartlaştırılmış bir protokol aracılığıyla uzmanlaşmış, harici araçlardan yararlanan güçlü, modüler yapay zeka uygulamaları oluşturmayı sağlar. Daha fazla bilgi için depodaki örnekleri ve testleri inceleyin.

API Tasarım-Öncelikli Yaklaşımı Apidog'da Uygulayın

API'leri oluşturmanın ve kullanmanın daha kolay yolunu keşfedin

Ücretsiz Kaydolİndir