Model Context Protocol (MCP) Nedir?

Haziran 10, 2025

| Yorumlar 0

Yapay zeka (Artificial Intelligence – AI) dünyası son birkaç yılda inanılmaz bir dönüşüm geçirdi. Büyük dil modelleri (Large Language Models – LLM) artık etkileyici metinler üretiyor, karmaşık problemleri çözüyor ve yaratıcı içerikler oluşturabiliyor. Ancak bu modellerin kritik bir sınırlaması var: kendi eğitim verileriyle sınırlı kalıyorlar ve dış dünyadaki gerçek zamanlı verilere veya araçlara erişimde ciddi zorluklar yaşıyorlar.

Bu zorlukları aşmak için Model Bağlam Protokolü (Model Context Protocol – MCP) geliştirildi. Bu yazıda MCP’nin ne olduğunu, nasıl çalıştığını, neden bu kadar önemli olduğunu ve Python ile nasıl kullanabileceğimizi derinlemesine inceleyeceğiz. Ayrıca MCP’yi alternatif yaklaşımlarla karşılaştıracak ve pratik kod örnekleriyle konuyu pekiştireceğiz.

MCP Nedir?

Model Bağlam Protokolü, Anthropic tarafından Kasım 2024’te açık kaynak olarak duyurulan devrim niteliğinde bir protokoldür [1]. Temel amacı, yapay zeka modellerinin farklı araçlar, servisler ve veri kaynaklarıyla standart bir şekilde iletişim kurmasını sağlamaktır.

MCP’yi anlamak için basit bir benzetme yapalım: USB-C portu nasıl farklı cihazları standart bir şekilde bağlamamızı sağlıyorsa, MCP de yapay zeka modellerini farklı veri kaynaklarına ve araçlara bağlayan “evrensel bir bağlayıcı” gibi çalışıyor [2]. Bu yaklaşım, hem geliştiriciler hem de işletmeler için büyük bir kolaylık sunuyor.

N×M Problemi ve MCP’nin Çözümü

Geleneksel yöntemlerde, bir yapay zeka modelinin her yeni veri kaynağı veya araçla entegre olabilmesi için özel bir API ve özelleştirilmiş kod yazılması gerekiyordu. Anthropic mühendisleri bu durumu “N×M problemi” olarak adlandırıyor [3].

Somut bir örnekle açıklayalım: Diyelim ki 3 farklı yapay zeka modeliniz var (Claude, GPT-4, Gemini) ve bunları 4 farklı araçla (GitHub, Slack, veritabanı, e-posta) entegre etmek istiyorsunuz. Geleneksel yöntemle her model için her araca ayrı bir bağlantı kodu yazmanız gerekiyor. Bu da 3 × 4 = 12 farklı entegrasyon demek. Şimdi 10 model ve 20 araç düşünün: 200 ayrı entegrasyon! İşte bu “çarpım problemi” hızla kontrolden çıkıyor.

MCP bu sorunu kökten çözüyor. Nasıl mı? Ortaya evrensel bir standart koyarak. Artık her araç için sadece bir kez MCP sunucusu yazıyorsunuz, her model için de bir kez MCP istemcisi. Sonuç: 3 + 4 = 7 entegrasyon. Ya da büyük senaryoda 10 + 20 = 30. Yani N×M yerine N+M. Bu, geliştirme süresini ve bakım maliyetini dramatik şekilde azaltıyor [4].

MCP’nin Mimarisi: İstemci-Sunucu Yapısı

MCP, klasik istemci-sunucu mimarisine (client-server architecture) dayanıyor ve üç temel bileşenden oluşuyor [5]:

1. MCP Ana Bilgisayarı (MCP Host)

Ana bilgisayar, yapay zekanın çalıştığı ana uygulama veya arayüzdür. Örneğin Claude Desktop uygulaması, Cursor IDE veya başka bir yapay zeka destekli araç olabilir. Ana bilgisayar kullanıcıyla doğrudan etkileşim kurar ve MCP istemcilerini yönetir [6].

Ana bilgisayarın temel sorumlulukları şunlardır:

İstemci örneklerinin yaşam döngüsünü yönetmek
Bağlantı izinlerini kontrol etmek
Güvenlik politikalarını uygulamak
Yapay zeka ve LLM entegrasyonunu koordine etmek

2. MCP İstemcisi (MCP Client)

İstemci, ana bilgisayar ile sunucular arasında bir köprü görevi görür. Her istemci, belirli bir MCP sunucusuyla birebir bağlantı kurar ve veri alışverişini yönetir [7]. Örneğin, Claude’un bir dosyaya erişmesi gerektiğinde, istemci bu talebi ilgili sunucuya iletir.

3. MCP Sunucuları (MCP Servers)

Sunucular, belirli bir aracı veya veri kaynağını yapay zekaya bağlayan hafif bileşenlerdir. Yerel kaynaklara (bilgisayarınızdaki bir dosya sistemi veya veritabanı gibi) veya uzak kaynaklara (bulut tabanlı API’ler gibi) erişim sağlayabilir [8].

