(Klik gambar di atas untuk melihat video pelajaran ini)
Pelajaran ini berfokus pada cara berinteraksi dengan komunitas MCP, berkontribusi pada ekosistem MCP, dan mengikuti praktik terbaik untuk pengembangan kolaboratif. Memahami cara berpartisipasi dalam proyek open-source MCP sangat penting bagi mereka yang ingin membentuk masa depan teknologi ini.
Pada akhir pelajaran ini, Anda akan mampu:
- Memahami struktur komunitas dan ekosistem MCP
- Berpartisipasi secara efektif dalam forum dan diskusi komunitas MCP
- Berkontribusi ke repositori open-source MCP
- Membuat dan membagikan alat dan server MCP kustom
- Mengikuti praktik terbaik untuk pengembangan dan kolaborasi MCP
- Menemukan sumber daya dan kerangka kerja komunitas untuk pengembangan MCP
Ekosistem MCP terdiri dari berbagai komponen dan peserta yang bekerja sama untuk mengembangkan protokol.
- Pemelihara Protokol Inti: Organisasi resmi Model Context Protocol GitHub memelihara spesifikasi inti MCP dan implementasi referensi
- Pengembang Alat: Individu dan tim yang membuat alat dan server MCP
- Penyedia Integrasi: Perusahaan yang mengintegrasikan MCP ke dalam produk dan layanan mereka
- Pengguna Akhir: Pengembang dan organisasi yang menggunakan MCP dalam aplikasi mereka
- Kontributor: Anggota komunitas yang berkontribusi kode, dokumentasi, atau sumber daya lainnya
- Klien MCP - Daftar klien yang mendukung integrasi MCP
- Server MCP Komunitas - Daftar berkembang server MCP yang dikembangkan komunitas
- Server MCP Hebat - Daftar kurasi server MCP
- PulseMCP - Pusat komunitas & newsletter untuk menemukan sumber daya MCP
- Server Discord - Terhubung dengan pengembang MCP
- Implementasi SDK spesifik bahasa
- Postingan blog dan tutorial
Ekosistem MCP menyambut berbagai jenis kontribusi:
-
Kontribusi Kode:
- Peningkatan protokol inti
- Perbaikan bug
- Implementasi alat dan server
- Perpustakaan klien/server dalam berbagai bahasa
-
Dokumentasi:
- Memperbaiki dokumentasi yang ada
- Membuat tutorial dan panduan
- Menerjemahkan dokumentasi
- Membuat contoh dan aplikasi sampel
-
Dukungan Komunitas:
- Menjawab pertanyaan di forum dan diskusi
- Menguji dan melaporkan masalah
- Menyelenggarakan acara komunitas
- Membimbing kontributor baru
Untuk berkontribusi ke protokol inti MCP atau implementasi resmi, ikuti prinsip-prinsip dari panduan kontribusi resmi:
-
Kesederhanaan dan Minimalisme: Spesifikasi MCP mempertahankan standar tinggi untuk menambah konsep baru. Lebih mudah menambahkan hal ke spesifikasi daripada menghapusnya.
-
Pendekatan Konkret: Perubahan spesifikasi harus berdasarkan tantangan implementasi spesifik, bukan ide spekulatif.
-
Tahapan Proposal:
- Definisikan: Jelajahi ruang masalah, validasi bahwa pengguna MCP lain menghadapi masalah serupa
- Prototipe: Bangun solusi contoh dan tunjukkan aplikasi praktisnya
- Tulis: Berdasarkan prototipe, buat proposal spesifikasi
# Fork repositori
git clone https://github.com/YOUR-USERNAME/modelcontextprotocol.git
cd modelcontextprotocol
# Pasang dependensi
npm install
# Untuk perubahan skema, validasi dan generate schema.json:
npm run check:schema:ts
npm run generate:schema
# Untuk perubahan dokumentasi
npm run check:docs
npm run format
# Pratinjau dokumentasi secara lokal (opsional):
npm run serve:docs// Kode asli dengan bug di typescript-sdk
export function validateResource(resource: unknown): resource is MCPResource {
if (!resource || typeof resource !== 'object') {
return false;
}
// Bug: Validasi properti hilang
// Implementasi saat ini:
const hasName = 'name' in resource;
const hasSchema = 'schema' in resource;
return hasName && hasSchema;
}
// Implementasi yang diperbaiki dalam kontribusi
export function validateResource(resource: unknown): resource is MCPResource {
if (!resource || typeof resource !== 'object') {
return false;
}
// Validasi yang ditingkatkan
const hasName = 'name' in resource && typeof (resource as MCPResource).name === 'string';
const hasSchema = 'schema' in resource && typeof (resource as MCPResource).schema === 'object';
const hasDescription = !('description' in resource) || typeof (resource as MCPResource).description === 'string';
return hasName && hasSchema && hasDescription;
}# Contoh kontribusi: Alat pemrosesan data CSV untuk perpustakaan standar MCP
from mcp_tools import Tool, ToolRequest, ToolResponse, ToolExecutionException
import pandas as pd
import io
import json
from typing import Dict, Any, List, Optional
class CsvProcessingTool(Tool):
"""
Tool for processing and analyzing CSV data.
This tool allows models to extract information from CSV files,
run basic analysis, and convert data between formats.
"""
def get_name(self):
return "csvProcessor"
def get_description(self):
return "Processes and analyzes CSV data"
def get_schema(self):
return {
"type": "object",
"properties": {
"csvData": {
"type": "string",
"description": "CSV data as a string"
},
"csvUrl": {
"type": "string",
"description": "URL to a CSV file (alternative to csvData)"
},
"operation": {
"type": "string",
"enum": ["summary", "filter", "transform", "convert"],
"description": "Operation to perform on the CSV data"
},
"filterColumn": {
"type": "string",
"description": "Column to filter by (for filter operation)"
},
"filterValue": {
"type": "string",
"description": "Value to filter for (for filter operation)"
},
"outputFormat": {
"type": "string",
"enum": ["json", "csv", "markdown"],
"default": "json",
"description": "Output format for the processed data"
}
},
"oneOf": [
{"required": ["csvData", "operation"]},
{"required": ["csvUrl", "operation"]}
]
}
async def execute_async(self, request: ToolRequest) -> ToolResponse:
try:
# Ekstrak parameter
operation = request.parameters.get("operation")
output_format = request.parameters.get("outputFormat", "json")
# Dapatkan data CSV dari data langsung atau URL
df = await self._get_dataframe(request)
# Proses berdasarkan operasi yang diminta
result = {}
if operation == "summary":
result = self._generate_summary(df)
elif operation == "filter":
column = request.parameters.get("filterColumn")
value = request.parameters.get("filterValue")
if not column:
raise ToolExecutionException("filterColumn is required for filter operation")
result = self._filter_data(df, column, value)
elif operation == "transform":
result = self._transform_data(df, request.parameters)
elif operation == "convert":
result = self._convert_format(df, output_format)
else:
raise ToolExecutionException(f"Unknown operation: {operation}")
return ToolResponse(result=result)
except Exception as e:
raise ToolExecutionException(f"CSV processing failed: {str(e)}")
async def _get_dataframe(self, request: ToolRequest) -> pd.DataFrame:
"""Gets a pandas DataFrame from either CSV data or URL"""
if "csvData" in request.parameters:
csv_data = request.parameters.get("csvData")
return pd.read_csv(io.StringIO(csv_data))
elif "csvUrl" in request.parameters:
csv_url = request.parameters.get("csvUrl")
return pd.read_csv(csv_url)
else:
raise ToolExecutionException("Either csvData or csvUrl must be provided")
def _generate_summary(self, df: pd.DataFrame) -> Dict[str, Any]:
"""Generates a summary of the CSV data"""
return {
"columns": df.columns.tolist(),
"rowCount": len(df),
"columnCount": len(df.columns),
"numericColumns": df.select_dtypes(include=['number']).columns.tolist(),
"categoricalColumns": df.select_dtypes(include=['object']).columns.tolist(),
"sampleRows": json.loads(df.head(5).to_json(orient="records")),
"statistics": json.loads(df.describe().to_json())
}
def _filter_data(self, df: pd.DataFrame, column: str, value: str) -> Dict[str, Any]:
"""Filters the DataFrame by a column value"""
if column not in df.columns:
raise ToolExecutionException(f"Column '{column}' not found")
filtered_df = df[df[column].astype(str).str.contains(value)]
return {
"originalRowCount": len(df),
"filteredRowCount": len(filtered_df),
"data": json.loads(filtered_df.to_json(orient="records"))
}
def _transform_data(self, df: pd.DataFrame, params: Dict[str, Any]) -> Dict[str, Any]:
"""Transforms the data based on parameters"""
# Implementasi akan mencakup berbagai transformasi
return {
"status": "success",
"message": "Transformation applied"
}
def _convert_format(self, df: pd.DataFrame, format: str) -> Dict[str, Any]:
"""Converts the DataFrame to different formats"""
if format == "json":
return {
"data": json.loads(df.to_json(orient="records")),
"format": "json"
}
elif format == "csv":
return {
"data": df.to_csv(index=False),
"format": "csv"
}
elif format == "markdown":
return {
"data": df.to_markdown(),
"format": "markdown"
}
else:
raise ToolExecutionException(f"Unsupported output format: {format}")Untuk membuat kontribusi yang sukses ke proyek MCP:
- Mulai dari yang Kecil: Mulai dengan dokumentasi, perbaikan bug, atau peningkatan kecil
- Ikuti Panduan Gaya: Patuhi gaya pengkodean dan konvensi proyek
- Tulis Tes: Sertakan tes unit untuk kontribusi kode Anda
- Dokumentasikan Pekerjaan Anda: Tambahkan dokumentasi yang jelas untuk fitur atau perubahan baru
- Kirim PR yang Terfokus: Jaga agar permintaan tarik fokus pada satu masalah atau fitur
- Tanggapi Masukan: Responsif terhadap masukan atas kontribusi Anda
# Kloning repositori
git clone https://github.com/modelcontextprotocol/typescript-sdk.git
cd typescript-sdk
# Buat cabang baru untuk kontribusi Anda
git checkout -b feature/my-contribution
# Lakukan perubahan Anda
# ...
# Jalankan tes untuk memastikan perubahan Anda tidak merusak fungsi yang sudah ada
npm test
# Komit perubahan Anda dengan pesan yang deskriptif
git commit -am "Fix validation in resource handler"
# Dorong cabang Anda ke fork Anda
git push origin feature/my-contribution
# Buat pull request dari cabang Anda ke repositori utama
# Kemudian tanggapi umpan balik dan iterasi pada PR Anda sesuai kebutuhanSalah satu cara paling berharga untuk berkontribusi pada ekosistem MCP adalah dengan membuat dan membagikan server MCP kustom. Komunitas telah mengembangkan ratusan server untuk berbagai layanan dan kasus penggunaan.
Beberapa kerangka kerja tersedia untuk menyederhanakan pengembangan server MCP:
-
SDK Resmi (selaras dengan Spesifikasi MCP 2025-11-25):
-
Kerangka Kerja Komunitas:
- MCP-Framework - Bangun server MCP dengan elegan dan cepat menggunakan TypeScript
- MCP Declarative Java SDK - Server MCP dengan anotasi menggunakan Java
- Quarkus MCP Server SDK - Kerangka kerja Java untuk server MCP
- Template Server MCP Next.js - Proyek awal Next.js untuk server MCP
// Create a new .NET library project
// dotnet new classlib -n McpFinanceTools
using Microsoft.Mcp.Tools;
using System.Threading.Tasks;
using System.Net.Http;
using System.Text.Json;
namespace McpFinanceTools
{
// Stock quote tool
public class StockQuoteTool : IMcpTool
{
private readonly HttpClient _httpClient;
public StockQuoteTool(HttpClient httpClient = null)
{
_httpClient = httpClient ?? new HttpClient();
}
public string Name => "stockQuote";
public string Description => "Gets current stock quotes for specified symbols";
public object GetSchema()
{
return new {
type = "object",
properties = new {
symbol = new {
type = "string",
description = "Stock symbol (e.g., MSFT, AAPL)"
},
includeHistory = new {
type = "boolean",
description = "Whether to include historical data",
default = false
}
},
required = new[] { "symbol" }
};
}
public async Task<ToolResponse> ExecuteAsync(ToolRequest request)
{
// Extract parameters
string symbol = request.Parameters.GetProperty("symbol").GetString();
bool includeHistory = false;
if (request.Parameters.TryGetProperty("includeHistory", out var historyProp))
{
includeHistory = historyProp.GetBoolean();
}
// Call external API (example)
var quoteResult = await GetStockQuoteAsync(symbol);
// Add historical data if requested
if (includeHistory)
{
var historyData = await GetStockHistoryAsync(symbol);
quoteResult.Add("history", historyData);
}
// Return formatted result
return new ToolResponse {
Result = JsonSerializer.SerializeToElement(quoteResult)
};
}
private async Task<Dictionary<string, object>> GetStockQuoteAsync(string symbol)
{
// Implementation would call a real stock API
// This is a simplified example
return new Dictionary<string, object>
{
["symbol"] = symbol,
["price"] = 123.45,
["change"] = 2.5,
["percentChange"] = 1.2,
["lastUpdated"] = DateTime.UtcNow
};
}
private async Task<object> GetStockHistoryAsync(string symbol)
{
// Implementation would get historical data
// Simplified example
return new[]
{
new { date = DateTime.Now.AddDays(-7).Date, price = 120.25 },
new { date = DateTime.Now.AddDays(-6).Date, price = 122.50 },
new { date = DateTime.Now.AddDays(-5).Date, price = 121.75 }
// More historical data...
};
}
}
}
// Create package and publish to NuGet
// dotnet pack -c Release
// dotnet nuget push bin/Release/McpFinanceTools.1.0.0.nupkg -s https://api.nuget.org/v3/index.json -k YOUR_API_KEY// konfigurasi pom.xml untuk paket alat MCP yang dapat dibagikan
<!--
<project>
<groupId>com.example</groupId>
<artifactId>mcp-weather-tools</artifactId>
<version>1.0.0</version>
<dependencies>
<dependency>
<groupId>com.mcp</groupId>
<artifactId>mcp-server</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>
<distributionManagement>
<repository>
<id>github</id>
<name>GitHub Packages</name>
<url>https://maven.pkg.github.com/username/mcp-weather-tools</url>
</repository>
</distributionManagement>
</project>
-->
package com.example.mcp.weather;
import com.mcp.tools.Tool;
import com.mcp.tools.ToolRequest;
import com.mcp.tools.ToolResponse;
import com.mcp.tools.ToolExecutionException;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
public class WeatherForecastTool implements Tool {
private final HttpClient httpClient;
private final String apiKey;
public WeatherForecastTool(String apiKey) {
this.httpClient = HttpClient.newHttpClient();
this.apiKey = apiKey;
}
@Override
public String getName() {
return "weatherForecast";
}
@Override
public String getDescription() {
return "Gets weather forecast for a specified location";
}
@Override
public Object getSchema() {
Map<String, Object> schema = new HashMap<>();
// Definisi skema...
return schema;
}
@Override
public ToolResponse execute(ToolRequest request) {
try {
String location = request.getParameters().get("location").asText();
int days = request.getParameters().has("days") ?
request.getParameters().get("days").asInt() : 3;
// Panggil API cuaca
Map<String, Object> forecast = getForecast(location, days);
// Bangun respons
return new ToolResponse.Builder()
.setResult(forecast)
.build();
} catch (Exception ex) {
throw new ToolExecutionException("Weather forecast failed: " + ex.getMessage(), ex);
}
}
private Map<String, Object> getForecast(String location, int days) {
// Implementasi akan memanggil API cuaca
// Contoh yang disederhanakan
Map<String, Object> result = new HashMap<>();
// Tambahkan data prakiraan...
return result;
}
}
// Bangun dan publikasikan menggunakan Maven
// mvn clean package
// mvn deploy# Struktur direktori untuk paket PyPI:
# mcp_nlp_tools/
# ├── LICENSE
# ├── README.md
# ├── setup.py
# ├── mcp_nlp_tools/
# │ ├── __init__.py
# │ ├── sentiment_tool.py
# │ └── translation_tool.py
# Contoh setup.py
"""
from setuptools import setup, find_packages
setup(
name="mcp_nlp_tools",
version="0.1.0",
packages=find_packages(),
install_requires=[
"mcp_server>=1.0.0",
"transformers>=4.0.0",
"torch>=1.8.0"
],
author="Your Name",
author_email="your.email@example.com",
description="MCP tools for natural language processing tasks",
long_description=open("README.md").read(),
long_description_content_type="text/markdown",
url="https://github.com/username/mcp_nlp_tools",
classifiers=[
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
],
python_requires=">=3.8",
)
"""
# Contoh implementasi alat NLP (sentiment_tool.py)
from mcp_tools import Tool, ToolRequest, ToolResponse, ToolExecutionException
from transformers import pipeline
import torch
class SentimentAnalysisTool(Tool):
"""MCP tool for sentiment analysis of text"""
def __init__(self, model_name="distilbert-base-uncased-finetuned-sst-2-english"):
# Memuat model analisis sentimen
self.sentiment_analyzer = pipeline("sentiment-analysis", model=model_name)
def get_name(self):
return "sentimentAnalysis"
def get_description(self):
return "Analyzes the sentiment of text, classifying it as positive or negative"
def get_schema(self):
return {
"type": "object",
"properties": {
"text": {
"type": "string",
"description": "The text to analyze for sentiment"
},
"includeScore": {
"type": "boolean",
"description": "Whether to include confidence scores",
"default": True
}
},
"required": ["text"]
}
async def execute_async(self, request: ToolRequest) -> ToolResponse:
try:
# Mengambil parameter
text = request.parameters.get("text")
include_score = request.parameters.get("includeScore", True)
# Menganalisis sentimen
sentiment_result = self.sentiment_analyzer(text)[0]
# Memformat hasil
result = {
"sentiment": sentiment_result["label"],
"text": text
}
if include_score:
result["score"] = sentiment_result["score"]
# Mengembalikan hasil
return ToolResponse(result=result)
except Exception as e:
raise ToolExecutionException(f"Sentiment analysis failed: {str(e)}")
# Untuk menerbitkan:
# python setup.py sdist bdist_wheel
# python -m twine upload dist/*Saat membagikan alat MCP dengan komunitas:
-
Dokumentasi Lengkap:
- Dokumentasikan tujuan, penggunaan, dan contoh
- Jelaskan parameter dan nilai pengembalian
- Dokumentasikan ketergantungan eksternal apa pun
-
Penanganan Kesalahan:
- Implementasikan penanganan kesalahan yang kuat
- Berikan pesan kesalahan yang berguna
- Tangani kasus tepi dengan baik
-
Pertimbangan Kinerja:
- Optimalkan untuk kecepatan dan penggunaan sumber daya
- Gunakan caching bila sesuai
- Pertimbangkan skala
-
Keamanan:
- Gunakan kunci API dan autentikasi yang aman
- Validasi dan sanitasi masukan
- Terapkan pembatasan laju untuk panggilan API eksternal
-
Pengujian:
- Sertakan cakupan pengujian komprehensif
- Uji dengan berbagai jenis masukan dan kasus tepi
- Dokumentasikan prosedur pengujian
Kolaborasi yang efektif adalah kunci untuk ekosistem MCP yang berkembang.
- Isu dan Diskusi GitHub
- Microsoft Tech Community
- Saluran Discord dan Slack
- Stack Overflow (tag:
model-context-protocolataumcp)
Saat meninjau kontribusi MCP:
- Kejelasan: Apakah kode jelas dan terdokumentasi dengan baik?
- Kebenaran: Apakah bekerja sesuai harapan?
- Konsistensi: Apakah mengikuti konvensi proyek?
- Kelengkapan: Apakah tes dan dokumentasi disertakan?
- Keamanan: Apakah ada masalah keamanan?
Saat mengembangkan untuk MCP:
- Versi Protokol: Patuhi versi protokol MCP yang didukung alat Anda
- Kompatibilitas Klien: Pertimbangkan kompatibilitas mundur
- Kompatibilitas Server: Ikuti pedoman implementasi server
- Perubahan Besar: Dokumentasikan dengan jelas semua perubahan besar
Kontribusi komunitas penting bisa berupa mengembangkan registri publik untuk alat MCP.
# Skema contoh untuk API registri alat komunitas
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel, Field, HttpUrl
from typing import List, Optional
import datetime
import uuid
# Model untuk registri alat
class ToolSchema(BaseModel):
"""JSON Schema for a tool"""
type: str
properties: dict
required: List[str] = []
class ToolRegistration(BaseModel):
"""Information for registering a tool"""
name: str = Field(..., description="Unique name for the tool")
description: str = Field(..., description="Description of what the tool does")
version: str = Field(..., description="Semantic version of the tool")
schema: ToolSchema = Field(..., description="JSON Schema for tool parameters")
author: str = Field(..., description="Author of the tool")
repository: Optional[HttpUrl] = Field(None, description="Repository URL")
documentation: Optional[HttpUrl] = Field(None, description="Documentation URL")
package: Optional[HttpUrl] = Field(None, description="Package URL")
tags: List[str] = Field(default_factory=list, description="Tags for categorization")
examples: List[dict] = Field(default_factory=list, description="Example usage")
class Tool(ToolRegistration):
"""Tool with registry metadata"""
id: uuid.UUID = Field(default_factory=uuid.uuid4)
created_at: datetime.datetime = Field(default_factory=datetime.datetime.now)
updated_at: datetime.datetime = Field(default_factory=datetime.datetime.now)
downloads: int = Field(default=0)
rating: float = Field(default=0.0)
ratings_count: int = Field(default=0)
# Aplikasi FastAPI untuk registri
app = FastAPI(title="MCP Tool Registry")
# Basis data dalam memori untuk contoh ini
tools_db = {}
@app.post("/tools", response_model=Tool)
async def register_tool(tool: ToolRegistration):
"""Register a new tool in the registry"""
if tool.name in tools_db:
raise HTTPException(status_code=400, detail=f"Tool '{tool.name}' already exists")
new_tool = Tool(**tool.dict())
tools_db[tool.name] = new_tool
return new_tool
@app.get("/tools", response_model=List[Tool])
async def list_tools(tag: Optional[str] = None):
"""List all registered tools, optionally filtered by tag"""
if tag:
return [tool for tool in tools_db.values() if tag in tool.tags]
return list(tools_db.values())
@app.get("/tools/{tool_name}", response_model=Tool)
async def get_tool(tool_name: str):
"""Get information about a specific tool"""
if tool_name not in tools_db:
raise HTTPException(status_code=404, detail=f"Tool '{tool_name}' not found")
return tools_db[tool_name]
@app.delete("/tools/{tool_name}")
async def delete_tool(tool_name: str):
"""Delete a tool from the registry"""
if tool_name not in tools_db:
raise HTTPException(status_code=404, detail=f"Tool '{tool_name}' not found")
del tools_db[tool_name]
return {"message": f"Tool '{tool_name}' deleted"}- Komunitas MCP beragam dan menyambut berbagai jenis kontribusi
- Berkontribusi ke MCP bisa berupa peningkatan protokol inti hingga alat kustom
- Mengikuti pedoman kontribusi meningkatkan peluang PR Anda diterima
- Membuat dan membagikan alat MCP adalah cara berharga untuk meningkatkan ekosistem
- Kolaborasi komunitas sangat penting untuk pertumbuhan dan perbaikan MCP
- Identifikasi area dalam ekosistem MCP di mana Anda bisa memberi kontribusi berdasarkan keahlian dan minat Anda
- Fork repositori MCP dan siapkan lingkungan pengembangan lokal
- Buat peningkatan kecil, perbaikan bug, atau alat yang akan bermanfaat bagi komunitas
- Dokumentasikan kontribusi Anda dengan tes dan dokumentasi yang tepat
- Ajukan pull request ke repositori yang sesuai
Selanjutnya: Pelajaran dari Adopsi Awal
Penafian:
Dokumen ini telah diterjemahkan menggunakan layanan terjemahan AI Co-op Translator. Meskipun kami berupaya untuk memberikan terjemahan yang akurat, harap diingat bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber otoritatif. Untuk informasi yang penting, disarankan menggunakan terjemahan profesional oleh penerjemah manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini.