Model Context Protocol (MCP): Demo Projesiyle Rehber

Model Context Protocol (MCP), büyük dil modellerinin standart bir arayüz üzerinden harici araçlar, veritabanları ve API’lerle dinamik şekilde etkileşime girmesini sağlayan açık bir standarttır.

Bu blogda, Claude Desktop ile entegre çalışan MCP tabanlı bir PR inceleme sunucusu oluşturma sürecini adım adım göstereceğim. Bu sunucu şunları yapacak:

• GitHub’dan PR ayrıntılarını ve değişen dosyaları getirme
• Claude Desktop uygulamasıyla kod değişikliklerini analiz etme
• PR inceleme özetleri ve önerileri üretme
• İncelemeleri Notion’a kaydetme

Sunucu ile Claude Desktop arasındaki iletişimi standartlaştırmak, sistemi modüler ve ölçeklenebilir kılmak için Model Context Protocol (MCP) kullanacağız.

Okurlarımızı, haftanın öne çıkan haberlerini sade bir dille anlatan ücretsiz Cuma bültenimiz The Median ile en güncel yapay zeka gelişmelerinden haberdar ediyoruz. Abone olun, haftada sadece birkaç dakikada güncel kalın:

Model Context Protocol (MCP) Nedir?

Model Context Protocol (MCP), Anthropic tarafından geliştirilen, yapay zeka modelleri ile harici araçlar arasında kolay ve standart bir entegrasyon sağlayan açık bir standarttır. Evrensel bir bağlayıcı gibi davranarak büyük dil modellerinin (LLM) API’ler, veritabanları ve iş uygulamalarıyla dinamik biçimde etkileşmesini sağlar.

Başta Claude’un harici sistemlerle etkileşimini iyileştirmek için geliştirilen MCP, Anthropic tarafından 2024’ün başında açık kaynaklandı ve yaygın benimsemeyi teşvik etmeyi amaçladı. MCP’yi herkese açarak, tescilli entegrasyonlara bağımlılığı azaltan, yapay zeka uygulamaları arasında daha fazla modülerlik ve birlikte çalışabilirlik sağlayan standart bir çerçeve oluşturmayı hedeflediler.

MCP, şu şekilde bir istemci-sunucu mimarisini izler:

• MCP istemcileri (ör. Claude Desktop) bilgi talep eder ve görevleri yürütür.
• MCP sunucuları, harici araçlar ve veri kaynaklarına erişim sağlar.
• Ana uygulamalar, modeller ve araçlar arasında iletişim için MCP’yi kullanır.

Kaynak: Model Context Protocol

Projelerinizde MCP kullanmak isteyebileceğiniz nedenler:

• Standartlaştırılmış yapay zeka entegrasyonu: MCP, yapay zeka modellerini araçlara bağlamak için yapılandırılmış bir yol sunar.
• Esneklik: Farklı yapay zeka modelleri ve sağlayıcılar arasında kolay geçiş sağlar.
• Güvenlik: Yapay zeka ile etkileşirken verilerinizin kendi altyapınızda kalmasını sağlar.
• Ölçeklenebilirlik: MCP, stdio, WebSockets, HTTP SSE ve UNIX soketleri gibi çeşitli taşıma katmanlarını destekler.

MCP Demo Proje Genel Bakış: PR İnceleme Sunucusu

PR inceleme sistemi, Claude Desktop ve Notion kullanarak kod analizi ve dokümantasyonu otomatikleştirir.

İzleyeceğimiz hattın kısa bir özeti:

1. Ortam kurulumu: GitHub ve Notion kimlik bilgilerini yükleyin.
2. Sunucu başlatma: Claude Desktop ile iletişim kurmak için bir MCP sunucusu başlatın.
3. PR verilerini getirme: GitHub’dan PR değişikliklerini ve meta verileri alın.
4. Kod analizi: Claude Desktop kod değişikliklerini doğrudan analiz eder (ayrı bir araca gerek yoktur).
5. Notion dokümantasyonu: Analiz sonuçlarını takibe almak için Notion’a kaydedin.

Adım 1: Ortamı Hazırlama