┌─────────────────────────────────────────────────────────────┐
│                     MCP Ana Bilgisayarı                     │
│  (Claude Desktop, Cursor, VS Code vb.)                      │
│                                                             │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │ MCP İstemci │  │ MCP İstemci │  │ MCP İstemci │          │
│  │     #1      │  │     #2      │  │     #3      │          │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘          │
└─────────┼────────────────┼────────────────┼─────────────────┘
          │                │                │
          ▼                ▼                ▼
   ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
   │ MCP Sunucusu │ │ MCP Sunucusu │ │ MCP Sunucusu │
   │   (GitHub)   │ │   (Slack)    │ │ (PostgreSQL) │
   └──────┬───────┘ └──────┬───────┘ └──────┬───────┘
          │                │                │
          ▼                ▼                ▼
   ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
   │  GitHub API  │ │  Slack API   │ │   Veritabanı │
   └──────────────┘ └──────────────┘ └──────────────┘

Diyagram 1: MCP mimarisi genel görünümü. Ana bilgisayar birden fazla istemci yönetir, her istemci bir sunucuya bağlanır ve sunucular dış kaynaklara erişim sağlar.

MCP Protokolü: JSON-RPC 2.0 Temelli İletişim

MCP’nin tüm iletişimi JSON-RPC 2.0 protokolü üzerine kurulu [9]. Peki bu ne anlama geliyor?

JSON-RPC, iki sistem arasında “şunu yap” ve “işte sonuç” şeklinde mesajlaşmayı standartlaştıran basit bir format. Bunu bir restoran siparişi gibi düşünebilirsiniz: Garson (istemci) mutfağa (sunucu) standart bir sipariş fişi veriyor, mutfak da standart bir formatta yanıt veriyor. Herkes aynı dili konuştuğu için yanlış anlaşılma olmuyor.

Bu standardın avantajı şu: Python’da yazılmış bir MCP sunucusu, JavaScript’te yazılmış bir istemciyle sorunsuz konuşabiliyor. Çünkü ikisi de aynı mesaj formatını kullanıyor. Tıpkı farklı ülkelerden iki kişinin İngilizce konuşarak anlaşması gibi.

Mesaj Türleri

MCP üç temel mesaj türü tanımlar [10]:

1. İstek (Request):

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "city": "Istanbul"
    }
  }
}

2. Yanıt (Response):

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "temperature": 22,
    "condition": "Güneşli",
    "humidity": 45
  }
}

3. Bildirim (Notification):

{
  "jsonrpc": "2.0",
  "method": "notifications/initialized"
}

Transport Mekanizmaları

MCP, mesajların taşınması için üç ana transport mekanizması destekliyor [11]:

1. stdio (Standard Input/Output):

Yerel entegrasyonlar için ideal
İstemci, sunucuyu alt süreç olarak başlatır
Mesajlar stdin/stdout üzerinden iletilir
Düşük gecikme süresi ve basit yapılandırma

2. Streamable HTTP:

Modern uzak sunucu iletişimi için önerilen yöntem
HTTP POST ile istemciden sunucuya iletişim
Server-Sent Events (SSE) ile sunucudan istemciye akış
Oturum yönetimi ve yeniden bağlanabilirlik desteği

3. SSE (Server-Sent Events) – Kullanımdan Kaldırıldı:

Eski sistemlerle uyumluluk için mevcut
Yeni projelerde Streamable HTTP önerilir

Diyagram 2: MCP transport mekanizmalarının karşılaştırmalı gösterimi.

MCP’nin Temel Bileşenleri: Araçlar, Kaynaklar ve Promptlar

MCP sunucuları üç temel ilkel (primitive) üzerinden yeteneklerini açığa çıkarır [12]:

1. Araçlar (Tools)

Araçlar, yapay zekanın gerçekleştirebileceği eylemlerdir. REST API’lerdeki POST uç noktalarına benzetilebilir. Hesaplama yapma, API çağrısı gerçekleştirme veya dosya yazma gibi yan etkileri olan işlemler için kullanılır [13].

Örnek araç tanımı:

@server.tool()
async def get_weather(city: str) -> dict:
    """Belirtilen şehir için hava durumu bilgisi getirir."""
    return {
        "temperature": 22,
        "condition": "Güneşli",
        "humidity": 45
    }

2. Kaynaklar (Resources)

Kaynaklar, yapay zekanın okuyabileceği verilerdir. REST API’lerdeki GET uç noktalarına benzer. Dosyalar, veritabanı şemaları veya yapılandırma bilgileri gibi salt okunur veriler için kullanılır [14].

@server.resource("config://app/settings")
async def get_settings() -> str:
    """Uygulama ayarlarını döndürür."""
    return json.dumps({"theme": "dark", "language": "tr"})

3. Promptlar (Prompts)

Promptlar, yapay zeka etkileşimleri için yeniden kullanılabilir şablonlardır. Belirli görevler için yapılandırılmış talimatlar tanımlamaya yarar [15].

@server.prompt()
async def code_review_prompt(code: str) -> str:
    """Kod inceleme için standart prompt şablonu."""
    return f"""
    Aşağıdaki kodu incele ve öneriler sun:
    
    ```
    {code}
    ```
    
    Değerlendirme kriterleri:
    1. Kod okunabilirliği
    2. Performans
    3. Güvenlik
    4. En iyi pratikler
    """

Python ile MCP: Pratik Örnekler

Şimdi Python kullanarak MCP sunucusu ve istemcisi oluşturmayı adım adım göreceğiz.

Gerekli Kurulumlar

Öncelikle gerekli paketleri yükleyelim:

# MCP Python SDK kurulumu
pip install mcp

# FastMCP (yüksek seviye framework) kurulumu
pip install fastmcp

# Geliştirme araçları
pip install uvicorn python-dotenv

Örnek 1: Basit Bir MCP Sunucusu Oluşturma

İlk örneğimizde, temel matematik işlemleri yapan basit bir MCP sunucusu oluşturacağız [16]:

# math_server.py
from mcp.server import Server
from mcp.server.stdio import stdio_server
import mcp.types as types

# Sunucu örneği oluştur
server = Server("math-server", version="1.0.0")

# Araç listesini tanımla
@server.list_tools()
async def list_tools() -> list[types.Tool]:
    """Kullanılabilir araçları listele."""
    return [
        types.Tool(
            name="add",
            description="İki sayıyı toplar",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "İlk sayı"},
                    "b": {"type": "number", "description": "İkinci sayı"}
                },
                "required": ["a", "b"]
            }
        ),
        types.Tool(
            name="multiply",
            description="İki sayıyı çarpar",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "İlk sayı"},
                    "b": {"type": "number", "description": "İkinci sayı"}
                },
                "required": ["a", "b"]
            }
        )
    ]

# Araç çağrılarını işle
@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    """Araç çağrısını gerçekleştir."""
    if name == "add":
        result = arguments["a"] + arguments["b"]
        return [types.TextContent(type="text", text=f"Sonuç: {result}")]
    elif name == "multiply":
        result = arguments["a"] * arguments["b"]
        return [types.TextContent(type="text", text=f"Sonuç: {result}")]
    else:
        raise ValueError(f"Bilinmeyen araç: {name}")

# Sunucuyu başlat
if __name__ == "__main__":
    import asyncio
    asyncio.run(stdio_server(server).run())

Örnek 2: FastMCP ile Daha Kolay Sunucu Geliştirme

FastMCP, MCP sunucusu geliştirmeyi çok daha kolay hale getiren bir Python framework’üdür [17]. Dekoratörler kullanarak minimum kod ile araçlar tanımlayabilirsiniz:

# weather_server.py
from fastmcp import FastMCP

# FastMCP sunucusu oluştur
mcp = FastMCP(name="weather-server")

# Sahte hava durumu veritabanı
weather_data = {
    "Istanbul": {"temp": 22, "condition": "Güneşli", "humidity": 55},
    "Ankara": {"temp": 18, "condition": "Bulutlu", "humidity": 40},
    "Izmir": {"temp": 28, "condition": "Güneşli", "humidity": 60},
}

@mcp.tool()
def get_weather(city: str) -> dict:
    """
    Belirtilen şehir için güncel hava durumu bilgisini getirir.
    
    Args:
        city: Hava durumu sorgulanacak şehir adı
    
    Returns:
        Sıcaklık, durum ve nem bilgisi içeren sözlük
    """
    if city in weather_data:
        data = weather_data[city]
        return {
            "city": city,
            "temperature": data["temp"],
            "condition": data["condition"],
            "humidity": data["humidity"],
            "unit": "celsius"
        }
    return {"error": f"{city} için veri bulunamadı"}

@mcp.tool()
def compare_weather(city1: str, city2: str) -> dict:
    """
    İki şehrin hava durumunu karşılaştırır.
    
    Args:
        city1: İlk şehir
        city2: İkinci şehir
    
    Returns:
        Karşılaştırma sonuçları
    """
    w1 = get_weather(city1)
    w2 = get_weather(city2)
    
    if "error" in w1 or "error" in w2:
        return {"error": "Bir veya iki şehir bulunamadı"}
    
    temp_diff = w1["temperature"] - w2["temperature"]
    
    return {
        "comparison": {
            city1: w1,
            city2: w2
        },
        "temperature_difference": abs(temp_diff),
        "warmer_city": city1 if temp_diff > 0 else city2
    }

@mcp.resource("weather://cities")
def list_available_cities() -> str:
    """Hava durumu verisi bulunan şehirlerin listesi."""
    return ", ".join(weather_data.keys())

# Sunucuyu çalıştır
if __name__ == "__main__":
    mcp.run()

Örnek 3: MCP İstemcisi Oluşturma

