Model Context Protocol (MCP): Panduan dengan Proyek Demo

Model Context Protocol (MCP) adalah standar terbuka yang memungkinkan model bahasa besar berinteraksi secara dinamis dengan alat, basis data, dan API eksternal melalui antarmuka yang terstandarisasi.

Dalam blog ini, saya akan memandu Anda membangun server ulasan PR berbasis MCP yang terintegrasi dengan Claude Desktop. Server ini akan:

• Mengambil detail PR dan berkas yang berubah dari GitHub
• Menganalisis perubahan kode menggunakan aplikasi Claude Desktop
• Menghasilkan ringkasan ulasan PR dan saran
• Menyimpan ulasan ke Notion

Kita akan menggunakan Model Context Protocol (MCP) untuk menstandarkan komunikasi antara server dan Claude Desktop, sehingga modular dan dapat diskalakan.

Kami terus memperbarui pembaca tentang kabar terbaru AI melalui The Median, buletin gratis setiap Jumat yang merangkum cerita kunci pekan ini. Berlangganan dan tetap tajam hanya dalam beberapa menit per minggu:

Apa Itu Model Context Protocol (MCP)?

Model Context Protocol (MCP) adalah standar terbuka yang dikembangkan oleh Anthropic untuk memudahkan dan menstandarkan integrasi antara model AI dan alat eksternal. Ini berfungsi sebagai penghubung universal, memungkinkan model bahasa besar (LLM) berinteraksi secara dinamis dengan API, basis data, dan aplikasi bisnis.

Awalnya dibangun untuk meningkatkan kemampuan Claude berinteraksi dengan sistem eksternal, Anthropic memutuskan untuk membuka sumber MCP pada awal 2024 guna mendorong adopsi industri secara luas. Dengan menjadikan MCP tersedia untuk publik, mereka bertujuan menciptakan kerangka kerja standar untuk komunikasi AI-ke-alat, mengurangi ketergantungan pada integrasi proprieter dan memungkinkan modularitas serta interoperabilitas yang lebih besar di seluruh aplikasi AI.

MCP mengikuti arsitektur klien-server di mana:

• Klien MCP (mis., Claude Desktop) meminta informasi dan mengeksekusi tugas.
• Server MCP menyediakan akses ke alat eksternal dan sumber data.
• Aplikasi host menggunakan MCP untuk berkomunikasi antara model dan alat.

Sumber: Model Context Protocol

Inilah alasan Anda ingin menggunakan MCP untuk proyek Anda:

• Integrasi AI yang terstandar: MCP menyediakan cara terstruktur untuk menghubungkan model AI dengan alat.
• Fleksibilitas: Memungkinkan pergantian mudah antar model dan penyedia AI yang berbeda.
• Keamanan: Data Anda tetap berada dalam infrastruktur Anda saat berinteraksi dengan AI.
• Skalabilitas: MCP mendukung berbagai transport seperti stdio, WebSocket, HTTP SSE, dan soket UNIX.

Gambaran Proyek Demo MCP: Server Ulasan PR

Sistem ulasan PR mengotomatiskan analisis kode dan dokumentasi menggunakan Claude Desktop dan Notion.

Berikut ringkasan alur kerjanya:

1. Penyiapan lingkungan: Muat kredensial GitHub dan Notion.
2. Inisialisasi server: Menjalankan server MCP untuk berkomunikasi dengan Claude Desktop.
3. Mengambil data PR: Mengambil perubahan dan metadata PR dari GitHub.
4. Analisis kode: Claude Desktop langsung menganalisis perubahan kode (tanpa alat terpisah).
5. Dokumentasi di Notion: Menyimpan hasil analisis ke Notion untuk pelacakan.

Langkah 1: Menyiapkan Lingkungan

Sebelum mulai, pastikan Anda telah memasang Python 3.10+. Lalu, kita menyiapkan lingkungan dan mulai dengan memasang manajer paket uv. Untuk Mac atau Linux: 

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

Untuk Windows (PowerShell):

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

Lalu, kita membuat direktori proyek baru dan menginisialisasinya dengan uv:

uv init pr_reviewer
cd pr_reviewer

Sekarang kita dapat membuat dan mengaktifkan virtual environment. Untuk Mac atau Linux:

uv venv
source .venv/bin/activate

Untuk Windows:

.venv\Scripts\activate

Sekarang kita memasang dependensi yang diperlukan:

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