Başlamadan önce Python 3.10+ kurulu olduğundan emin olun. Ardından ortamımızı kurup uv paket yöneticisini yükleyerek başlıyoruz. Mac veya Linux için: 

curl -LsSf https://astral.sh/uv/install.sh | sh  # Mac/Linux

Windows (PowerShell) için:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Sonra yeni bir proje klasörü oluşturup uv ile başlatıyoruz:

uv init pr_reviewer
cd pr_reviewer

Şimdi sanal bir ortam oluşturup etkinleştirebiliriz. Mac veya Linux için:

uv venv
source .venv/bin/activate

Windows için:

.venv\Scripts\activate

Şimdi gerekli bağımlılıkları yüklüyoruz:

uv add "mcp[cli]" requests python-dotenv notion-client

Bu projede conda yerine uv kullanacağız; çünkü daha hızlı, daha hafif ve Python paket yönetimine odaklı. Neler yaptığımızı özetleyelim:

• uv paket yöneticisiyle bir GitHub PR İnceleme MCP sunucusu geliştirme ortamı kurduk.
• pr_reviewer adında yeni bir proje klasörü başlattık ve içine geçtik.
• Paket kurulumlarını izole etmek için bir sanal ortam oluşturup etkinleştirdik.

Adım 2: Bağımlılıkları Yükleme

Ortamımız hazır olduğunda, API anahtarları ve diğer gereksinimlerle bağımlılıkları ayarlıyoruz. Bir requirements.txt dosyası oluşturup aşağıdaki Python paketlerini ekleyin:

# Core dependencies for PR Analyzer
requests>=2.31.0          # For GitHub API calls
python-dotenv>=1.0.0      # For environment variables
mcp[cli]>=1.4.0          # For MCP server functionality
notion-client>=2.3.0      # For Notion integration

# Optional: Pin versions for stability
# requests==2.31.0
# python-dotenv==1.0.0
# mcp[cli]==1.4.0
# notion-client==2.3.0

requirements.txt dosyası projede gereken tüm temel bağımlılıkları içerir. Bağımlılıkları kurmak için aşağıdaki komutlardan birini çalıştırın (önceden kurduysanız uv kullanın).

uv pip install -r requirements.txt
pip install -r requirements.txt

Artık ortamınızda gerekli tüm bağımlılıklar yüklü.

Adım 3: Ortam Değişkenlerini Ayarlama

Sırada bu proje için gereken tüm anahtar ve belirteçleri içeren bir .env dosyası oluşturmak var. 

GitHub belirteçleri oluşturma

GitHub belirteci oluşturmak için:

• GitHub hesabınıza giriş yapıp ayarlara gidin.
• Geliştirici ayarları → Kişisel Erişim Belirteçleri bölümüne gidin.
• Yeni Belirteç Oluştur’a tıklayın ve klasik sürümü seçin.
• Belirtece bir ad verin ve aşağıdaki izinleri etkinleştirin:
• read:org
• read:repo_hook
• repo
• Belirteci oluşturmak için Oluştur’a tıklayın.
• Belirteci kopyalayıp güvenli şekilde saklayın; API isteklerinde kimlik doğrulama için kullanılacaktır.

Notion entegrasyonları

• Notion’un entegrasyon sayfasına giriş yapın.
• Yeni bir entegrasyon oluşturup formu doldurun. “type” alanını Internal olarak bırakın ve çalışma alanınıza ekleyin. 

• Entegrasyonu kaydedin ve entegrasyon bağlantısını kopyalayın (URL’nin sonundaki UUID, Evrensel Benzersiz Tanımlayıcıdır; bunu not alın ve Notion Sayfa Kimliği olarak kullanın).

https://www.notion.so/profile/integrations/internal/UUID

• Entegrasyon oluşturulduktan sonra üzerine tıklayın ve yapılandırma bölümünden Internal Integration Secret’ı kopyalayın; bu, sizin Notion API anahtarınız olacaktır.

Bir .env dosyası oluşturma

Şimdi bir .env dosyası oluşturun ve yukarıda ürettiğimiz API anahtarları ile belirteçleri ekleyin.

