Apa Itu Server MCP? Penjelasan Lengkap

Model Context Protocol (MCP), yang diperkenalkan oleh Anthropic pada tanggal 26 November 2024, adalah standar terbuka yang bertujuan untuk menjembatani kesenjangan antara model AI dan sumber data eksternal. Protokol ini mengatasi tantangan penting: bahkan Model Bahasa Besar (LLM) yang canggih, meskipun kuat dalam menghasilkan teks, sering kali terisolasi dari data dan alat secara waktu nyata, yang membatasi kegunaan praktisnya. MCP Server, sebagai komponen integral, memungkinkan asisten AI seperti Claude untuk mengakses file, database, API, dan lainnya, meningkatkan kemampuan mereka untuk memberikan respons yang relevan dan dapat ditindaklanjuti.

Signifikansi MCP terletak pada potensinya untuk menstandarisasi integrasi, mengurangi fragmentasi yang telah melanda pengembangan AI. Dengan menyediakan protokol universal, ia bertujuan untuk membantu model perintis menghasilkan respons yang lebih baik dan lebih relevan dengan memecah silo informasi dan hambatan sistem lama.

Pada tanggal 25 Maret 2025, ekosistem berkembang pesat, dengan kontribusi komunitas dan adopsi perusahaan, seperti pengadopsi awal seperti Block dan Apollo yang mengintegrasikan MCP ke dalam sistem mereka.

💡

Perlu menemukan alat alternatif postman terbaik yang mengintegrasikan semua alur kerja Pengujian API Anda di satu tempat?
Unduh Apidog secara gratis hari ini dan temukan bagaimana ia dapat mengubah alur kerja Anda!

button

Apa Itu MCP Server?

MCP server, bagian dari Model Context Protocol (MCP), adalah program khusus yang membantu model AI, seperti yang berasal dari Anthropic, terhubung ke dan menggunakan data dan alat eksternal. Diperkenalkan pada November 2024, mereka memungkinkan AI untuk melakukan lebih dari sekadar menghasilkan teks dengan mengakses hal-hal seperti file di komputer Anda, database, atau bahkan layanan seperti GitHub, semuanya dengan cara yang aman dan terstandarisasi.

Anggap MCP server sebagai jembatan yang memungkinkan AI berinteraksi dengan dunia luar, mirip dengan bagaimana port USB memungkinkan Anda mencolokkan perangkat yang berbeda ke komputer Anda. Misalnya, jika Anda meminta AI untuk meringkas dokumen, ia dapat menarik file langsung dari sistem Anda. Atau, jika Anda perlu membuat masalah GitHub, AI juga dapat melakukannya, berkat MCP server. Mereka dapat menyediakan data (seperti file), alat (seperti panggilan API), atau perintah (panduan untuk interaksi), membuat AI lebih berguna untuk tugas-tugas seperti pengkodean, penelitian, atau mengelola proyek.

Detail yang tak terduga adalah seberapa cepat komunitas telah berkembang, dengan lebih dari 250 server sudah tersedia, termasuk integrasi resmi dan kontribusi komunitas, menunjukkan ekosistem yang dinamis yang berkembang pesat.

Bagaimana Cara Kerja MCP Server (Dan Bagaimana Mereka Berbeda dari API)

MCP beroperasi pada model klien-server, seperti yang diuraikan dalam dokumentasi. Arsitekturnya meliputi:

MCP Host: Aplikasi seperti Claude Desktop, IDE, atau alat AI yang berupaya memanfaatkan data eksternal.
MCP Client: Klien protokol yang memelihara koneksi satu-ke-satu yang aman dengan server, memastikan komunikasi yang efisien.
MCP Server: Program ringan yang masing-masing mengekspos kemampuan spesifik melalui Model Context Protocol yang terstandarisasi. Struktur ini memungkinkan integrasi yang mulus, dengan host menggunakan klien untuk terhubung ke berbagai server, masing-masing menawarkan fungsionalitas unik. Protokol ini mendukung tiga jenis eksposur utama:
Sumber Daya: Sumber data seperti file, dokumen, atau kueri database yang dapat dimuat AI ke dalam konteksnya. Misalnya, server sistem file mungkin memungkinkan akses ke dokumen lokal.
Alat: Tindakan yang dapat dilakukan AI, seperti membuat panggilan API atau menjalankan perintah. Contohnya adalah server GitHub yang memungkinkan manajemen repositori, yang dirinci dalam repositori yang sama.
Perintah: Templat yang dapat digunakan kembali untuk interaksi LLM, memandu perilaku AI dalam skenario tertentu.