Kita akan menggunakan uv alih-alih conda untuk proyek ini karena lebih cepat, lebih ringan, dan lebih berfokus pada manajemen paket Python. Mari rekap apa yang baru saja kita lakukan:

• Menyiapkan lingkungan pengembangan server MCP Ulasan PR GitHub menggunakan manajer paket uv
• Menginisialisasi direktori proyek baru bernama pr_reviewer dan masuk ke dalamnya.
• Membuat virtual environment dan mengaktifkannya agar pemasangan paket terisolasi.

Langkah 2: Memasang Dependensi

Setelah lingkungan siap, kita menyiapkan dependensi dengan kunci API dan persyaratan lainnya. Buat berkas requirements.txt dan tambahkan paket Python berikut ke dalamnya:

# 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

Berkas requirements.txt memuat semua dependensi inti yang diperlukan untuk proyek. Untuk menyiapkan dependensi, jalankan salah satu perintah berikut (gunakan uv jika Anda sudah memasangnya sebelumnya).

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

Sekarang, lingkungan Anda telah memasang semua dependensi yang diperlukan.

Langkah 3: Menyiapkan Variabel Lingkungan

Berikutnya, kita membuat berkas .env yang berisi semua kunci dan token yang diperlukan untuk proyek ini. 

Membuat token GitHub

Untuk membuat token GitHub:

• Masuk ke akun GitHub Anda dan buka pengaturan.
• Masuk ke developer settings → Personal Access Tokens.
• Klik Generate New Token dan pilih versi klasik.
• Berikan nama untuk token dan aktifkan izin berikut:
• read:org
• read:repo_hook
• repo
• Klik Generate untuk membuat token.
• Salin dan simpan token dengan aman, karena akan digunakan untuk autentikasi dalam permintaan API.

Integrasi Notion

• Masuk ke halaman integrasi Notion.
• Buat integrasi baru dan lengkapi formulir. Biarkan “type” tetap Internal dan tambahkan ke workspace Anda. 

• Simpan integrasi dan salin tautan integrasi (UUID di akhir URL adalah Universally Unique Identifier yang perlu Anda catat dan gunakan sebagai Notion Page ID).

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

• Setelah integrasi dibuat, klik integrasi tersebut, lalu pada bagian konfigurasi, salin Internal Integration Secret, yang akan menjadi kunci API Notion Anda.

Membuat berkas .env

Sekarang, buat berkas .env dan tambahkan teks berikut beserta kunci API dan token yang telah kita buat di atas.

GITHUB_TOKEN=your_github_token
NOTION_API_KEY=your_notion_api_key
NOTION_PAGE_ID=your_notion_page_id

Langkah 4: Integrasi GitHub

Mari konfigurasikan modul integrasi GitHub kita untuk mengelola dan mengambil perubahan PR dari repositori GitHub.

Buat berkas github_integration.py dan tulis kode berikut (akan kita jelaskan sebentar lagi).

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) 

Fungsi fetch_pr_changes() mengambil dan mengembalikan perubahan dari pull request GitHub tertentu. Fungsi ini menerima tiga parameter, yaitu repo_owner, repo_name, dan pr_number, dan mengembalikan daftar terstruktur perubahan berkas beserta metadata PR.

Kode menggunakan pustaka requests untuk mengirim permintaan HTTP GET terautentikasi, mengambil metadata PR umum dan perubahan rinci di tingkat berkas:

• Permintaan API pertama mengambil informasi tingkat tinggi PR, termasuk judul, deskripsi, detail penulis, cap waktu, dan status saat ini.
• Permintaan API kedua mengambil detail tentang setiap berkas yang diubah dalam PR, seperti nama berkas, status modifikasi, jumlah baris yang ditambahkan atau dihapus, dan URL untuk mengakses isi berkas.

Setelah data diambil, fungsi menstrukturkan dan menggabungkan metadata PR dengan perubahan berkas ke dalam sebuah kamus. Perubahan berkas disimpan dalam sebuah daftar, dengan setiap entri berisi informasi detail tentang satu berkas. Struktur data akhir mencakup judul PR, deskripsi, penulis, cap waktu, status, jumlah total berkas yang berubah, dan rincian modifikasi berkas.

Langkah 5: Menerapkan Server MCP

Setelah semua dependensi dan fungsi tambahan siap, kita menyiapkan server MCP. Kita membuat berkas pr_analyzer.py, yang akan:

• Menginisialisasi server MCP.
• Mendefinisikan alat untuk mengambil detail PR, menganalisis kode, dan menyimpan hasil di Notion.
• Mengekspos alat ini ke Claude Desktop untuk pembuatan ringkasan, solusi yang mungkin, dan lainnya.

Mari tambahkan dulu kodenya dan kemudian kita jelaskan 

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() 

Kode di atas menyiapkan Server MCP untuk mengambil perubahan PR GitHub dan menyimpan hasil analisis di Notion. Mari kita bahas komponen kuncinya:

1. Penyiapan lingkungan dan inisialisasi
• Modul dotenv memuat variabel lingkungan, memastikan kunci API dan kredensial diakses dengan aman. 
• Kemudian, kelas PRAnalyzer menginisialisasi server MCP menggunakan fungsi FastMCP() yang menginisialisasi server MCP dengan nama github_pr_analysis dan mengaktifkan interaksi dengan aplikasi Claude Desktop.
• Klien Notion juga disiapkan menggunakan paket notion-client, yang memanfaatkan kunci API Notion dan ID halaman yang disimpan dalam berkas .env.
2. Alat MCP: mengambil perubahan PR
• Fungsi fetch_pr() mengambil metadata pull request dari GitHub menggunakan metode fetch_pr_changes() dari berkas github_integration.py. Jika berhasil, fungsi mengembalikan kamus yang berisi detail PR.
• Anda dapat mengotomatiskan proses ini menggunakan pustaka Webhooks yang tertanam di GitHub sehingga PR baru apa pun yang dibuat di repositori Anda akan otomatis diproses oleh server. 
3. Alat MCP: membuat halaman Notion
• Fungsi create_notion_page() menghasilkan halaman Notion dengan hasil analisis PR.
• Fungsi ini menggunakan API Notion untuk membuat halaman baru di bawah workspace Notion yang ditentukan.
4. Eksekusi server
• Metode run() menjalankan server MCP menggunakan mcp.run(transport="stdio"), mengaktifkan interaksi antara Claude Desktop dan alat ulasan PR.

Langkah 6: Menjalankan Server MCP

Setelah semua potongan kode siap, jalankan server dengan perintah terminal berikut:

python pr_analyzer.py

Setelah server berjalan, buka aplikasi Claude Desktop, dan Anda akan melihat ikon steker (🔌) di kotak teks. Ikon ini menandakan adanya MCP di lingkungan Claude. Di kotak teks yang sama, Anda akan melihat ikon mirip palu (🔨) yang menampilkan semua MCP yang tersedia, seperti di bawah.

Sekarang, berikan tautan ke PR yang ingin Anda analisis dan biarkan Claude mengerjakan sisanya untuk Anda.

Claude akan terlebih dahulu menganalisis PR lalu memberikan ringkasan dan ulasannya. Claude akan menanyakan apakah pengguna ingin mengunggah detailnya ke halaman Notion. Meskipun proses tersebut dapat diotomatisasi, kode saat ini memungkinkan Anda meninjau ringkasan sebelum membuat halaman Notion baru.

Halaman Notion yang diperbarui terlihat seperti ini:

Kesimpulan

Server berbasis MCP untuk Ulasan PR kami meningkatkan analisis kode dan dokumentasi, sehingga proses ulasan menjadi lebih efisien dan terorganisasi. Dengan menggunakan MCP, GitHub API, dan integrasi Notion, sistem ini mendukung analisis PR otomatis, kolaborasi yang mudah, dan dokumentasi terstruktur. Dengan konfigurasi ini, pengembang dapat dengan cepat mengambil detail PR, menganalisis perubahan kode menggunakan Claude, dan menyimpan wawasan di Notion untuk referensi di masa mendatang.

Untuk mengeksplorasi lebih banyak alat AI terbaru, saya merekomendasikan blog berikut:

• Cara Menyiapkan dan Menjalankan Gemma 3 Secara Lokal dengan Ollama
• Mistral OCR: Panduan dengan Contoh Praktis
• Tutorial OpenAI Agents SDK: Membangun Sistem AI yang Dapat Bertindak
• Baidu ERNIE 4.5 & X1: Fitur, Akses, Perbandingan dengan DeepSeek
• Chrome DevTools MCP: Otomatisasi dan Debugging Browser Berbasis AI