GITHUB_TOKEN=your_github_token
NOTION_API_KEY=your_notion_api_key
NOTION_PAGE_ID=your_notion_page_id

Adım 4: GitHub Entegrasyonu

GitHub deposundan PR değişikliklerini yönetip almak için GitHub entegrasyon modülümüzü yapılandıralım.

Bir github_integration.py dosyası oluşturup aşağıdaki kodu yazın (birazdan açıklayacağız).

import os
import requests
import traceback
from dotenv import load_dotenv

# Load environment variables
load_dotenv()
GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')

def fetch_pr_changes(repo_owner: str, repo_name: str, pr_number: int) -> list:
    """Fetch changes from a GitHub pull request.
    
    Args:
        repo_owner: The owner of the GitHub repository
        repo_name: The name of the GitHub repository
        pr_number: The number of the pull request to analyze
        
    Returns:
        A list of file changes with detailed information about each change
    """
    print(f" Fetching PR changes for {repo_owner}/{repo_name}#{pr_number}")
    
    # Fetch PR details
    pr_url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/pulls/{pr_number}"
    files_url = f"{pr_url}/files"
    headers = {'Authorization': f'token {GITHUB_TOKEN}'}
    
    try:
        # Get PR metadata
        pr_response = requests.get(pr_url, headers=headers)
        pr_response.raise_for_status()
        pr_data = pr_response.json()
        
        # Get file changes
        files_response = requests.get(files_url, headers=headers)
        files_response.raise_for_status()
        files_data = files_response.json()
        
        # Combine PR metadata with file changes
        changes = []
        for file in files_data:
            change = {
                'filename': file['filename'],
                'status': file['status'],  # added, modified, removed
                'additions': file['additions'],
                'deletions': file['deletions'],
                'changes': file['changes'],
                'patch': file.get('patch', ''),  # The actual diff
                'raw_url': file.get('raw_url', ''),
                'contents_url': file.get('contents_url', '')
            }
            changes.append(change)
        
        # Add PR metadata
        pr_info = {
            'title': pr_data['title'],
            'description': pr_data['body'],
            'author': pr_data['user']['login'],
            'created_at': pr_data['created_at'],
            'updated_at': pr_data['updated_at'],
            'state': pr_data['state'],
            'total_changes': len(changes),
            'changes': changes
        }
        
        print(f"Successfully fetched {len(changes)} changes")
        return pr_info
        
    except Exception as e:
        print(f"Error fetching PR changes: {str(e)}")
        traceback.print_exc()
        return None

# Example usage for debugging
# pr_data = fetch_pr_changes('owner', 'repo', 1)
# print(pr_data) 

fetch_pr_changes() fonksiyonu, verilen bir GitHub pull request’inden değişiklikleri alır ve döndürür. repo_owner, repo_name ve pr_number olmak üzere üç parametre alır ve PR meta verileriyle birlikte yapılandırılmış bir dosya değişiklikleri listesi döndürür.

requests kütüphanesi, kimlik doğrulamalı HTTP GET istekleri göndererek genel PR meta verilerini ve ayrıntılı dosya düzeyi değişikliklerini alır:

• İlk API isteği; başlık, açıklama, yazar bilgileri, zaman damgaları ve mevcut durum gibi üst düzey PR bilgilerini getirir.
• İkinci API isteği; PR’da değişen her dosyayla ilgili ayrıntıları (dosya adı, değişim durumu, eklenen/silinen satır sayıları ve dosya içeriğine erişim URL’leri gibi) getirir.

Veriler alındıktan sonra fonksiyon, PR meta verilerini dosya değişiklikleriyle birleştirerek bir sözlük yapısına dönüştürür. Dosya değişiklikleri, her öğesi bir dosyayla ilgili ayrıntılı bilgileri içeren bir listede tutulur. Nihai yapı; PR başlığı, açıklaması, yazarı, zaman damgaları, durumu, değişen dosyaların toplam sayısı ve dosya değişikliklerinin ayrıntılı dökümünü içerir.

Adım 5: MCP Sunucusunu Uygulama