Protokol ini didasarkan pada JSON-RPC 2.0, memastikan koneksi stateful dan negosiasi kemampuan antara klien dan server. Fondasi teknis ini memungkinkan komunikasi yang kuat dan aman, dengan fitur-fitur seperti pelacakan kemajuan, pembatalan, dan pelaporan kesalahan yang meningkatkan keandalan.

Jadi, Apa yang Sebenarnya Dapat Dilakukan MCP?

MCP server dirancang agar serbaguna, memenuhi berbagai kebutuhan. Mereka dapat dijalankan secara lokal atau jarak jauh, tergantung pada implementasinya, dan dibangun dengan prinsip-prinsip keamanan sebagai prioritas utama. Setiap server mengontrol sumber dayanya sendiri, memelihara batasan sistem yang jelas untuk mencegah akses yang tidak sah.

Keamanan ini sangat penting, terutama saat berurusan dengan data sensitif, memastikan bahwa koneksi aman dan izin dikelola dengan ketat.

Secara teknis, server mengekspos kemampuannya melalui titik akhir JSON-RPC, memungkinkan klien untuk menanyakan sumber daya, alat, dan perintah yang tersedia.

Misalnya, server mungkin mengekspos sumber daya "readFile" yang mengembalikan konten file yang ditentukan, atau alat "createIssue" yang berinteraksi dengan API GitHub. Protokol ini juga mendukung perilaku yang diprakarsai server seperti pengambilan sampel, memungkinkan interaksi AI agentik, yang dapat bersifat rekursif dan dinamis, seperti yang dijelaskan dalam spesifikasi.

Tertarik dengan MCP Server? Anda Dapat Mencoba Ini Sekarang

Ekosistem MCP server kaya dan berkembang, dengan banyak contoh yang menggambarkan kegunaannya, seperti yang tercantum dalam repositori di GitHub - awesome-mcp-servers:

File System MCP Server: Memungkinkan AI untuk membaca dan menulis file, berguna untuk mengakses catatan atau skrip pribadi, seperti yang terlihat dalam implementasi referensi di GitHub - filesystem.
GitHub MCP Server: Memfasilitasi interaksi seperti membuat masalah atau melakukan kode, meningkatkan alur kerja pengembang, yang dirinci dalam GitHub - github.
Web Scraping MCP Server: Memungkinkan AI untuk mencari dan mengekstrak konten web, menyediakan data waktu nyata, seperti yang disebutkan dalam server komunitas seperti tavily-ai/tavily-mcp.
Database MCP Server: Menawarkan akses ke database SQL atau NoSQL, seperti PostgreSQL atau MongoDB, memungkinkan kueri data, seperti yang terlihat di GitHub - postgres.
API Integration MCP Server: Terhubung ke layanan seperti Slack, Trello, atau API cuaca, memperluas basis pengetahuan AI, dengan contoh seperti GitHub - slack. Server ini menunjukkan fleksibilitas protokol, dengan kontribusi komunitas seperti server manajemen Kubernetes yang menambah ekosistem, seperti yang tercantum dalam server pihak ketiga di GitHub - servers.

💡

Ingin menjelajahi 1000+ MCP Server lainnya?

Cari tahu lebih lanjut di Himcp.ai!

button

Apa Perbedaan Antara MCP Server dan API?

Meskipun MCP server dan API tradisional memungkinkan perangkat lunak untuk berinteraksi dengan layanan eksternal, tujuan mereka berbeda dalam konteks AI:

Tujuan: API tradisional adalah antarmuka tujuan umum untuk komunikasi perangkat lunak, sering digunakan untuk mengirim kueri ke model AI atau mengakses layanan eksternal. MCP server dirancang khusus untuk memberikan konteks ke model AI, dengan fokus pada data, alat, dan perintah dalam format standar.
Interaksi: Dengan API tradisional, model AI perlu tahu cara memanggil API, mengurai responsnya, dan mengintegrasikan informasi itu ke dalam konteksnya. Dengan MCP server, server menangani interaksi dengan sumber data atau alat dan menyajikan informasi dengan cara yang dapat dengan mudah dipahami dan digunakan oleh model AI, tanpa perlu mengetahui spesifikasi sumber data yang mendasarinya.
Standarisasi: MCP menyediakan protokol standar, membuatnya plug-and-play untuk berbagai server, sedangkan API tradisional mungkin memerlukan integrasi khusus untuk setiap layanan.
Keamanan: MCP server dioptimalkan untuk keamanan, dengan otentikasi bawaan dan kontrol akses, sementara API tradisional mungkin memerlukan langkah-langkah keamanan tambahan tergantung pada implementasinya.

Misalnya, dalam pengaturan tradisional, AI mungkin perlu memanggil REST API untuk mendapatkan data cuaca, mengurai respons JSON dan mengintegrasikannya ke dalam konteksnya. Dengan MCP server, server dapat mengekspos alat "get_weather", dan AI cukup memanggilnya dengan parameter, menerima data yang diformat yang siap digunakan.

Cara Menyiapkan MCP Server (dengan Claude sebagai Contoh)

Model Context Protocol (MCP) adalah kerangka kerja yang kuat yang memungkinkan

MCP server dapat menyediakan tiga jenis kemampuan utama:

Sumber Daya: Data seperti file yang dapat dibaca oleh klien (seperti respons API atau konten file)
Alat: Fungsi yang dapat dipanggil oleh LLM (dengan persetujuan pengguna)
Perintah: Templat yang ditulis sebelumnya yang membantu pengguna menyelesaikan tugas-tugas tertentu

Menyiapkan Lingkungan Anda

Sebelum memulai, pastikan Anda memiliki:

Python 3.10 atau lebih tinggi terinstal
Node.js (jika menggunakan implementasi JavaScript/TypeScript)
Keakraban dasar dengan pemrograman Python atau JavaScript
Pemahaman tentang LLM seperti Claude

Menginstal Manajer Paket UV

UV adalah manajer paket yang direkomendasikan untuk proyek Python MCP:

# MacOS/Linux
curl -LsSf <https://astral.sh/uv/install.sh> | sh

# Pastikan untuk memulai ulang terminal Anda setelahnya

Membangun MCP Server

Mari kita bangun server cuaca sederhana sebagai contoh.

Server ini akan menyediakan dua alat: get-alerts dan get-forecast.

Langkah 1: Menyiapkan Struktur Proyek

# Buat direktori baru untuk proyek kita
uv init weather
cd weather

# Buat lingkungan virtual dan aktifkan
uv venv
source .venv/bin/activate  # Di Windows: .venv\\\\Scripts\\\\activate

# Instal dependensi
uv add "mcp[cli]" httpx

# Buat file server kita
touch weather.py

Langkah 2: Mengimplementasikan Server

Berikut adalah implementasi lengkap dari server cuaca kita (di weather.py):

from typing import Any
import httpx
from mcpserver.fastmcp import FastMCP

# Inisialisasi server FastMCP
mcp = FastMCP("weather")

# Konstanta
NWS_API_BASE = "<https://api.weather.gov>"
USER_AGENT = "weather-app/1.0"

async def make_nws_request(url: str) -> dict[str, Any] | None:
    """Buat permintaan ke NWS API dengan penanganan kesalahan yang tepat."""
    headers = {
        "User-Agent": USER_AGENT,
        "Accept": "application/geo+json"
    }
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=headers, timeout=30.0)
            response.raise_for_status()
            return response.json()
        except Exception:
            return None