Şimdi bir MCP sunucusuna bağlanan basit bir istemci yazalım [18]:

# client.py
import asyncio
from mcp import ClientSession
from mcp.client.stdio import stdio_client, StdioServerParameters

async def main():
    # Sunucu parametrelerini tanımla
    server_params = StdioServerParameters(
        command="python",
        args=["weather_server.py"]
    )
    
    # Sunucuya bağlan
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            # Bağlantıyı başlat
            await session.initialize()
            
            # Kullanılabilir araçları listele
            tools_response = await session.list_tools()
            print("Kullanılabilir araçlar:")
            for tool in tools_response.tools:
                print(f"  - {tool.name}: {tool.description}")
            
            # Bir araç çağır
            result = await session.call_tool(
                "get_weather",
                {"city": "Istanbul"}
            )
            print(f"\nHava durumu sonucu: {result}")
            
            # Karşılaştırma yap
            comparison = await session.call_tool(
                "compare_weather",
                {"city1": "Istanbul", "city2": "Ankara"}
            )
            print(f"\nKarşılaştırma: {comparison}")

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

Örnek 4: Veritabanı MCP Sunucusu

Daha gelişmiş bir örnek olarak, SQLite veritabanıyla çalışan bir MCP sunucusu oluşturalım [19]:

# database_server.py
from fastmcp import FastMCP
import sqlite3
import json

mcp = FastMCP(name="database-server")

# Veritabanı bağlantısı
def get_db_connection():
    conn = sqlite3.connect("example.db")
    conn.row_factory = sqlite3.Row
    return conn

# Örnek tablo oluştur
def init_database():
    conn = get_db_connection()
    conn.execute("""
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            email TEXT UNIQUE,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    """)
    conn.commit()
    conn.close()

@mcp.tool()
def query_users(limit: int = 10) -> list:
    """
    Kullanıcıları listeler.
    
    Args:
        limit: Maksimum döndürülecek kayıt sayısı
    
    Returns:
        Kullanıcı listesi
    """
    conn = get_db_connection()
    cursor = conn.execute(
        "SELECT * FROM users LIMIT ?", 
        (limit,)
    )
    users = [dict(row) for row in cursor.fetchall()]
    conn.close()
    return users

@mcp.tool()
def add_user(name: str, email: str) -> dict:
    """
    Yeni kullanıcı ekler.
    
    Args:
        name: Kullanıcı adı
        email: E-posta adresi
    
    Returns:
        Eklenen kullanıcı bilgisi
    """
    conn = get_db_connection()
    try:
        cursor = conn.execute(
            "INSERT INTO users (name, email) VALUES (?, ?)",
            (name, email)
        )
        conn.commit()
        user_id = cursor.lastrowid
        conn.close()
        return {
            "success": True,
            "user_id": user_id,
            "message": f"{name} başarıyla eklendi"
        }
    except sqlite3.IntegrityError:
        conn.close()
        return {
            "success": False,
            "error": "Bu e-posta adresi zaten kayıtlı"
        }

@mcp.tool()
def search_users(query: str) -> list:
    """
    Kullanıcıları isim veya e-postaya göre arar.
    
    Args:
        query: Arama terimi
    
    Returns:
        Eşleşen kullanıcılar
    """
    conn = get_db_connection()
    cursor = conn.execute(
        """SELECT * FROM users 
           WHERE name LIKE ? OR email LIKE ?""",
        (f"%{query}%", f"%{query}%")
    )
    results = [dict(row) for row in cursor.fetchall()]
    conn.close()
    return results

@mcp.resource("database://schema")
def get_schema() -> str:
    """Veritabanı şemasını döndürür."""
    conn = get_db_connection()
    cursor = conn.execute(
        "SELECT sql FROM sqlite_master WHERE type='table'"
    )
    schemas = [row[0] for row in cursor.fetchall() if row[0]]
    conn.close()
    return "\n\n".join(schemas)

if __name__ == "__main__":
    init_database()
    mcp.run()

Claude Desktop ile Entegrasyon

MCP sunucunuzu Claude Desktop ile kullanmak için yapılandırma dosyasını düzenlemeniz gerekiyor [20]:

MacOS için: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows için: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "weather-server": {
      "command": "python",
      "args": ["/tam/yol/weather_server.py"]
    },
    "database-server": {
      "command": "python",
      "args": ["/tam/yol/database_server.py"]
    }
  }
}

MCP vs Alternatif Yaklaşımlar: Karşılaştırma

MCP’nin değerini daha iyi anlamak için alternatif yaklaşımlarla karşılaştıralım.

MCP vs OpenAI Function Calling

OpenAI, Haziran 2023’te fonksiyon çağırma (Function Calling) özelliğini tanıttı. Bu yaklaşım, geliştiricilerin fonksiyon şemaları tanımlamasına ve modelin bu fonksiyonları çağırmasına olanak tanır [21].