Artık tüm bağımlılıklar ve yardımcı fonksiyonlar hazır olduğuna göre MCP sunucumuzu kuruyoruz. pr_analyzer.py dosyasını oluşturuyoruz; bu dosya şunları yapacak:

• Bir MCP sunucusu başlatır.
• PR ayrıntılarını getirmek, kodu analiz etmek ve sonuçları Notion’da saklamak için araçlar tanımlar.
• Bu araçları, özetleme, olası çözümler ve daha fazlası için Claude Desktop’a sunar.

Önce kodu ekleyelim, ardından açıklayalım 

import sys
import os
import traceback
from typing import Any, List, Dict
from mcp.server.fastmcp import FastMCP
from github_integration import fetch_pr_changes
from notion_client import Client
from dotenv import load_dotenv

class PRAnalyzer:
    def __init__(self):
        # Load environment variables
        load_dotenv()
        
        # Initialize MCP Server
        self.mcp = FastMCP("github_pr_analysis")
        print("MCP Server initialized", file=sys.stderr)
        
        # Initialize Notion client
        self._init_notion()
        
        # Register MCP tools
        self._register_tools()
    
    def _init_notion(self):
        """Initialize the Notion client with API key and page ID."""
        try:
            self.notion_api_key = os.getenv("NOTION_API_KEY")
            self.notion_page_id = os.getenv("NOTION_PAGE_ID")
            
            if not self.notion_api_key or not self.notion_page_id:
                raise ValueError("Missing Notion API key or page ID in environment variables")
            
            self.notion = Client(auth=self.notion_api_key)
            print(f"Notion client initialized successfully", file=sys.stderr)
            print(f"Using Notion page ID: {self.notion_page_id}", file=sys.stderr)
        except Exception as e:
            print(f"Error initializing Notion client: {str(e)}", file=sys.stderr)
            traceback.print_exc(file=sys.stderr)
            sys.exit(1)
    
    def _register_tools(self):
        """Register MCP tools for PR analysis."""
        @self.mcp.tool()
        async def fetch_pr(repo_owner: str, repo_name: str, pr_number: int) -> Dict[str, Any]:
            """Fetch changes from a GitHub pull request."""
            print(f"Fetching PR #{pr_number} from {repo_owner}/{repo_name}", file=sys.stderr)
            try:
                pr_info = fetch_pr_changes(repo_owner, repo_name, pr_number)
                if pr_info is None:
                    print("No changes returned from fetch_pr_changes", file=sys.stderr)
                    return {}
                print(f"Successfully fetched PR information", file=sys.stderr)
                return pr_info
            except Exception as e:
                print(f"Error fetching PR: {str(e)}", file=sys.stderr)
                traceback.print_exc(file=sys.stderr)
                return {}
        
        @self.mcp.tool()
        async def create_notion_page(title: str, content: str) -> str:
            """Create a Notion page with PR analysis."""
            print(f"Creating Notion page: {title}", file=sys.stderr)
            try:
                self.notion.pages.create(
                    parent={"type": "page_id", "page_id": self.notion_page_id},
                    properties={"title": {"title": [{"text": {"content": title}}]}},
                    children=[{
                        "object": "block",
                        "type": "paragraph",
                        "paragraph": {
                            "rich_text": [{
                                "type": "text",
                                "text": {"content": content}
                            }]
                        }
                    }]
                )
                print(f"Notion page '{title}' created successfully!", file=sys.stderr)
                return f"Notion page '{title}' created successfully!"
            except Exception as e:
                error_msg = f"Error creating Notion page: {str(e)}"
                print(error_msg, file=sys.stderr)
                traceback.print_exc(file=sys.stderr)
                return error_msg
    
    def run(self):
        """Start the MCP server."""
        try:
            print("Running MCP Server for GitHub PR Analysis...", file=sys.stderr)
            self.mcp.run(transport="stdio")
        except Exception as e:
            print(f"Fatal Error in MCP Server: {str(e)}", file=sys.stderr)
            traceback.print_exc(file=sys.stderr)
            sys.exit(1)

if __name__ == "__main__":
    analyzer = PRAnalyzer()
    analyzer.run() 