def format_alert(feature: dict) -> str:
    """Format fitur peringatan menjadi string yang dapat dibaca."""
    props = feature["properties"]
    return f"""
Acara: {props.get('event', 'Tidak Diketahui')}
Area: {props.get('areaDesc', 'Tidak Diketahui')}
Tingkat Keparahan: {props.get('severity', 'Tidak Diketahui')}
Deskripsi: {props.get('description', 'Tidak ada deskripsi yang tersedia')}
Instruksi: {props.get('instruction', 'Tidak ada instruksi khusus yang diberikan')}
"""

@mcp.tool()
async def get_alerts(state: str) -> str:
    """Dapatkan peringatan cuaca untuk negara bagian AS.

    Args:
        state: Kode negara bagian AS dua huruf (mis., CA, NY)
    """
    url = f"{NWS_API_BASE}/alerts/active/area/{state}"
    data = await make_nws_request(url)

    if not data or "features" not in data:
        return "Tidak dapat mengambil peringatan atau tidak ada peringatan yang ditemukan."

    if not data["features"]:
        return "Tidak ada peringatan aktif untuk negara bagian ini."

    alerts = [format_alert(feature) for feature in data["features"]]
    return "\\\\n---\\\\n".join(alerts)

@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
    """Dapatkan perkiraan cuaca untuk suatu lokasi.

    Args:
        latitude: Garis lintang lokasi
        longitude: Garis bujur lokasi
    """
    # Pertama dapatkan titik akhir grid perkiraan
    points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
    points_data = await make_nws_request(points_url)

    if not points_data:
        return "Tidak dapat mengambil data perkiraan untuk lokasi ini."

    # Dapatkan URL perkiraan dari respons titik
    forecast_url = points_data["properties"]["forecast"]
    forecast_data = await make_nws_request(forecast_url)

    if not forecast_data:
        return "Tidak dapat mengambil perkiraan terperinci."

    # Format periode menjadi perkiraan yang dapat dibaca
    periods = forecast_data["properties"]["periods"]
    forecasts = []
    for period in periods[:5]:  # Hanya tampilkan 5 periode berikutnya
        forecast = f"""
{period['name']}: Suhu: {period['temperature']}°{period['temperatureUnit']}
Angin: {period['windSpeed']} {period['windDirection']}
Perkiraan: {period['detailedForecast']}
"""
        forecasts.append(forecast)

    return "\\\\n---\\\\n".join(forecasts)

if __name__ == "__main__":
    # Inisialisasi dan jalankan server
    mcp.run(transport='stdio')

Langkah 3: Menjalankan Server Anda

Untuk menguji server Anda secara langsung, jalankan:

uv run weather.py

Menghubungkan ke Claude untuk Desktop

Claude untuk Desktop adalah cara sederhana untuk berinteraksi dengan MCP server Anda.

Langkah 1: Instal Claude untuk Desktop

Pastikan Anda telah menginstal Claude untuk Desktop dan diperbarui ke versi terbaru.

Langkah 2: Mengonfigurasi Claude untuk Desktop

Buka konfigurasi Aplikasi Claude untuk Desktop Anda di editor teks:

# macOS
code ~/Library/Application\\\\ Support/Claude/claude_desktop_config.json

2. Tambahkan konfigurasi server Anda:

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather",
        "run",
        "weather.py"
      ]
    }
  }
}

Pastikan untuk:

Gunakan jalur absolut ke direktori server Anda
Pastikan perintah sesuai dengan lingkungan Anda (mis., uv atau jalur lengkap ke uv)

Langkah 3: Memulai Ulang Claude untuk Desktop

Setelah menyimpan konfigurasi, mulai ulang Claude untuk Desktop sepenuhnya.

Langkah 4: Menguji Server Anda

Cari ikon palu di sudut kanan bawah kotak input Claude untuk Desktop. Mengekliknya akan menampilkan alat server Anda.

Anda sekarang dapat mengajukan pertanyaan kepada Claude seperti:

"Bagaimana cuaca di Sacramento?"
"Apa peringatan cuaca aktif di Texas?"

Membangun Klien MCP Kustom untuk Claude MCP Server

Alih-alih menggunakan Claude untuk Desktop, Anda dapat membangun klien kustom Anda sendiri.