Özellik	MCP	Function Calling
Standart	Açık standart, vendor-bağımsız	Vendor’a özgü (OpenAI, Anthropic farklı)
Taşınabilirlik	Aynı sunucu tüm MCP istemcileriyle çalışır	Her sağlayıcı için yeniden yazılmalı
Keşif	Çalışma zamanında dinamik araç keşfi	Derleme zamanında tanımlanmalı
Durum Yönetimi	Oturum tabanlı kalıcı bağlantılar	Durumsuz istek-yanıt
Karmaşıklık	Sunucu altyapısı gerektirir	Daha basit entegrasyon

Somut Bir Örnek: OpenAI kullanarak bir hava durumu API’si ve veritabanı entegrasyonu yaptığınızı düşünün. Şimdi daha iyi akıl yürütme için Claude’a geçmek istiyorsunuz. Function Calling ile tüm araç tanımlarınızı yeniden yazmanız, şemaları Anthropic formatına uyarlamanız ve her şeyi yeniden test etmeniz gerekiyor. MCP ile sadece Claude istemcinizi aynı hava durumu ve veritabanı MCP sunucularına yönlendiriyorsunuz – sıfır kod değişikliği, anında uyumluluk [22].

MCP vs LangChain

LangChain, LLM tabanlı uygulamalar geliştirmek için popüler bir Python framework’üdür. Prompt yönetimi, bellek, araç entegrasyonu ve ajan orkestrasyonu gibi bileşenler sunar [23].

Özellik	MCP	LangChain
Katman	Protokol/entegrasyon katmanı	Uygulama/orkestrasyon katmanı
Odak	Araç bağlantısı standardizasyonu	LLM iş akışı orkestrasyonu
Yaklaşım	Model-odaklı standart	Geliştirici-odaklı framework
Esneklik	Her MCP istemcisi her sunucuyu kullanabilir	Framework’e bağımlı araç tanımları
Kullanım	Birlikte kullanılabilir	MCP ile entegre edilebilir

Önemli bir nokta: MCP ve LangChain rakip değil, tamamlayıcıdır. LangChain ajanın nasıl düşüneceğini ve akışı yöneteceğini tanımlarken, MCP araçların nasıl açığa çıkarılacağını ve çağrılacağını standardize eder [24]. LangChain ekibi, MCP sunucularının LangChain araçları olarak kullanılabilmesi için bir adaptör sağlamıştır.

# LangChain ile MCP entegrasyonu örneği
from langchain_mcp import MCPToolkit

# MCP sunucusunu LangChain aracı olarak kullan
toolkit = MCPToolkit(server_url="http://localhost:3000/mcp")
tools = toolkit.get_tools()

# LangChain ajanında kullan
from langchain.agents import create_openai_functions_agent
agent = create_openai_functions_agent(llm, tools, prompt)

Karşılaştırma Özeti

┌─────────────────────────────────────────────────────────────┐
│                    AI Entegrasyon Katmanları                 │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  Orkestrasyon Katmanı     │  LangChain, LangGraph           │
│  (Nasıl düşünür?)         │  CrewAI, LlamaIndex             │
│                           │                                  │
├───────────────────────────┼──────────────────────────────────┤
│                           │                                  │
│  Eylem Katmanı            │  Function Calling               │
│  (Ne yapar?)              │  Tool Use                       │
│                           │                                  │
├───────────────────────────┼──────────────────────────────────┤
│                           │                                  │
│  Entegrasyon Katmanı      │  MCP                            │
│  (Nasıl bağlanır?)        │  (Standart protokol)            │
│                           │                                  │
└─────────────────────────────────────────────────────────────┘

Diyagram 3: AI entegrasyon katmanları ve her birinin rolü.

MCP Ekosistemi: Büyüyen Topluluk

MCP, 2025 yılında hızla büyüyen bir ekosistem haline geldi. GitHub, Slack, Cloudflare, Sentry ve Stripe gibi büyük platformlar MCP’yi entegre etti [25].

Önemli Gelişmeler

OpenAI’nin MCP’yi Benimsemesi: Mart 2025’te OpenAI, MCP’yi ChatGPT masaüstü uygulaması, Agents SDK ve Responses API dahil tüm ürünlerine entegre etme kararı aldığını duyurdu [26].

Google DeepMind Desteği: Nisan 2025’te Google DeepMind CEO’su Demis Hassabis, gelecek Gemini modellerinde ve ilgili altyapıda MCP desteği sağlanacağını doğruladı [27].

GitHub MCP Registry: GitHub, Ekim 2025’te MCP sunucularını keşfetmek, kurmak ve yönetmek için merkezi bir kayıt defteri (registry) başlattı. Şu anda Microsoft, Terraform, Dynatrace ve daha birçok ortaktan 40’ın üzerinde MCP sunucusu içeriyor [28].

MCP Topluluk Registry: Topluluk tarafından yönetilen açık kaynak registry’de 1.000’den fazla kendi kendine yayınlanan sunucu bulunuyor [29].

Popüler MCP Sunucuları

