wehub-resource-sync
45 KiB
45 KiB
ಸಮುದಾಯ ಮತ್ತು ಕೊಡುಗೆಗಳು
(ಈ ಪಾಠದ ವೀಡಿಯೋವನ್ನು ನೋಡಲು ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ)
ಅವಲೋಕನ
ಈ ಪಾಠವು MCP ಸಮುದಾಯದೊಂದಿಗೆ ಹೇಗೆ ಒಟ್ಟಾಗಿ ಪಾಲ್ಗೊಳ್ಳುವುದು, MCP ಪರಿಸರಕ್ಕೆ ನೀಡುವ ಕೊಡುಗೆಗಳು ಮತ್ತು ಸಹಯೋಗಾತ್ಮಕ ಅಭಿವೃದ್ಧಿಗೆ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಬಗ್ಗೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ. ತೆರೆಯಲಾದ ಆಧಾರದ MCP ಪ್ರಾಜೆಕ್ಟುಗಳಲ್ಲಿ ಪಾಲ್ಗೊಳ್ಳುವುದು ಈ ತಂತ್ರಜ್ಞಾನದ ಭವಿಷ್ಯವನ್ನು ರೂಪಿಸಲು ಬಯಸುವವರಿಗೆ ಅತ್ಯಾವಶ್ಯಕವಾಗಿದೆ.
ಕಲಿಕಾ ಗುರಿಗಳು
ಈ ಪಾಠದ ಅಂತ್ಯಕ್ಕೆ, ನೀವು ಸಾಮರ್ಥ್ಯ ಹೊಂದಿರುತ್ತೀರಿ:
- MCP ಸಮುದಾಯ ಮತ್ತು ಪರಿಸರದ ರಚನೆಯನ್ನು ಅರಿತುಕೊಳ್ಳುವುದು
- MCP ಸಮುದಾಯ ಫೋರಮ್ಗಳು ಮತ್ತು ಚರ್ಚೆಗಳಲ್ಲಿ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪಾಲ್ಗೊಳ್ಳುವುದು
- MCP ತೆರೆಯಲಾದ ಆಧಾರದ ರೆಪೊಸಿಟರಿಗಳಲ್ಲಿ ಕೊಡುಗೆ ನೀಡುವುದು
- ಕಸ್ಟಮ್ MCP ಸಾಧನಗಳು ಮತ್ತು ಸರ್ವರ್ಗಳನ್ನು ರಚಿಸಿ ಹಂಚಿಕೊಳ್ಳುವುದು
- MCP ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಸಹಯೋಗಕ್ಕೆ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವುದು
- MCP ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸಮುದಾಯ ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಫ್ರೇಮ್ವರ್ಕ್ಗಳನ್ನು ಅನ್ವೇಷಿಸುವುದು
MCP ಸಮುದಾಯ ಪರಿಸರ
MCP ಪರಿಸರವು ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಮುಂದುವರಿಸಲು ಒಟ್ಟಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಿವಿಧ ಭಾಗಗಳು ಮತ್ತು ಭಾಗವಹಿಸುವವರಿಂದ ಕೂಡಿದೆ.
ಪ್ರಮುಖ ಸಮುದಾಯ ಅಂಗಾಂಶಗಳು
- ಕಾರ್ಯನಿರ್ವಹಣಾ ಪ್ರೋಟೋಕಾಲ್ ನಿರ್ವಹಕರು: ಅಧಿಕೃತ Model Context Protocol GitHub ಸಂಸ್ಥೆ ಮೂಲ MCP ವಿನಿಯೋಗಗಳ ಮತ್ತು ಉಲ್ಲೇಖ ಅನುಷ್ಠಾನಗಳ ನಿರ್ವಹಣೆ ಮಾಡುತ್ತದೆ
- ಸಾಧನ ವಿಕಸಕರು: MCP ಸಾಧನಗಳು ಮತ್ತು ಸರ್ವರ್ಗಳನ್ನು ರಚಿಸುವ ವ್ಯಕ್ತಿಗಳು ಮತ್ತು ತಂಡಗಳು
- ಒಟ್ಟು ಸೇರಿಸುವವರಿಗೆ ಪೂರೈಕೆದಾರರು: ತಮ್ಮ ಉತ್ಪನ್ನಗಳು ಮತ್ತು ಸೇವೆಗಳಲ್ಲಿ MCP ಅನ್ನು ಸೇರಿಸುವ ಕಂಪನಿಗಳು
- ಅಂತಿಮ ಬಳಕೆದಾರರು: MCP ಅನ್ನು ತಮ್ಮ ಅನ್ವಯಗಳಲ್ಲಿ ಬಳಸುವ ವೃತ್ತಿಪರರು ಮತ್ತು ಸಂಸ್ಥೆಗಳು
- ಕೊಡುಗೆದಾರರು: ಕೋಡ್, ಡಾಕ್ಯುಮೆಂಟ್ ಅಥವಾ ಇತರ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಕೊಡುಗೆ ನೀಡುವ ಸಮುದಾಯ ಸದಸ್ಯರು
ಸಮುದಾಯ ಸಂಪನ್ಮೂಲಗಳು
ಅಧಿಕೃತ ಚಾನೆಲ್ಗಳು
- MCP GitHub ಸಂಸ್ಥೆ
- MCP ಡಾಕ್ಯುಮೆಂಟೇಶನ್
- MCP ನಿರ್ದಿಷ್ಟತೆ
- GitHub ಚರ್ಚೆಗಳು
- MCP ಉದಾಹರಣೆಗಳು ಮತ್ತು ಸರ್ವರ್ ರೆಪೊಸಿಟರಿ
ಸಮುದಾಯ ಚಾಲಿತ ಸಂಪನ್ಮೂಲಗಳು
- MCP ಕ್ಲೈಂಟ್ಗಳು - MCP ಸಂಯೋಜನೆಗಳನ್ನು ಬೆಂಬಲಿಸುವ ಕ್ಲೈಂಟ್ಗಳ ಪಟ್ಟಿಮನು
- ಸಮುದಾಯ MCP ಸರ್ವರ್ಗಳು - ಸಮುದಾಯ ವಿಕಸಿತ MCP ಸರ್ವರ್ಗಳ ಹೆಚ್ಚುತ್ತಿರುವ ಪಟ್ಟಿಮನು
- ಅತ್ಯುತ್ತಮ MCP ಸರ್ವರ್ಗಳು - ಆಯ್ಕೆಮಾಡಲಾದ MCP ಸರ್ವರ್ಗಳ ಪಟ್ಟಿಮನು
- PulseMCP - MCP ಸಂಪನ್ಮೂಲ ಕಂಡುಹಿಡಿಯಲು ಸಮುದಾಯ ಕೇಂದ್ರ ಮತ್ತು ವಾರ್ತಾ ಪತ್ರಿಕೆ
- Discord ಸರ್ವರ್ - MCP ವಿಕಸಕರೊಂದಿಗೆ ಸಂಪರ್ಕ
- ಭಾಷಾ ನಿರ್ದಿಷ್ಟ SDK ಅನುಷ್ಠಾನಗಳು
- ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ಗಳು ಮತ್ತು ಪಾಠಗಳು
MCPಗೆ ಕೊಡುಗೆ ನೀಡುವುದು
ಕೊಡುಗೆಗಳ ಪ್ರಕಾರಗಳು
MCP ಪರಿಸರವು ವಿವಿಧ ರೀತಿಯ ಕೊಡುಗೆಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ:
-
ಕೋಡ್ ಕೊಡುಗೆಗಳು:
- ಮೂಲ ಪ್ರೋಟೋಕಾಲ್ ವೃದ್ಧಿಗಳು
- ದೋಷದ ಸರಿಪಡಿಕೆಗಳು
- ಸಾಧನ ಮತ್ತು ಸರ್ವರ್ ಅನುಷ್ಠಾನಗಳು
- ವಿಭಿನ್ನ ಭಾಷೆಗಳ ಕ್ಲೈಂಟ್/ಸರ್ವರ್ ಗ್ರಂಥಾಲಯಗಳು
-
ಡಾಕ್ಯುಮೆಂಟೇಶನ್:
- ಇತ್ತೀಚಿನ ಡಾಕ್ಯುಮೆಂಟ್ ಸುಧಾರಣೆಗಳು
- ಪಾಠಗಳು ಮತ್ತು ಮಾರ್ಗಗಳ ರಚನೆ
- ಡಾಕ್ಯುಮೆಂಟ್ ಭಾಷಾಂತರಣೆ
- ಉದಾಹರಣೆಗಳು ಮತ್ತು ಮಾದರಿ ಅನ್ವಯಗಳ ರಚನೆ
-
ಸಮುದಾಯ ಬೆಂಬಲ:
- ಫೋರಮ್ಗಳಲ್ಲಿ ಮತ್ತು ಚರ್ಚೆಗಳಲ್ಲಿ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸುವುದು
- ಪರೀಕ್ಷಿಸಿ ಸಮಸ್ಯೆಗಳನ್ನು ವರದಿ ಮಾಡುವುದು
- ಸಮುದಾಯ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಏರ್ಪಡಿಸುವುದು
- ಹೊಸ ಕೊಡುಗೆದಾರರಿಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುವುದು
ಕೊಡುಗೆ ಪ್ರಕ್ರಿಯೆ: ಮೂಲ ಪ್ರೋಟೋಕಾಲ್
ಮೂಲ MCP ಪ್ರೋಟೋಕಾಲ್ ಅಥವಾ ಅಧಿಕೃತ ಅನುಷ್ಠಾನಗಳಿಗೆ ಕೊಡುಗೆ ನೀಡಲು, ಅಧಿಕೃತ ಕೊಡುಗೆ ಮಾರ್ಗಸೂಚಿ ಯಲ್ಲಿರುವ ಸಿದ್ಧಾಂತಗಳನ್ನು ಅನುಸರಿಸಿ:
-
ಸರಳತೆ ಮತ್ತು ಕನಿಷ್ಠತೆ: MCP ನಿರ್ದಿಷ್ಟತೆ ಹೊಸ ಸಂಶೋಧನೆಗಳನ್ನು ಸೇರಿಸಲು ಹೆಚ್ಚಿನ ಮಟ್ಟವನ್ನು ಕಾಯ್ದುಕೊಳ್ಳುತ್ತದೆ. ಹೊಸ ಸಂಗತಿಗಳನ್ನು ಸೇರಿಸುವುದು ಅಳಿಸುವುದಕ್ಕಿಂತ ಸುಲಭ.
-
ನಿಖರ ಶೈಲಿ: ನಿರ್ದಿಷ್ಟತೆ ಬದಲಾವಣೆಗಳು ನಿರ್ದಿಷ್ಟ ಅನುಷ್ಠಾನ ಸವಾಲುಗಳ ಆಧಾರವಾಗಿರಬೇಕು, ಊಹಾಪೋಹದ ಆಲೋಚನೆಗಳೇ ಆಗಬಾರದು.
-
ಪ್ರಸ್ತಾವನದ ಹಂತಗಳು:
- ವ್ಯಾಖ್ಯಾನಿಸಿ: ಸಮಸ್ಯಾ ಕ್ಷೇತ್ರವನ್ನು ಅನ್ವೇಷಿಸಿ, ಇತರೆ MCP ಬಳಕೆದಾರರು ಕೂಡ ಅದೇ ಸಮಸ್ಯೆ ಎದುರಿಸುತ್ತಿರುವುದನ್ನು ದೃಢೀಕರಿಸಿ
- ಪ್ರೋಟೋಟೈಪ್ ಮಾಡಿ: ಮಾದರಿ ಪರಿಹಾರವನ್ನು ನಿರ್ಮಿಸಿ ಮತ್ತು ಅದರ ವೈಯಕ್ತಿಕ ಉಪಯೋಗವನ್ನು ತೋರಿಸಿ
- ಬರೆದು: ಪ್ರೋಟೋಟೈಪ್ ಆಧಾರಿತವಾಗಿ ನಿರ್ದಿಷ್ಟತೆ ಪ್ರಸ್ತಾವನೆ ಬರೆದು ನೀಡು
ಅಭಿವೃದ್ಧಿ ಪರಿಸರ ಸ್ಥಾಪನೆ
# ರೆಪೊಸಿಟರಿಯನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ
git clone https://github.com/YOUR-USERNAME/modelcontextprotocol.git
cd modelcontextprotocol
# ಆಧಾರಗಳನ್ನು ಸ್ಥಾಪಿಸಿ
npm install
# ಸ್ಕೀಮಾ ಬದಲಾವಣೆಗಳಿಗೆ, ಸ್ಕೀಮಾ.json ಅನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ರಚಿಸಿ:
npm run check:schema:ts
npm run generate:schema
# ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಬದಲಾವಣೆಗಾಗಿ
npm run check:docs
npm run format
# ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಪೂರ್ವದೃಶ್ಯಿಸಿ (ಐಚ್ಛಿಕ):
npm run serve:docs
ಉದಾಹರಣೆ: ದೋಷ ಸರಿಪಡಿಕೆಗೆ ಕೊಡುಗೆ ನೀಡುವುದು
// ಟೈಪ್ಸ್ಕ್ರಿಪ್ಟ್-ಎಸ್ಡಿಕೆ ನಲ್ಲಿ ದೋಷವಿರುವ ಮೂಲ ಕೋಡ್
export function validateResource(resource: unknown): resource is MCPResource {
if (!resource || typeof resource !== 'object') {
return false;
}
// ದೋಷ: ಪ್ರಾಪರ್ಟಿ ಮಾನ್ಯತೆ ಇಲ್ಲದಿರುವುದು
// ಪ್ರಸ್ತುತ ಜಾರಿಗೊಳಿಸುವಿಕೆ:
const hasName = 'name' in resource;
const hasSchema = 'schema' in resource;
return hasName && hasSchema;
}
// ಕೊಡುವಿಕೆಯಲ್ಲಿನ ಸುಧಾರಿತ ಜಾರಿಗೊಳಿಸುವಿಕೆ
export function validateResource(resource: unknown): resource is MCPResource {
if (!resource || typeof resource !== 'object') {
return false;
}
// ಸುಧಾರಿತ ಮಾನ್ಯತೆ
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;
}
ಉದಾಹರಣೆ: ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಗ್ರಂಥಾಲಯಕ್ಕೆ ಹೊಸ ಸಾಧನ ಕೊಡುಗೆ
# ಉದಾಹರಣೆ ಕೊಡುಗೆ: MCP ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರೇರಿಗಾಗಿ CSV ಡೇಟಾ ಪ್ರಕ್ರಿಯೆ ಸಾಧನ
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:
# ಪರಿಮಾಣಗಳನ್ನು ತೆಗೆಯಿರಿ
operation = request.parameters.get("operation")
output_format = request.parameters.get("outputFormat", "json")
# ನೇರ ಡೇಟಾ ಅಥವಾ URL ನಿಂದ CSV ಡೇಟಾವನ್ನು ಪಡೆಯಿರಿ
df = await self._get_dataframe(request)
# ವಿನಂತಿಸಲಾದ ಕಾರ್ಯಾಚರಣೆ ಆಧರಿಸಿ ಪ್ರಕ್ರಿಯೆ ಮಾಡಿ
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"""
# ಅನುಷ್ಠಾನದಲ್ಲಿ ವಿವಿಧ ಪರಿವರ್ತನೆಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು
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 ಪ್ರಾಜೆಕ್ಟ್ಗೆ ಯಶಸ್ವಿಯಾಗಿ ಕೊಡುಗೆ ನೀಡಲು:
- ಸಣ್ಣದರಿಂದ ಪ್ರಾರಂಭಿಸಿ: ಡಾಕ್ಯುಮೆಂಟೇಶನ್, ದೋಷ ಸರಿಪಡಿಕೆಗಳು ಅಥವಾ ಸಣ್ಣ ಸುಧಾರಣೆಗಳಿಂದ ಆರಂಭಿಸಿ
- ಶೈಲಿ ಮಾರ್ಗದರ್ಶನವನ್ನು ಅನುಸರಿಸಿ: ಪ್ರಾಜೆಕ್ಟ್ನ ಕೋಡಿಂಗ್ ಶೈಲಿ ಮತ್ತು ಸಂಪ್ರದಾಯಗಳನ್ನು ಪಾಲಿಸಿ
- ಪರೀಕ್ಷೆ ಬರೆಯಿರಿ: ನಿಮ್ಮ ಕೋಡ್ ಕೊಡುಗೆಗಳಿಗೆ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಸೇರಿಸಿ
- ನೀವು ಮಾಡಿದ ಕೆಲಸವನ್ನು ಡಾಕ್ಯುಮೆಂಟ್ ಮಾಡಿ: ಹೊಸ ತತ್ವಾಂಶಗಳು ಅಥವಾ ಬದಲಾವಣೆಗಳಿಗೆ ಸ್ಪಷ್ಟ ದಾಖಲೆ ನೀಡಿರಿ
- ಲಕ್ಷ್ಯಿತ_pull requests_ ಸಲ್ಲಿಸಿ: ಒಂದೇ ಸಮಸ್ಯೆ ಅಥವಾ ವೈಶಿಷ್ಟ್ಯಕ್ಕೆ ಸಂಬಂದಿಸಿದ_PULL REQUEST_ಗಳನ್ನು ಕೇಂದ್ರೀಕರಿಸಿ
- ಪ್ರತಿಕ್ರಿಯೆಗೆ ತ್ವರಿತವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸಿ: ನಿಮ್ಮ ಕೊಡುಗೆಗಳ ಮೇಲಿನ ಪ್ರತಿಕ್ರಿಯೆಗೆ ಸ್ಪಂದನಶೀಲವಾಗಿರಿ
ಉದಾಹರಣೆ ಕೊಡುಗೆ ಕಾರ್ಯಪಟು
# ರೆಪೋಸಿಟರಿಯನ್ನು ಕ್ಲೋನ್ ಮಾಡಿ
git clone https://github.com/modelcontextprotocol/typescript-sdk.git
cd typescript-sdk
# ನಿಮ್ಮ ಕೊಡುಗೆಯಿಂದ ಹೊಸ ಶಾಖೆಯನ್ನು ರಚಿಸಿ
git checkout -b feature/my-contribution
# ನಿಮ್ಮ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿ
# ...
# ನಿಮ್ಮ ಬದಲಾವಣೆಗಳು ಇಡಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಭಂಗ ಮಾಡದಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸಿ
npm test
# ವರ್ಣನಾತ್ಮಕ ಸಂದೇಶದೊಂದಿಗೆ ನಿಮ್ಮ ಬದಲಾವಣೆಗಳನ್ನು ಕಮಿಟ್ ಮಾಡಿ
git commit -am "Fix validation in resource handler"
# ನಿಮ್ಮ ಶಾಖೆಯನ್ನು ನಿಮ್ಮ ಫೋರ್ಕ್ಗೆ ಪುಷ್ ಮಾಡಿ
git push origin feature/my-contribution
# ನಿಮ್ಮ ಶಾಖೆಯಿಂದ ಮುಖ್ಯ ರೆಪೋಸಿಟರಿಗೇ ಪಲ್ಲು ವಿನಂತಿ ರಚಿಸಿ
# ನಂತರ ಪ್ರತಿಕ್ರಿಯೆ ಪಡೆದು ನಿಮ್ಮ PR ಮೇಲೆ ಅಗತ್ಯವಾಗಿ ಪುನರಾವ್ರತಿಸಿ
MCP ಸರ್ವರ್ಗಳನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಹಂಚಿಕೊಳ್ಳುವುದು
MCP ಪರಿಸರಕ್ಕೆ ಕೊಡುಗೆ ನೀಡುವ ಅತ್ಯಂತ ಅಮೂಲ್ಯ ಮಾರ್ಗಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಕಸ್ಟಮ್ MCP ಸರ್ವರ್ಗಳನ್ನು ರಚಿಸಿ ಹಂಚಿಕೊಳ್ಳುವುದು. ಸಮುದಾಯವು ವಿವಿಧ ಸೇವೆಗಳು ಮತ್ತು ಬಳಕೆ ಪ್ರಕರಣಗಳಿಗೆ ನೂರಾರು ಸರ್ವರ್ಗಳನ್ನು ಈಗಾಗಲೇ ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ್ದಾಗಿದೆ.
MCP ಸರ್ವರ್ ಅಭಿವೃದ್ಧಿ ಫ್ರೇಮ್ವರ್ಕ್ಗಳು
MCP ಸರ್ವರ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸರಳಗೊಳಿಸಲು ಹಲವಾರು ಫ್ರೇಮ್ವರ್ಕ್ಗಳು ಲಭ್ಯವಿವೆ:
-
ಅಧಿಕೃತ SDKಗಳು (MCP ನಿರ್ದಿಷ್ಟತೆ 2025-11-25 ಸಮ್ಮತ):
-
ಸಮುದಾಯ ಫ್ರೇಮ್ವರ್ಕ್ಗಳು:
- MCP-Framework - ಟೈಪ್ಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ MCP ಸರ್ವರ್ಗಳನ್ನು ಶೃಂಗಾರ ಮತ್ತು ವೇಗದೊಂದಿಗೆ ನಿರ್ಮಿಸಿ
- MCP ಸೂಚನಾತ್ಮಕ ಜಾವಾ SDK - ಜಾವಾ ಬಳಸಿ ಗುರುತಿನ ಸೂಚನೆಗಳಿಂದ MCP ಸರ್ವರ್ಗಳು
- Quarkus MCP ಸರ್ವರ್ SDK - MCP ಸರ್ವರ್ಗಳಿಗೆ ಜಾವಾ ಫ್ರೇಮ್ವರ್ಕ್
- Next.js MCP ಸರ್ವರ್ ಮಾದರಿ - MCP ಸರ್ವರ್ಗಳಿಗೆ ಆರಂಭ ದ Next.js ಪ್ರಾಜೆಕ್ಟ್
ಹಂಚಿಕೊಳ್ಳಬಹುದಾದ ಸಾಧನಗಳ ಅಭಿವೃದ್ಧಿ
.NET ಉದಾಹರಣೆ: ಹಂಚಿಕೊಳ್ಳಬಹುದಾದ ಸಾಧನ ಪ್ಯಾಕೇಜ್ ರಚನೆ
// 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
ಜಾವಾ ಉದಾಹರಣೆ: ಸಾಧನಗಳಿಗೆ.maven ಪ್ಯಾಕೇಜ್ ರಚನೆ
// ಹಂಚಿಕೊಳ್ಳಬಹುದಾದ MCP ಉಪಕರಣ ಪ್ಯಾಕೇಜ್ ಗೆ pom.xml ಸಂರಚನೆ
<!--
<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<>();
// ಯೋಜನೆ ವಿವರಣೆ...
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;
// ಹವಾಮಾನ API ಕರೆದಿರಿ
Map<String, Object> forecast = getForecast(location, days);
// ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕೂಡಿಸಿ
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) {
// ಅನುಷ್ಠಾನವು ಹವಾಮಾನ API ಕರೆದಿರುತ್ತೆ
// ಸರಳ ಉದಾಹರಣೆ
Map<String, Object> result = new HashMap<>();
// ಮುನ್ಸೂಚನೆಯ ಡೇಟಾವನ್ನು ಸೇರಿಸಿ...
return result;
}
}
// Maven ಬಳಸಿ ನಿರ್ಮಿಸಿ ಮತ್ತು ಪ್ರಕಟಿಸಿ
// mvn clean package
// mvn deploy
ಪೈಥಾನ್ ಉದಾಹರಣೆ: PyPI ಪ್ಯಾಕೇಜ್ ಪ್ರಕಟಣೆ
# PyPI ಪ್ಯಾಕೇಜ್ಗಾಗಿ ಡೈರೆಕ್ಟರಿ ರಚನೆ:
# mcp_nlp_tools/
# ├── LICENSE
# ├── README.md
# ├── setup.py
# ├── mcp_nlp_tools/
# │ ├── __init__.py
# │ ├── sentiment_tool.py
# │ └── translation_tool.py
# ಉದಾಹರಣೆಯ 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",
)
"""
# ಉದಾಹರಣೆಯ 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"):
# ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣಾ ಮಾದರಿಯನ್ನು ಲೋಡ್ ಮಾಡಿ
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:
# ಪ್ಯಾರಾಮೀಟರ್ಗಳನ್ನು ತೆಗೆದುಹಿಡಿಯಿರಿ
text = request.parameters.get("text")
include_score = request.parameters.get("includeScore", True)
# ಭಾವನಾತ್ಮಕವನ್ನು ವಿಶ್ಲೇಷಿಸಿ
sentiment_result = self.sentiment_analyzer(text)[0]
# ಫಲಿತಾಂಶವನ್ನು ಸ್ವರೂಪಗೊಳಿಸಿ
result = {
"sentiment": sentiment_result["label"],
"text": text
}
if include_score:
result["score"] = sentiment_result["score"]
# ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿ
return ToolResponse(result=result)
except Exception as e:
raise ToolExecutionException(f"Sentiment analysis failed: {str(e)}")
# ಪ್ರಕಟಿಸಲು:
# python setup.py sdist bdist_wheel
# python -m twine upload dist/*
ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುವುದು
MCP ಸಾಧನಗಳನ್ನು ಸಮುದಾಯದೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳುವಾಗ:
-
ಪೂರ್ಣ ಡಾಕ್ಯುಮೆಂಟೇಶನ್:
- ಉದ್ದೇಶ, ಬಳಕೆ ಮತ್ತು ಉದಾಹರಣೆಗಳನ್ನು ದಾಖಲೆ ಮಾಡಿ
- ಪ್ಯಾರಾಮಿಟರ್ಗಳು ಮತ್ತು ಹಿಂತಿರುಗುವ ಮೌಲ್ಯಗಳನ್ನು ವಿವರಿಸಿ
- ಯಾವುದಾದರೂ ಹೊರಗಿನ ಅವಲಂಬನೆಗಳನ್ನು ದಾಖಲೆ ಮಾಡಿ
-
ದೋಷ ನಿರ್ವಹಣೆ:
- ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ
- ಉಪಯುಕ್ತ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಿ
- ಅಡ್ಡಮಗ್ಗುಗಳನ್ನು ಸೂಕ್ಷ್ಮವಾಗಿ ನಿರ್ವಹಿಸಿ
-
ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಗಣನೆಗಳು:
- ವೇಗ ಮತ್ತು ಸಂಪನ್ಮೂಲ ಬಳಕೆಯಿಗಾಗಿ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿ
- ಅಗತ್ಯವಿದ್ದರೆ ಕ್ಯಾಶಿಂಗ್ ಅನ್ನು ಜಾರಿಗೆ ತರುವಿರಿ
- ವಿಸ್ತರಣೀಯತೆಯನ್ನು ಪರಿಗಣಿಸಿ
-
ಭದ್ರತೆ:
- ಸುರಕ್ಷಿತ API ಕೀಗಳು ಮತ್ತು ಪ್ರಾಮಾಣೀಕರಣವನ್ನು ಬಳಸಿ
- ಇನ್ಪುಟ್ಗಳನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಶುದ್ಧೀಕರಿಸಿ
- ಹೊರಗಿನ API ಕರೆಗಳಿಗೆ ದರ ನಿಯಂತ್ರಣವನ್ನು ಜಾರಿಗೆ ತರುವುದು
-
ಪರೀಕ್ಷೆ:
- ಸಮಗ್ರ ಪರೀಕ್ಷಾ ವ್ಯಾಪ್ತಿಯನ್ನು ಸೇರಿಸಿ
- ವಿಭಿನ್ನ ಇನ್ಪುಟ್ ಪ್ರಕಾರಗಳು ಮತ್ತು ಅಡ್ಡಮಗ್ಗುಗಳೊಂದಿಗೆ ಪರೀಕ್ಷೆ ನಡೆಸಿ
- ಪರೀಕ್ಷಾ ಕ್ರಮವನ್ನು ದಾಖಲಿಸಿ
ಸಮುದಾಯ ಸಹಕಾರ ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
ಪ್ರಭಾವಶೀಲ ಸಹಕಾರವು ಸಬೆಂಪಟ್ಟ MCP ಪರಿಸರಕ್ಕೆ ಮುಖ್ಯ.
ಸಂವಹನ ಚಾನೆಲ್ಗಳು
- GitHub ವಿಷಯಗಳು ಮತ್ತು ಚರ್ಚೆಗಳು
- Microsoft ಟೆಕ್ ಸಮುದಾಯ
- Discord ಮತ್ತು Slack ಚಾನೆಲ್ಗಳು
- Stack Overflow (ಟ್ಯಾಗ್:
model-context-protocolಅಥವಾmcp)
ಕೋಡ್ ವಿಮರ್ಶೆಗಳು
MCP ಕೊಡುಗೆಗಳನ್ನು ವಿಮರ್ಶಿಸುವಾಗ:
- ಸ್ಪಷ್ಟತೆ: ಕೋಡ್ ಸ್ಪಷ್ಟ ಮತ್ತು ಚೆನ್ನಾಗಿ ದಾಖಲೆ ಮಾಡಲಾಗಿದೆ ಎಂದು ತಿಳಿಯುತ್ತದೆಯೆ?
- ಮಾನ್ಯತೆ: ನಿರೀಕ್ಷೆಯಂತೆ ಕೆಲಸ ಮಾಡುತ್ತದೆಯೇ?
- ಸಂದರ್ಭಾತ್ಮಕತೆ: ಪ್ರಾಜೆಕ್ಟ್ ಸಂಪ್ರದಾಯಗಳನ್ನು ಅನುಸರಿಸುತ್ತದೆಯೇ?
- ಪೂರ್ಣತೆ: ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ದಾಖಲೆ ಸಮೇತವಿದ್ದವೆಯೇ?
- ಭದ್ರತೆ: ಯಾವುದೇ ಭದ್ರತಾ ಚಿಂತನೆಗಳಿವೆಯೇ?
ಆವೃತ್ತಿ ಹೊಂದಾಣಿಕೆ
MCP ಗಾಗಿ ಅಭಿವೃದ್ಧಿ ಮಾಡುವಾಗ:
- ಪ್ರೋಟೋಕಾಲ್ ಆವೃತ್ತಿ: ನಿಮ್ಮ ಸಾಧನ ಬೆಂಬಲಿಸುವ MCP ಪ್ರೋಟೋಕಾಲ್ ಆವೃತ್ತಿ ಪಾಲಿಸಿ
- ಕ್ಲೈಂಟ್ ಹೊಂದಾಣಿಕೆ: ಹಿಂದಿನ ಆವೃತ್ತಿಗೂ ಹೊಂದಿಕೊಳ್ಳುವುದು ಪರಿಗಣಿಸಿ
- ಸರ್ವರ್ ಹೊಂದಾಣಿಕೆ: ಸರ್ವರ್ ಅನುಷ್ಠಾನ ಮಾರ್ಗಸೂಚಿಗಳನ್ನು ಅನುಸರಿಸಿ
- ಈಡುಗೊಂಡ ಬದಲಾವಣೆಗಳು: ಯಾವುದೇ ಪ್ರಮುಖ ಬದಲಾವಣೆಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಡಾಕ್ಯುಮೆಂಟ್ ಮಾಡಿ
ಉದಾಹರಣೆ ಸಮುದಾಯ ಪ್ರಾಜೆಕ್ಟ್: MCP ಸಾಧನ ರಿಜಿಸ್ಟ್ರೀ
ಒಂದು ಪ್ರಮುಖ ಸಮುದಾಯ ಕೊಡುಗೆ MCP ಸಾಧನಗಳ ಸಾರ್ವಜನಿಕ ರಿಜಿಸ್ಟ್ರಿಯನ್ನು ಅಭಿವೃದ್ಧಿಗೊಳಿಸುವುದು ಆಗಿರಬಹುದು.
# ಸಮುದಾಯ ಸಾಧನ ನೋಂದಣಿ API ಗಾಗಿ ಉದಾಹರಣಾ ವಿನ್ಯಾಸ
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel, Field, HttpUrl
from typing import List, Optional
import datetime
import uuid
# ಸಾಧನ ನೋಂದಣಿಗೆ ಮಾದರಿಗಳು
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 ಅಪ್ಲಿಕೇಶನ್
app = FastAPI(title="MCP Tool Registry")
# ಈ ಉದಾಹರಣೆಗೆ ಮೆಮೊರಿ ಆಧಾರಿತ ಡೇಟಾಬೇಸ್
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ಗೆ ಕೊಡುಗೆ ನೀಡುವುದು ಮೂಲ ಪ್ರೋಟೋಕಾಲ್ ವೃದ್ಧಿಯಿಂದ ಕಸ್ಟಮ್ ಸಾಧನಗಳವರೆಗೂ ಇರಬಹುದು
- ಕೊಡುಗೆ ಮಾರ್ಗಸೂಚಿಗಳನ್ನು ಅನುಸರಿಸುವುದರಿಂದ ನಿಮ್ಮ ಪಿಆರ್ ಅಂಗೀಕಾರದ ಸಾಧ್ಯತೆ ಇರುತ್ತದೆ
- MCP ಸಾಧನಗಳನ್ನು ರಚಿಸಿ ಹಂಚಿಕೊಳ್ಳುವುದು ಪರಿಸರವನ್ನು ವೃದ್ಧಿಸುವ ಅಮೂಲ್ಯ ಮಾರ್ಗ
- ಸಮುದಾಯ ಸಹಕಾರ MCPಗಳ ಬೆಳವಣಿಗೆ ಮತ್ತು ಸುಧಾರಣೆಗೆ ಅಗತ್ಯ
ವ್ಯಾಯಾಮ
- ನಿಮ್ಮ ಕೌಶಲಗಳು ಮತ್ತು ಆಸಕ್ತಿಗಳ ಆಧಾರದಲ್ಲಿ MCP ಪರಿಸರದ ಒಂದು ಪ್ರದೇಶವನ್ನು ಗುರುತಿಸಿ ಕೊಡುಗೆ ನೀಡಲು
- MCP ರೆಪೊಸಿಟರಿಯನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿ ಪರಿಸರವನ್ನು ಸ್ಥಾಪಿಸಿ
- ಸಮುದಾಯಕ್ಕೆ ಲಾಭದಾಯಕವಾಗುವ ಸಣ್ಣ ಸುಧಾರಣೆ, ದೋಷ ದುರಸ್ತಿ ಅಥವಾ ಸಾಧನವನ್ನು ರಚಿಸಿ
- ನಿಮ್ಮ ಕೊಡುಗೆ ಸರಿಯಾದ ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ದಾಖಲೆಗಳೊಂದಿಗೆ ದಾಖಲೆ ಮಾಡಿ
- ಸೂಕ್ತ ರೆಪೊಸಿಟರಿಯವರಿಗೆ ಪుల్ ರಿಕ್ವೆಸ್ಟ್ ಸಲ್ಲಿಸಿ
ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳು
ಮುಂದಿನದು ಏನು
ಮುಂದೆ: ಮುನಿಸಿಕೆ ಆಧಾರಿತ ಪಾಠಗಳು
ದೃಢೀಕರಣ:
ಈ ದಾಖಲೆಯನ್ನು AI ಭಾಷಾಂತರ ಸೇವೆ Co-op Translator ಬಳಸಿ ಭಾಷಾಂತರಿಸಲಾಗಿದೆ. ನಾವು ನಾಯಕತ್ವಬದ್ಧತೆಯನ್ನು ಹೊಂದಿದ್ದರೂ ಸಹ, ಸ್ವಯಂಚಾಲಿತ ಭಾಷಾಂತರಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು कृಪಯಾ ಗಮನಿಸಿ. ಮೂಲದನ್ ಭಾಷೆಯಲ್ಲಿನ ಮೂಲ ದಾಖಲೆ ಪರಿಶುದ್ಧ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕಾಗಿದೆ. ಮಹತ್ವಪೂರ್ಣ ಮಾಹಿತಿಗಾಗಿ ವೃತ್ತಿಪರ ಮಾನವ ಭಾಷಾಂತರವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ. ಈ ಭಾಷಾಂತರ ಬಳಕೆಯಿಂದ ಸಂಭವಿಸಬಹುದಾದ ಯಾವುದೇ ತಪ್ಪುಬೋಧನೆಗಳು ಅಥವಾ ತಪ್ಪು ಅರ್ಥೈಸಲು ನಾವು ಜವಾಬ್ದಾರಿಯಾಗುವುದಿಲ್ಲ.