Langkah 1: Menyiapkan Proyek Klien

# Buat direktori proyek
uv init mcp-client
cd mcp-client

# Buat lingkungan virtual
uv venv
source .venv/bin/activate  # Di Windows: .venv\\\\Scripts\\\\activate

# Instal paket yang diperlukan
uv add mcp anthropic python-dotenv

# Buat file utama kita
touch client.py

Langkah 2: Menyiapkan Kunci API Anda

Buat file .env dengan kunci API Anthropic Anda:

ANTHROPIC_API_KEY=<kunci Anda di sini>

Langkah 3: Mengimplementasikan Klien

Berikut adalah implementasi klien dasar (di client.py):

import asyncio
import sys
from typing import Optional
from contextlib import AsyncExitStack

from mcp.client.stdio import ClientSession, StdioServerParameters, stdio_client
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()  # muat variabel lingkungan dari .env

class MCPClient:
    def __init__(self):
        # Inisialisasi objek sesi dan klien
        self.session: Optional[ClientSession] = None
        self.exit_stack = AsyncExitStack()
        self.anthropic = Anthropic()

    async def connect_to_server(self, server_script_path: str):
        """Hubungkan ke MCP server

        Args:
            server_script_path: Jalur ke skrip server (py atau js)
        """
        is_python = server_script_path.endswith('.py')
        is_js = server_script_path.endswith('.js')

        if not (is_python or is_js):
            raise ValueError("Skrip server harus berupa file .py atau .js")

        command = "python" if is_python else "node"
        server_params = StdioServerParameters(command=command, args=[server_script_path], env=None)

        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
        self.stdio, self.write = stdio_transport
        self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
        await self.session.initialize()

        # Daftar alat yang tersedia
        response = await self.session.list_tools()
        tools = response.tools
        print("\\\\nTerhubung ke server dengan alat:", [tool.name for tool in tools])

    async def process_query(self, query: str) -> str:
        """Proses kueri menggunakan Claude dan alat yang tersedia"""
        messages = [
            {
                "role": "user",
                "content": query
            }
        ]

        response = await self.session.list_tools()
        available_tools = [{
            "name": tool.name,
            "description": tool.description,
            "input_schema": tool.input_schema
        } for tool in response.tools]

        # Panggilan API Claude awal
        response = self.anthropic.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1000,
            messages=messages,
            tools=available_tools
        )

        # Proses respons dan tangani panggilan alat
        final_text = []
        assistant_message_content = []

        for content in response.content:
            if content.type == 'text':
                final_text.append(content.text)
                assistant_message_content.append(content)
            elif content.type == 'tool_use':
                tool_name = content.name
                tool_args = content.input

                # Jalankan panggilan alat
                result = await self.session.call_tool(tool_name, tool_args)
                final_text.append(f"[Memanggil alat {tool_name} dengan argumen {tool_args}]")
                assistant_message_content.append(content)

                messages.append({
                    "role": "assistant",
                    "content": assistant_message_content
                })

                messages.append({
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": content.id,
                            "content": result
                        }
                    ]
                })

                # Dapatkan respons berikutnya dari Claude
                response = self.anthropic.messages.create(
                    model="claude-3-5-sonnet-20241022",
                    max_tokens=1000,
                    messages=messages,
                    tools=available_tools
                )

                final_text.append(response.content[0].text)

        return "\\\\n".join(final_text)

    async def chat_loop(self):
        """Jalankan loop obrolan interaktif"""
        print("\\\\nKlien MCP Dimulai!")
        print("Ketik kueri Anda atau 'quit' untuk keluar.")

        while True:
            try:
                query = input("\\\\nKueri: ").strip()
                if query.lower() == 'quit':
                    break

                response = await self.process_query(query)
                print("\\\\n" + response)
            except Exception as e:
                print(f"\\\\nError: {str(e)}")

    async def cleanup(self):
        """Bersihkan sumber daya"""
        await self.exit_stack.aclose()