GitHub MCP Server: 100’den fazla GitHub API aracı ile depo yönetimi, PR oluşturma, issue takibi [30]
Slack MCP Server: Kanal yönetimi, mesajlaşma, dosya paylaşımı [31]
PostgreSQL MCP Server: Doğal dil ile SQL sorguları
Cloudflare MCP Server: DNS yönetimi, Workers, KV storage [32]
Playwright MCP Server: Web otomasyonu ve test

Cloudflare ve Uzak MCP Sunucuları

Cloudflare, MCP sunucularını dağıtık altyapı bileşenlerine dönüştürerek MCP’nin geleceğini şekillendiriyor [33]. 300’den fazla şehirde bulunan edge ağı sayesinde, Cloudflare’de dağıtılan MCP sunucuları düşük gecikme süresi ve yüksek kullanılabilirlik sunuyor.

// Cloudflare Worker olarak MCP sunucusu
export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    
    if (url.pathname === "/mcp" && request.method === "POST") {
      const body = await request.json();
      
      // MCP isteğini işle
      const response = await handleMCPRequest(body, env);
      
      return new Response(JSON.stringify(response), {
        headers: { "Content-Type": "application/json" }
      });
    }
    
    return new Response("MCP Server", { status: 200 });
  }
};

2025 MCP Özellik Güncellemeleri

Haziran 2025’te yayınlanan MCP spesifikasyonu önemli iyileştirmeler içeriyor [34]:

Yapılandırılmış Çıktılar (Structured Outputs)

Araçlar artık çıktıları için JSON şema tanımlayabilir, bu da tip güvenliği ve öngörülebilirlik sağlıyor:

@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="get_user",
            description="Kullanıcı bilgisi getirir",
            inputSchema={
                "type": "object",
                "properties": {
                    "user_id": {"type": "integer"}
                },
                "required": ["user_id"]
            },
            outputSchema={  # Yeni özellik
                "type": "object",
                "properties": {
                    "id": {"type": "integer"},
                    "name": {"type": "string"},
                    "email": {"type": "string"}
                },
                "required": ["id", "name"]
            }
        )
    ]

OAuth Yetkilendirme

MCP sunucuları artık resmi olarak OAuth Resource Server olarak sınıflandırılıyor. Bu, standart OAuth 2.0 akışlarıyla entegrasyonu kolaylaştırıyor [35]:

# OAuth ile korunan MCP sunucusu
from fastmcp import FastMCP
from fastmcp.auth import OAuth2Provider

mcp = FastMCP(
    name="secure-server",
    auth=OAuth2Provider(
        discovery_url="https://auth.example.com/.well-known/oauth-authorization-server",
        client_id="mcp-client"
    )
)

Elicitation (Etkileşimli Sorgulama)

Yeni elicitation özelliği, MCP araçlarının eksik bilgi olduğunda kullanıcıyla çok turlu konuşmalar yapmasına olanak tanıyor [36]:

@mcp.tool()
async def create_appointment(
    date: str = None,
    time: str = None,
    description: str = None
) -> dict:
    """Randevu oluşturur, eksik bilgileri kullanıcıdan ister."""
    
    if not date:
        # Elicitation ile kullanıcıdan tarih iste
        date = await elicit("Randevu için tarih seçin:")
    
    if not time:
        time = await elicit("Saat seçin:")
    
    return {
        "status": "created",
        "date": date,
        "time": time,
        "description": description
    }

MCP Güvenlik Hususları

MCP, güçlü yeteneklerle birlikte önemli güvenlik sorumluluklarını da beraberinde getiriyor [37].

Temel Güvenlik Prensipleri

Açık Kullanıcı Onayı: Her araç çağrısı için kullanıcı onayı alınmalı
En Az Ayrıcalık: Araçlara sadece gerekli minimum erişim verilmeli
Giriş Doğrulama: Tüm araç parametreleri doğrulanmalı
Güvenli Transport: Üretimde HTTPS zorunlu

Bilinen Güvenlik Riskleri

Prompt Enjeksiyonu: Saldırganlar, MCP araç açıklamalarına kötü amaçlı komutlar gizleyebilir. Bir görünüşte zararsız “WebSearch” aracının açıklaması, modeli finansal veritabanından veri sızdırmaya yönlendirebilir [38].

Tedarik Zinciri Saldırıları: 2025 ortasında, popüler bir npm paketinde (CVE-2025-6514) kritik bir güvenlik açığı keşfedildi ve sayısız MCP sunucusu etkilendi [39].

Ayrıcalık Yükseltme: “Confused Deputy” saldırısında, yüksek ayrıcalıklara sahip bir AI ajanı, destek talebine gömülü SQL komutlarını çalıştırmaya kandırılabilir [40].

Güvenlik En İyi Pratikleri

# Güvenli MCP sunucusu örneği
from fastmcp import FastMCP
from fastmcp.security import validate_input, rate_limit

mcp = FastMCP(name="secure-server")

