(اوپر دی گئی تصویر پر کلک کریں تاکہ اس سبق کی ویڈیو دیکھ سکیں)
یہ سبق MCP کمیونٹی کے ساتھ جڑنے، MCP ایکو سسٹم میں تعاون کرنے، اور مشترکہ ترقی کے بہترین طریقوں پر عمل کرنے پر مرکوز ہے۔ اوپن سورس MCP پروجیکٹس میں حصہ لینا ان لوگوں کے لیے ضروری ہے جو اس ٹیکنالوجی کے مستقبل کو تشکیل دینا چاہتے ہیں۔
اس سبق کے اختتام تک، آپ:
- MCP کمیونٹی اور ایکو سسٹم کی ساخت کو سمجھ سکیں گے
- MCP کمیونٹی فورمز اور مباحثوں میں مؤثر طریقے سے حصہ لے سکیں گے
- MCP اوپن سورس ریپوزیٹریز میں تعاون کر سکیں گے
- اپنی مرضی کے MCP ٹولز اور سرورز بنا کر شیئر کر سکیں گے
- MCP ترقی اور تعاون کے بہترین طریقوں پر عمل کر سکیں گے
- MCP ترقی کے لیے کمیونٹی وسائل اور فریم ورک دریافت کر سکیں گے
MCP ایکو سسٹم مختلف اجزاء اور شرکاء پر مشتمل ہے جو پروٹوکول کو آگے بڑھانے کے لیے مل کر کام کرتے ہیں۔
- کور پروٹوکول مینٹینرز: Model Context Protocol GitHub تنظیم MCP کی بنیادی وضاحتیں اور حوالہ جات کو برقرار رکھتی ہے۔
- ٹول ڈیولپرز: وہ افراد اور ٹیمیں جو MCP ٹولز اور سرورز بناتے ہیں۔
- انٹیگریشن فراہم کنندگان: وہ کمپنیاں جو MCP کو اپنی مصنوعات اور خدمات میں شامل کرتی ہیں۔
- اختتامی صارفین: وہ ڈویلپرز اور تنظیمیں جو MCP کو اپنی ایپلیکیشنز میں استعمال کرتی ہیں۔
- تعاون کرنے والے: وہ کمیونٹی ممبران جو کوڈ، دستاویزات، یا دیگر وسائل میں تعاون کرتے ہیں۔
- MCP کلائنٹس - وہ کلائنٹس جو MCP انٹیگریشنز کو سپورٹ کرتے ہیں۔
- کمیونٹی MCP سرورز - کمیونٹی کے ذریعے تیار کردہ MCP سرورز کی بڑھتی ہوئی فہرست۔
- Awesome MCP Servers - MCP سرورز کی منتخب کردہ فہرست۔
- PulseMCP - MCP وسائل دریافت کرنے کے لیے کمیونٹی حب اور نیوز لیٹر۔
- Discord سرور - MCP ڈویلپرز کے ساتھ جڑیں۔
- زبان کے لحاظ سے SDK کی تنفیذ
- بلاگ پوسٹس اور ٹیوٹوریلز
MCP ایکو سسٹم مختلف اقسام کے تعاون کا خیر مقدم کرتا ہے:
-
کوڈ تعاون:
- کور پروٹوکول میں بہتری
- بگ فکسز
- ٹول اور سرور کی تنفیذ
- مختلف زبانوں میں کلائنٹ/سرور لائبریریاں
-
دستاویزات:
- موجودہ دستاویزات کو بہتر بنانا
- ٹیوٹوریلز اور گائیڈز بنانا
- دستاویزات کا ترجمہ کرنا
- مثالیں اور نمونہ ایپلیکیشنز بنانا
-
کمیونٹی سپورٹ:
- فورمز اور مباحثوں میں سوالات کے جوابات دینا
- مسائل کی جانچ اور رپورٹنگ
- کمیونٹی ایونٹس کا انعقاد
- نئے تعاون کرنے والوں کی رہنمائی
کور MCP پروٹوکول یا سرکاری تنفیذ میں تعاون کرنے کے لیے، سرکاری تعاون کے رہنما اصول کے اصولوں پر عمل کریں:
-
سادگی اور کم سے کمیت: MCP وضاحت نئے تصورات شامل کرنے کے لیے اعلیٰ معیار برقرار رکھتی ہے۔ وضاحت میں چیزیں شامل کرنا ہٹانے سے آسان ہے۔
-
ٹھوس نقطہ نظر: وضاحت میں تبدیلیاں مخصوص تنفیذی چیلنجز پر مبنی ہونی چاہئیں، نہ کہ قیاسی خیالات پر۔
-
تجویز کے مراحل:
- تعریف کریں: مسئلے کی جگہ کو دریافت کریں، تصدیق کریں کہ دیگر MCP صارفین کو بھی اسی طرح کا مسئلہ درپیش ہے۔
- پروٹوٹائپ بنائیں: ایک مثال حل بنائیں اور اس کے عملی اطلاق کو ظاہر کریں۔
- لکھیں: پروٹوٹائپ کی بنیاد پر وضاحت کی تجویز لکھیں۔
# Fork the repository
git clone https://github.com/YOUR-USERNAME/modelcontextprotocol.git
cd modelcontextprotocol
# Install dependencies
npm install
# For schema changes, validate and generate schema.json:
npm run check:schema:ts
npm run generate:schema
# For documentation changes
npm run check:docs
npm run format
# Preview documentation locally (optional):
npm run serve:docs// Original code with bug in the typescript-sdk
export function validateResource(resource: unknown): resource is MCPResource {
if (!resource || typeof resource !== 'object') {
return false;
}
// Bug: Missing property validation
// Current implementation:
const hasName = 'name' in resource;
const hasSchema = 'schema' in resource;
return hasName && hasSchema;
}
// Fixed implementation in a contribution
export function validateResource(resource: unknown): resource is MCPResource {
if (!resource || typeof resource !== 'object') {
return false;
}
// Improved validation
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;
}# Example contribution: A CSV data processing tool for the MCP standard library
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:
# Extract parameters
operation = request.parameters.get("operation")
output_format = request.parameters.get("outputFormat", "json")
# Get CSV data from either direct data or URL
df = await self._get_dataframe(request)
# Process based on requested operation
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"""
# Implementation would include various transformations
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}")MCP پروجیکٹس میں کامیاب تعاون کرنے کے لیے:
- چھوٹے سے شروع کریں: دستاویزات، بگ فکسز، یا چھوٹے اضافے سے آغاز کریں۔
- اسٹائل گائیڈ پر عمل کریں: پروجیکٹ کے کوڈنگ اسٹائل اور کنونشنز پر عمل کریں۔
- ٹیسٹ لکھیں: اپنے کوڈ تعاون کے لیے یونٹ ٹیسٹ شامل کریں۔
- اپنے کام کو دستاویز کریں: نئی خصوصیات یا تبدیلیوں کے لیے واضح دستاویزات شامل کریں۔
- ہدف شدہ PRs جمع کریں: پل ریکویسٹ کو ایک مسئلے یا خصوصیت پر مرکوز رکھیں۔
- فیڈبیک کے ساتھ مشغول ہوں: اپنے تعاون پر فیڈبیک کے لیے جوابدہ رہیں۔
# Clone the repository
git clone https://github.com/modelcontextprotocol/typescript-sdk.git
cd typescript-sdk
# Create a new branch for your contribution
git checkout -b feature/my-contribution
# Make your changes
# ...
# Run tests to ensure your changes don't break existing functionality
npm test
# Commit your changes with a descriptive message
git commit -am "Fix validation in resource handler"
# Push your branch to your fork
git push origin feature/my-contribution
# Create a pull request from your branch to the main repository
# Then engage with feedback and iterate on your PR as neededMCP ایکو سسٹم میں تعاون کرنے کے سب سے قیمتی طریقوں میں سے ایک اپنی مرضی کے MCP سرورز بنانا اور شیئر کرنا ہے۔ کمیونٹی نے پہلے ہی مختلف خدمات اور استعمال کے معاملات کے لیے سینکڑوں سرورز تیار کیے ہیں۔
MCP سرور کی ترقی کو آسان بنانے کے لیے کئی فریم ورک دستیاب ہیں:
-
سرکاری SDKs:
-
کمیونٹی فریم ورک:
- MCP-Framework - TypeScript میں MCP سرورز کو خوبصورتی اور رفتار کے ساتھ بنائیں۔
- MCP Declarative Java SDK - جاوا کے ساتھ تشریحی MCP سرورز۔
- Quarkus MCP Server SDK - جاوا فریم ورک MCP سرورز کے لیے۔
- Next.js MCP Server Template - MCP سرورز کے لیے اسٹارٹر Next.js پروجیکٹ۔
// 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// pom.xml configuration for a shareable MCP tool package
<!--
<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<>();
// Schema definition...
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;
// Call weather API
Map<String, Object> forecast = getForecast(location, days);
// Build response
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) {
// Implementation would call weather API
// Simplified example
Map<String, Object> result = new HashMap<>();
// Add forecast data...
return result;
}
}
// Build and publish using Maven
// mvn clean package
// mvn deploy# Directory structure for a PyPI package:
# mcp_nlp_tools/
# ├── LICENSE
# ├── README.md
# ├── setup.py
# ├── mcp_nlp_tools/
# │ ├── __init__.py
# │ ├── sentiment_tool.py
# │ └── translation_tool.py
# Example 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",
)
"""
# Example NLP tool implementation (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"):
# Load the sentiment analysis model
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:
# Extract parameters
text = request.parameters.get("text")
include_score = request.parameters.get("includeScore", True)
# Analyze sentiment
sentiment_result = self.sentiment_analyzer(text)[0]
# Format result
result = {
"sentiment": sentiment_result["label"],
"text": text
}
if include_score:
result["score"] = sentiment_result["score"]
# Return result
return ToolResponse(result=result)
except Exception as e:
raise ToolExecutionException(f"Sentiment analysis failed: {str(e)}")
# To publish:
# python setup.py sdist bdist_wheel
# python -m twine upload dist/*کمیونٹی کے ساتھ MCP ٹولز شیئر کرتے وقت:
-
مکمل دستاویزات:
- مقصد، استعمال، اور مثالیں دستاویز کریں۔
- پیرامیٹرز اور ریٹرن ویلیوز کی وضاحت کریں۔
- کسی بھی بیرونی انحصار کو دستاویز کریں۔
-
غلطی کا انتظام:
- مضبوط غلطی کا انتظام نافذ کریں۔
- مفید غلطی کے پیغامات فراہم کریں۔
- کنارے کے معاملات کو خوبصورتی سے سنبھالیں۔
-
کارکردگی کے تحفظات:
- رفتار اور وسائل کے استعمال دونوں کے لیے بہتر بنائیں۔
- مناسب ہونے پر کیشنگ نافذ کریں۔
- توسیع پذیری پر غور کریں۔
-
سیکیورٹی:
- محفوظ API کیز اور تصدیق کا استعمال کریں۔
- ان پٹ کی توثیق اور صفائی کریں۔
- بیرونی API کالز کے لیے شرح کی حد نافذ کریں۔
-
ٹیسٹنگ:
- جامع ٹیسٹ کوریج شامل کریں۔
- مختلف ان پٹ اقسام اور کنارے کے معاملات کے ساتھ ٹیسٹ کریں۔
- ٹیسٹ کے طریقہ کار کو دستاویز کریں۔
MCP ایکو سسٹم کی ترقی کے لیے مؤثر تعاون کلیدی ہے۔
- GitHub مسائل اور مباحثے
- Microsoft Tech کمیونٹی
- Discord اور Slack چینلز
- Stack Overflow (ٹیگ:
model-context-protocolیاmcp)
MCP تعاون کا جائزہ لیتے وقت:
- وضاحت: کیا کوڈ واضح اور اچھی طرح سے دستاویزی ہے؟
- درستگی: کیا یہ توقع کے مطابق کام کرتا ہے؟
- مطابقت: کیا یہ پروجیکٹ کے کنونشنز پر عمل کرتا ہے؟
- مکملیت: کیا ٹیسٹ اور دستاویزات شامل ہیں؟
- سیکیورٹی: کیا کوئی سیکیورٹی خدشات ہیں؟
MCP کے لیے ترقی کرتے وقت:
- پروٹوکول ورژننگ: اس MCP پروٹوکول ورژن پر عمل کریں جسے آپ کا ٹول سپورٹ کرتا ہے۔
- کلائنٹ مطابقت: پچھلی مطابقت پر غور کریں۔
- سرور مطابقت: سرور کی تنفیذ کے رہنما اصولوں پر عمل کریں۔
- توڑنے والی تبدیلیاں: کسی بھی توڑنے والی تبدیلیوں کو واضح طور پر دستاویز کریں۔
کمیونٹی کے لیے ایک اہم تعاون MCP ٹولز کے لیے عوامی رجسٹری تیار کرنا ہو سکتا ہے۔
# Example schema for a community tool registry API
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel, Field, HttpUrl
from typing import List, Optional
import datetime
import uuid
# Models for the tool registry
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)
# FastAPI application for the registry
app = FastAPI(title="MCP Tool Registry")
# In-memory database for this example
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"}- MCP کمیونٹی متنوع ہے اور مختلف اقسام کے تعاون کا خیر مقدم کرتی ہے۔
- MCP میں تعاون کور پروٹوکول میں بہتری سے لے کر اپنی مرضی کے ٹولز تک ہو سکتا ہے۔
- تعاون کے رہنما اصولوں پر عمل کرنے سے آپ کے PR کے قبول ہونے کے امکانات بہتر ہوتے ہیں۔
- MCP ٹولز بنانا اور شیئر کرنا ایکو سسٹم کو بہتر بنانے کا ایک قیمتی طریقہ ہے۔
- کمیونٹی تعاون MCP کی ترقی اور بہتری کے لیے ضروری ہے۔
- MCP ایکو سسٹم میں وہ علاقہ شناخت کریں جہاں آپ اپنی مہارت اور دلچسپیوں کی بنیاد پر تعاون کر سکتے ہیں۔
- MCP ریپوزیٹری کو فورک کریں اور مقامی ترقیاتی ماحول ترتیب دیں۔
- ایک چھوٹا اضافہ، بگ فکس، یا ٹول بنائیں جو کمیونٹی کے لیے فائدہ مند ہو۔
- اپنے تعاون کو مناسب ٹیسٹ اور دستاویزات کے ساتھ دستاویز کریں۔
- مناسب ریپوزیٹری میں پل ریکویسٹ جمع کریں۔
اگلا: ابتدائی اپنانے سے سبق
ڈس کلیمر:
یہ دستاویز AI ترجمہ سروس Co-op Translator کا استعمال کرتے ہوئے ترجمہ کی گئی ہے۔ ہم درستگی کے لیے کوشش کرتے ہیں، لیکن براہ کرم آگاہ رہیں کہ خودکار ترجمے میں غلطیاں یا عدم درستگی ہو سکتی ہیں۔ اصل دستاویز کو اس کی اصل زبان میں مستند ذریعہ سمجھا جانا چاہیے۔ اہم معلومات کے لیے، پیشہ ور انسانی ترجمہ کی سفارش کی جاتی ہے۔ اس ترجمے کے استعمال سے پیدا ہونے والی کسی بھی غلط فہمی یا غلط تشریح کے لیے ہم ذمہ دار نہیں ہیں۔