async def main():
    if len(sys.argv) < 2:
        print("Penggunaan: python client.py <path_to_server_script>")
        sys.exit(1)

    client = MCPClient()

    try:
        await client.connect_to_server(sys.argv[1])
        await client.chat_loop()
    finally:
        await client.cleanup()

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

Langkah 4: Menjalankan Klien

Untuk menggunakan klien Anda dengan server cuaca Anda:

uv run client.py /path/to/weather.py

Menggunakan MCP Server yang Sudah Dibuat dengan Claude untuk Desktop

Claude untuk Desktop mendukung berbagai MCP server yang sudah dibuat. Mari kita lihat cara menggunakan server sistem file sebagai contoh.

Langkah 1: Mengonfigurasi Server Sistem File

Buka pengaturan Claude untuk Desktop dan klik "Edit Config"
Perbarui file konfigurasi Anda dengan:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop",
        "/Users/username/Downloads"
      ]
    }
  }
}

Ganti username dengan nama pengguna Anda yang sebenarnya, dan sesuaikan jalur sesuai kebutuhan.

Langkah 2: Memulai Ulang dan Menguji

Setelah memulai ulang Claude untuk Desktop, Anda dapat menggunakan alat sistem file untuk:

Membaca file
Menulis file
Mencari file
Memindahkan file

Contoh perintah:

"Bisakah Anda menulis puisi dan menyimpannya ke desktop saya?"
"Apa saja file terkait pekerjaan di folder unduhan saya?"
"Bisakah Anda mengambil semua gambar di desktop saya dan memindahkannya ke folder baru bernama 'Gambar'?"

Kesimpulan

MCP server mewakili kemajuan signifikan dalam fungsionalitas AI, menjembatani kesenjangan antara model bahasa yang kuat dan alat eksternal. Dengan mengikuti panduan ini, Anda telah mempelajari cara membuat, mengonfigurasi, dan menggunakan MCP server untuk meningkatkan kemampuan Claude.

Pendekatan standar Model Context Protocol memastikan bahwa model AI dapat mengakses data waktu nyata, melakukan tindakan, dan berinteraksi dengan sistem dengan cara yang aman dan terkontrol. Ini membuat asisten AI lebih praktis untuk aplikasi dunia nyata di seluruh pengembangan, analisis data, pembuatan konten, dan lainnya.

Saat ekosistem MCP terus berkembang, pengembang membuat server yang semakin canggih yang memperluas apa yang mungkin dilakukan dengan AI. Apakah Anda menggunakan server yang sudah dibuat atau mengembangkan solusi khusus, MCP menyediakan fondasi yang fleksibel untuk membangun aplikasi AI yang lebih mumpuni.

Saat Anda terus bekerja dengan MCP server yang sering melibatkan integrasi API, Anda mungkin ingin menjelajahi Apidog, platform pengembangan API komprehensif yang dapat melengkapi alur kerja implementasi MCP Anda.

Apidog menawarkan solusi lengkap untuk desain API, dokumentasi, debugging, dan pengujian otomatis. Antarmuka intuitifnya memudahkan untuk:

Mendesain API dengan antarmuka visual atau mengimpor spesifikasi yang ada
Membuat dokumentasi secara otomatis yang tetap sinkron dengan kode Anda
Menguji titik akhir API dengan pembuat permintaan yang kuat
Membuat skenario pengujian otomatis untuk API Anda
Berkolaborasi dengan anggota tim melalui ruang kerja bersama

Saat mengembangkan MCP server yang berinteraksi dengan API eksternal, Apidog dapat membantu Anda memvalidasi titik akhir, memahami struktur respons, dan memastikan integrasi Anda berfungsi dengan benar sebelum mengimplementasikannya dalam kode server Anda.

Untuk memulai dengan Apidog bersama dengan pengembangan MCP Anda, kunjungi situs web Apidog dan jelajahi bagaimana ia dapat meningkatkan alur kerja pengembangan API Anda.

button

Dengan menggabungkan MCP server dengan alat pengembangan API yang efisien seperti Apidog, Anda dapat membuat koneksi yang lebih kuat dan andal antara sistem AI dan layanan eksternal, menjadikan aplikasi AI Anda semakin kuat.