@mcp.tool()
@rate_limit(max_calls=100, period=3600)  # Saat başına 100 çağrı
@validate_input  # Otomatik giriş doğrulama
async def sensitive_operation(user_id: int, action: str) -> dict:
    """Hassas işlem - güvenlik kontrolleri uygulanır."""
    
    # İzin verilen eylemler listesi
    allowed_actions = ["read", "update", "delete"]
    if action not in allowed_actions:
        raise ValueError(f"Geçersiz eylem: {action}")
    
    # İşlemi kaydet
    log_audit(user_id, action)
    
    # İşlemi gerçekleştir
    result = await perform_action(user_id, action)
    
    return {"status": "success", "result": result}

Sonuç

Model Bağlam Protokolü, yapay zekanın gerçek dünyayla bağlantı kurma şeklini köklü bir şekilde dönüştürüyor. Geleneksel API entegrasyonlarının karmaşıklığını ortadan kaldırarak, geliştiricilere ve işletmelere daha hızlı, güvenli ve esnek entegrasyonlar sunuyor.

MCP’nin Temel Değer Önermeleri

Standartlaşma: Her araç için ayrı entegrasyon yerine tek bir protokol
Taşınabilirlik: Aynı sunucu tüm MCP istemcileriyle çalışıyor
Keşfedilebilirlik: Araçlar çalışma zamanında dinamik olarak keşfedilebiliyor
Güvenlik: Varsayılan olarak gizlilik ve erişim kontrolü

Geleceğe Bakış

MCP’nin HTTP’nin web için yaptığını yapay zeka için yapması muhtemel görünüyor. Büyük oyuncuların (OpenAI, Google DeepMind, Microsoft) protokolü benimsemesi, MCP’nin endüstri standardı haline gelme yolunda emin adımlarla ilerlediğini gösteriyor [41].

Eylül 2025’te duyurulan gelecek güncellemeler arasında uzun süreli asenkron işlemler, sektöre özel uzantılar ve SDK seviyelendirme sistemi bulunuyor [42].

Başlamak İçin Öneriler

Eğer bir geliştiriciyseniz veya yapay zeka odaklı bir işletmeyseniz, MCP’yi keşfetmek için en iyi zaman şimdidir:

Başlangıç: FastMCP ile basit bir sunucu oluşturun
Deneyim: Claude Desktop ile entegre edin
Genişletme: Mevcut API’lerinizi MCP sunucularına dönüştürün
Katkı: Açık kaynak topluluğuna katılın

MCP, yapay zeka ajanlarını sadece akıllı değil, aynı zamanda işlevsel ve pratik hale getiriyor. Gelecekte, yapay zeka sistemlerimizin dış dünyayla nasıl etkileşim kurduğunu tanımlayan temel protokol olmaya aday.

Başka bir yazıda görüşmek üzere, hoşçakalın…

Kaynaklar

[1] Anthropic. (2024). “Introducing the Model Context Protocol.” https://www.anthropic.com/news/model-context-protocol

[2] BytePlus. (2025). “Model Context Protocol Specification – Technical Guide 2025.” https://www.byteplus.com/en/topic/542166

[3] Keywords AI. (2025). “A Complete Guide to the Model Context Protocol (MCP) in 2025.” https://www.keywordsai.co/blog/introduction-to-mcp

[4] Wikipedia. (2025). “Model Context Protocol.” https://en.wikipedia.org/wiki/Model_Context_Protocol

[5] MCP Specification. (2025). “Architecture Overview.” https://modelcontextprotocol.io/specification/2025-06-18

[6] ClaudeMCP. (2025). “MCP Protocol Specification.” https://www.claudemcp.com/specification

[7] Quash. (2025). “Model Context Protocol (MCP): The Definitive 2025 Guide.” https://quashbugs.com/blog/model-context-protocol-mcp-guide

[8] GitHub. (2025). “Model Context Protocol Python SDK.” https://github.com/modelcontextprotocol/python-sdk

[9] MCP Specification. (2025). “Transports.” https://modelcontextprotocol.io/docs/concepts/transports

[10] MCP Framework. (2025). “SSE Transport.” https://mcp-framework.com/docs/Transports/sse/

[11] MCPcat. (2025). “MCP Transport Protocols: stdio vs SSE vs StreamableHTTP.” https://mcpcat.io/guides/comparing-stdio-sse-streamablehttp/

[12] Real Python. (2025). “Python MCP Server: Connect LLMs to Your Data.” https://realpython.com/python-mcp/

[13] FastMCP GitHub. (2025). “The fast, Pythonic way to build MCP servers and clients.” https://github.com/jlowin/fastmcp

[14] MCP Official Documentation. (2025). “Build an MCP Client.” https://modelcontextprotocol.io/quickstart/client

[15] Real Python. (2025). “Build a Python MCP Client to Test Servers From Your Terminal.” https://realpython.com/python-mcp-client/

[16] GitHub. (2025). “Simple MCP Server with Python.” https://github.com/ruslanmv/Simple-MCP-Server-with-Python

[17] PyPI. (2025). “mcp Package.” https://pypi.org/project/mcp/

[18] DigitalOcean. (2025). “MCP Server in Python — Everything I Wish I’d Known on Day One.” https://www.digitalocean.com/community/tutorials/mcp-server-python

[19] Medium. (2025). “Building a Basic MCP Server with Python.” https://medium.com/data-engineering-with-dremio/building-a-basic-mcp-server-with-python-4c34c41031ed

[20] Composio. (2025). “MCP server: A step-by-step guide to building from scratch.” https://composio.dev/blog/mcp-server-step-by-step-guide-to-building-from-scrtch

[21] Descope. (2025). “MCP vs. Function Calling: How They Differ and Which to Use.” https://www.descope.com/blog/post/mcp-vs-function-calling

[22] Zilliz. (2025). “Function Calling vs. MCP vs. A2A: Developer’s Guide to AI Agent Protocols.” https://zilliz.com/blog/function-calling-vs-mcp-vs-a2a-developers-guide-to-ai-agent-protocols

[23] BytePlus. (2025). “MCP vs Langchain: Comprehensive 2025 Comparison.” https://www.byteplus.com/en/topic/541311

[24] Medium. (2025). “LangChain vs. MCP — How They Work, When to Use Them, and Why They Matter.” https://medium.com/@jalajagr/langchain-vs-mcp-how-they-work-when-to-use-them-and-why-they-matter-171c5b6fab1c

[25] Latent Space. (2025). “Why MCP Won.” https://www.latent.space/p/why-mcp-won

[26] LangChain Blog. (2025). “MCP: Flash in the Pan or Future Standard?” https://blog.langchain.com/mcp-fad-or-fixture/

[27] VisionVix. (2025). “LangChain vs MCP: Which Framework Is Better for Multi-Agent AI Development?” https://visionvix.com/langchain-vs-mcp/

[28] InfoQ. (2025). “GitHub MCP Registry Offers a Central Hub for Discovering and Deploying MCP Servers.” https://www.infoq.com/news/2025/10/github-mcp-registry/

[29] GitHub. (2025). “MCP Registry – A community driven registry service.” https://github.com/modelcontextprotocol/registry

[30] GitHub Blog. (2025). “How to find, install, and manage MCP servers with the GitHub MCP Registry.” https://github.blog/ai-and-ml/generative-ai/how-to-find-install-and-manage-mcp-servers-with-the-github-mcp-registry/

[31] DEV Community. (2025). “Top 10 MCP Servers for 2025.” https://dev.to/fallon_jimmy/top-10-mcp-servers-for-2025-yes-githubs-included-15jg

[32] Cloudflare Blog. (2025). “Build and deploy Remote Model Context Protocol (MCP) servers to Cloudflare.” https://blog.cloudflare.com/remote-model-context-protocol-servers-mcp/

[33] GitHub. (2025). “Cloudflare MCP Server.” https://github.com/cloudflare/mcp-server-cloudflare

[34] MCP Info. (2025). “Update on the Next MCP Protocol Release.” https://modelcontextprotocol.info/blog/mcp-next-version-update/

[35] Auth0. (2025). “Model Context Protocol (MCP) Spec Updates from June 2025.” https://auth0.com/blog/mcp-specs-update-all-about-auth/

[36] Medium. (2025). “MCP 2025–06–18 Revolutionized Everything.” https://medium.com/@aywengo/mcp-2025-06-18-revolutionized-everything-our-schema-registry-server-transformation-8ca027c296f4

[37] Enkrypt AI. (2025). “MCP: The Protocol That’s Quietly Revolutionizing AI Integration.” https://www.enkryptai.com/blog/mcp-the-protocol-thats-quietly-revolutionizing-ai-integration

[38] Cloudflare Blog. (2025). “Securing the AI Revolution: Introducing Cloudflare MCP Server Portals.” https://blog.cloudflare.com/zero-trust-mcp-server-portals/

[39] Glama. (2025). “Comparing MCP vs LangChain/ReAct for Chatbots.” https://glama.ai/blog/2025-09-02-comparing-mcp-vs-lang-chainre-act-for-chatbots

[40] Hugging Face Blog. (2025). “What Is MCP, and Why Is Everyone – Suddenly!– Talking About It?” https://huggingface.co/blog/Kseniase/mcp

[41] IKangAI. (2025). “Model Context Protocol Comparison: MCP vs Function Calling, Plugins, APIs.” https://www.ikangai.com/model-context-protocol-comparison-mcp-vs-function-calling-plugins-apis/

[42] MarkTechPost. (2025). “Model Context Protocol (MCP) vs Function Calling vs OpenAPI Tools — When to Use Each?” https://www.marktechpost.com/2025/10/08/model-context-protocol-mcp-vs-function-calling-vs-openapi-tools-when-to-use-each/

Bir yanıt yazın Yanıtı iptal et

Yorum yapabilmek için oturum açmalısınız.