Yukarıdaki kod, GitHub PR değişikliklerini almak ve analiz sonuçlarını Notion’da saklamak için bir MCP Sunucusu kurar. Temel bileşenleri inceleyelim:

1. Ortam kurulumu ve başlatma
• dotenv modülü, API anahtarları ve kimlik bilgilerine güvenli erişim için ortam değişkenlerini yükler. 
• PRAnalyzer sınıfı, FastMCP() işleviyle github_pr_analysis adıyla bir MCP sunucusu başlatır ve Claude Desktop uygulamasıyla etkileşime imkân tanır.
• Notion istemcisi de notion-client paketiyle kurulur ve .env dosyasındaki Notion API anahtarı ile sayfa kimliğini kullanır.
2. MCP aracı: PR değişikliklerini getirme
• fetch_pr() işlevi, github_integration.py dosyasındaki fetch_pr_changes() yöntemini kullanarak GitHub’dan PR meta verilerini alır. Başarılı olursa PR ayrıntılarını içeren bir sözlük döndürür.
• Bu süreci GitHub’a gömülü Webhooks kütüphanesiyle otomatikleştirebilirsiniz; böylece deponuzda oluşturulan her yeni PR otomatik olarak sunucu tarafından işlenir. 
3. MCP aracı: Bir Notion sayfası oluşturma
• create_notion_page() işlevi, PR analiz sonuçlarıyla bir Notion sayfası oluşturur.
• Belirtilen Notion çalışma alanında yeni bir sayfa oluşturmak için Notion API’sini kullanır.
4. Sunucuyu çalıştırma
• run() yöntemi, mcp.run(transport="stdio") ile MCP sunucusunu başlatır ve Claude Desktop ile PR inceleme araçları arasındaki etkileşimi etkinleştirir.

Adım 6: MCP Sunucusunu Çalıştırma

Artık tüm kod parçaları hazır olduğuna göre, sunucumuzu aşağıdaki terminal komutuyla çalıştırıyoruz:

python pr_analyzer.py

Sunucu çalışmaya başladıktan sonra Claude Desktop uygulamasını açın; metin kutusunda bir fiş simgesi (🔌) göreceksiniz. Bu fiş, Claude ortamında bir MCP bulunduğunu gösterir. Aynı metin kutusunda mevcut tüm MCP’leri gösteren çekiç benzeri bir simge (🔨) de göreceksiniz; aşağıda gösterildiği gibi.

Şimdi analiz etmek istediğiniz PR bağlantısını verin; gerisini Claude halledecek.

Claude önce PR’ı analiz edecek, ardından bunun bir özetini ve incelemesini sunacaktır. Kullanıcılara ayrıntıları Notion sayfasına yüklemek isteyip istemediklerini soracaktır. Bunu otomatikleştirebilirsiniz; ancak mevcut kod, yeni bir Notion sayfası oluşturmadan önce özeti gözden geçirmenize olanak tanır.

Güncellenen Notion sayfası şöyle görünüyor:

Sonuç

PR İnceleme MCP tabanlı sunucumuz, kod analizi ve dokümantasyonu iyileştirerek inceleme sürecini verimli ve düzenli hale getirir. MCP, GitHub API ve Notion entegrasyonunu kullanarak bu sistem; otomatik PR analizi, kolay işbirliği ve yapılandırılmış dokümantasyon sağlar. Bu yapılandırmayla geliştiriciler PR ayrıntılarını hızla alabilir, kod değişikliklerini Claude ile analiz edebilir ve içgörüleri gelecekte başvurmak üzere Notion’da saklayabilir.

Daha güncel yapay zeka araçlarını keşfetmek için şu blogları öneririm:

• Gemma 3’ü Ollama ile Yerelde Kurup Çalıştırma
• Mistral OCR: Uygulamalı Örneklerle Rehber
• OpenAI Agents SDK Eğitimi: Eyleme Geçen Yapay Zeka Sistemleri Kurma
• Baidu ERNIE 4.5 & X1: Özellikler, Erişim, DeepSeek Karşılaştırması
• Chrome DevTools MCP: Yapay Zeka Destekli Tarayıcı Otomasyonu ve Hata Ayıklama