wehub/microsoft--mcp-for-beginners
1
0
Fork 0
Code Issues Pull Requests Actions Deployments Models Agent Notes Packages Projects Releases Wiki Activity
Files
main
microsoft--mcp-for-beginners/translations/te/06-CommunityContributions/README.md
T
wehub-resource-sync c275ba2868 chore: import upstream snapshot with attribution
2026-07-13 13:31:35 +08:00

45 KiB
Raw Permalink Blame History

కమ్యూనిటీ మరియు కాంట్రిబ్యూషన్స్

MCPకి ఎలా సహకరించాలి: టూల్స్, డాక్స్, కోడ్ మరియు మరిన్ని

(ఈ లెస్సన్ వీడియోను చూడడానికి పై చిత్రాన్ని క్లిక్ చేయండి)

అవలోకనం

ఈ లెస్సన్ MCP కమ్యూనిటీతో ఎలా వ్యవహరించాలి, MCP ఎకోసिस्टम‌కు ఎలా సహకరించాలి, మరియు సహకార డెవలప్‌మెంట్ కోసం ఉత్తమ పద్దతులు ఏమిటి అనేదానిపై Focus చేస్తుంది. ఓపెన్-సోర్స్ MCP ప్రాజెక్టుల్లో ఎలా పాల్గొనాలి అనేది ఈ టెక్నాలజీని రూపొందించేందుకు ఆసక్తి ఉన్న వారికీ మౌలిక అంశం.

అభ్యాస లక్ష్యాలు

ఈ లెస్సన్ ముగింపు వరకూ, మీరు ఈ క్రింది విషయాలను చేయగలుగుతారు:

  • MCP కమ్యూనిటీ మరియు ఎకోసిస్టమ్ యొక్క నిర్మాణాన్ని అర్థం చేసుకోండి
  • MCP కమ్యూనిటీ ఫోరమ్స్ మరియు చర్చల్లో సమర్థవంతంగా పాల్గొనండి
  • MCP ఓపెన్-సోర్స్ రిపాజిటరీలలో సహకరించండి
  • కస్టమ్ MCP టూల్స్ మరియు సర్వర్లు సృష్టించి పంచుకోండి
  • MCP డెవలప్‌మెంట్ మరియు సహకారం కోసం ఉత్తమ పద్ధతులను అనుసరించండి
  • MCP డెవలప్‌మెంట్ కోసం కమ్యూనిటీ వనరులు మరియు ఫ్రేమ్‌వర్క్‌లు కనుగొనండి

MCP కమ్యూనిటీ ఎకోసిస్టమ్

MCP ఎకోసిస్టమ్ అనేది వివిధ భాగాలు మరియు పాల్గొనే వారితో కూడిన జట్లతో ఉంటుంది, ఇవి కలిసి ఈ ప్రోటోకాల్‌ను అభివృద్ధి చేస్తాయి.

ముఖ్య కమ్యూనిటీ భాగాలు

  1. కోర్ ప్రోటోకాల్ నిర్వహకులు: అధికారిక Model Context Protocol GitHub సంస్థ MCP ప్రాథమిక స్పెసిఫికేషన్లు మరియు రిఫరెన్స్ ఇంప్లిమెంటేషన్లు నిర్వహిస్తారు
  2. టూల్ డెవలపర్స్: MCP టూల్స్ మరియు సర్వర్లను సృష్టించే వ్యక్తులు మరియు జట్లు
  3. ఇంటిగ్రేషన్ ప్రొవైడర్స్: తమ ఉత్పత్తులు మరియు సేవల్లో MCPని ఇంటిగ్రేట్ చేసే కంపెనీలు
  4. ఎండ్ యూజర్స్: MCPని తమ అప్లికేషన్లలో ఉపయోగించే డెవలపర్లు మరియు సంస్థలు
  5. కాంట్రిబ్యూటర్స్: కోడ్, డాక్యుమెంటేషన్ లేదా ఇతర వనరులను ఇచ్చే కమ్యూనిటీ సభ్యులు

కమ్యూనిటీ వనరులు

అధికారిక ఛానెల్స్

కమ్యూనిటీ-చేరిన వనరులు

MCPకు సహకరించడం

కాంట్రిబ్యూషన్ల రకాలు

MCP ఎకోసిస్టమ్ వివిధ రకాల కాంట్రిబ్యూషన్లను స్వాగతిస్తుంది:

  1. కోడ్ కాంట్రిబ్యూషన్స్:

    • కోర్ ప్రోటోకాల్ మెరుగుదలలు
    • దోషాలు సవరణలు
    • టూల్ మరియు సర్వర్ అమల్స్
    • వివిధ భాషలలో క్లయింట్/సర్వర్ లైబ్రరీలు

  2. డాక్యుమెంటేషన్:

    • ఉన్న డాక్యుమెంటేషన్ మెరుగుదల
    • ట్యుటోరియల్స్ మరియు గైడ్స్ సృష్టించడం
    • డాక్యుమెంటేషన్ అనువాదం
    • ఉదాహరణలు మరియు నమూనా అప్లికేషన్లు సృష్టించడం

  3. కమ్యూనిటీ సపోర్ట్:

    • ఫోరమ్స్ మరియు చర్చలలో ప్రశ్నలకు జవాబివ్వడం
    • పరీక్షలు మరియు సమస్యలను నివేదిక చేయడం
    • కమ్యూనిటీ ఈవెంట్స్ నిర్వహణ
    • కొత్త కాంట్రిబ్యూటర్స్‌కు మార్గనిర్దేశం

కాంట్రిబ్యూషన్ ప్రాసెస్: కోర్ ప్రోటోకాల్

కోర్ MCP ప్రోటోకాల్ లేదా అధికారిక అమల్స్‌లో సహకరించడానికి, అధికారిక కాంట్రిబ్యూటింగ్ మార్గదర్శకాలులో ఉన్న ఈ సూత్రాలను అనుసరించండి:

  1. సరళత మరియు కనీసం: MCP స్పెసిఫికేషన్ కొత్త కాన్సెప్ట్స్ జోడించేందుకు గరిష్ట ప్రమాణం కలిగి ఉంటుంది. తొలగించడానికి కంటే జోడించడం సులభం.

  2. నిర్దిష్ట దృష్టికోణం: స్పెసిఫికేషన్ మార్పులు నిర్దిష్ట అమలులో సవాళ్లపై ఆధారపడి ఉండాలి, ఊహాత్మక ఆలోచనలపై కాదు.

  3. ప్రస్తావన దశలు:

    • నిర్వచించు: సమస్య స్థలం అన్వేషించండి, ఇతర MCP వినియోగదారులు కూడా ఇలాంటి సమస్య ఎదుర్కొంటున్నారా అని ధ్రువీకరించండి
    • నమూనా తోటకం: ఒక ఉదాహరణ పరిష్కారాన్ని నిర్మించుకొని దాని ప్రాక్టికల్ అప్లికేషనును చూపించండి
    • వ్రాయండి: నమూనా తోటకం ఆధారంగా స్పెసిఫికేషన్ ప్రపోజల్ వ్రాయండి

డెవలప్‌మెంట్ వాతావరణం సెటప్

# రిపాజిటరీని ఫోర్క్ చేయండి
git clone https://github.com/YOUR-USERNAME/modelcontextprotocol.git
cd modelcontextprotocol

# డిపెండెన్సీలను ఇన్‌స్టాల్ చేయండి
npm install

# స్కీమా మార్పుల కోసం, స్కీమాను ధృవీకరించండి మరియు schema.jsonను తయారుచేయండి:
npm run check:schema:ts
npm run generate:schema

# డాక్యుమెంటేషన్ మార్పుల కోసం
npm run check:docs
npm run format

# డాక్యుమెంటేషన్‌ను స్థానికంగా ప్రివ్యూ చేయండి (ఐచ్ఛికం):
npm run serve:docs

ఉదాహరణ: బగ్ ఫిక్స్‌లో సహకారము

// typescript-sdkలో బగ్ ఉన్న మౌలిక కోడ్
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 ప్రాజెక్టులలో విజయవంతమైన కాంట్రిబ్యూషన్ చేయడానికి:

  1. చిన్నదిగా ప్రారంభించండి: డాక్యుమెంటేషన్, బగ్ ఫిక్స్‌లు, లేదా చిన్న మెరుగుదలలతో మొదలుపెట్టండి
  2. స్టైల్ గైడ్ అనుసరించండి: ప్రాజెక్ట్ యొక్క కోడింగ్ శైలి మరియు పద్ధతులకు కట్టుబడి ఉండండి
  3. పరీక్షలు వ్రాయండి: మీ కోడ్ కాంట్రిబ్యూషన్లకు యూనిట్ టెస్టులను చేర్చండి
  4. మీ పని డాక్యుమెంట్ చేయండి: కొత్త ఫీచర్లు లేదా మార్పుల కోసం స్పష్టమైన డాక్యుమెంటేషన్ జోడించండి
  5. లక్ష్య PRs అందించండి: పుల్ రిక్వెస్టులు ఒక సమస్య లేదా ఫీచర్ పై దృష్టి పెట్టి ఉండాలి
  6. ఫీడ్‌బ్యాక్‌తో వ్యవహరించండి: మీ కాంట్రిబ్యూషన్లపై వచ్చిన సూచనలను జవాబివ్వండి

ఉదాహరణ కాంట్రిబ్యూషన్ వర్క్‌ఫ్లో

# రిపోజిటరీని క్లోన్ చేయండి
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

# మీ బ్రాంచ్ నుండి ప్రధాన రిపోజిటరీకి పుల్ రిక్వెస్ట్ సృష్టించండి
# తర్వాత అభిప్రాయాలతో చర్చించండి మరియు అవసరమైతే మీ పీఆర్ పై పునరావృతం చేయండి

MCP సర్వర్స్ సృష్టించడం మరియు పంచుకోవడం

MCP ఎకోసిస్టమ్‌కు అత్యంత విలువైన మార్గాల్లో ఒకటి కస్టమ్ MCP సర్వర్స్ సృష్టించి వాటిని పంచుకోవడం. కమ్యూనిటీ ఇప్పటికే వివిధ సేవలకు మరియు వినియోగ దలాలకు వందలాది సర్వర్లు అభివృద్ధి చేసింది.

MCP సర్వర్ డెవలప్‌మెంట్ ఫ్రేమ్‌వర్క్‌లు

MCP సర్వర్ డెవలప్‌మెంట్‌ను సులభతరం చేయడానికి అనేక ఫ్రేమ్‌వర్క్‌లు అందుబాటులో ఉన్నాయి:

  1. అధికారిక SDKలు (MCP స్పెసిఫికేషన్ 2025-11-25కి అనుసంధానంగా):

  2. కమ్యూనిటీ ఫ్రేమ్‌వర్క్‌లు:

    • MCP-Framework - TypeScriptలో MCP సర్వర్లను అందంగా మరియు వేగంగా నిర్మించు
    • MCP Declarative Java SDK - Javaతో అనోటేషన్-ఆధారిత MCP సర్వర్లు
    • Quarkus MCP Server SDK - MCP సర్వర్ల కోసం Java ఫ్రేమ్‌వర్క్
    • Next.js MCP Server Template - 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

Java ఉదాహరణ: టూల్స్ కోసం 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

Python ఉదాహరణ: 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 టూల్స్‌ను కమ్యూనిటీతో పంచుకున్నప్పుడు:

  1. సంపూర్ణ డాక్యుమెంటేషన్:

    • ఉపయోగం, ప్రయోజనం మరియు ఉదాహరణలను డాక్యుమెంట్ చేయండి
    • పరిమాణాలు మరియు తిరిగి వచ్చే విలువలను వివరించండి
    • ఎలాంటి బాహ్య ఆధారాలు ఉన్నవో చేర్చండి

  2. లోపాల నిర్వహణ:

    • బలమైన లోపాల నిర్వహణ అమలు చేయండి
    • ఉపయోగకరమైన లోప సందేశాలు అందించండి
    • అద్భుతమైన సందర్భాలను మంచిగా, శ్రద్ధగా నిర్వహించండి

  3. పనితీరు విషయాలు:

    • వేగం మరియు వనరు వినియోగంలో సమతుల్యత ఉంచండి
    • సరైన సమయంలో క్యాషింగ్ అమలు చేయండి
    • స్కేలబిలిటీని కూడా పరిగణించండి

  4. భద్రత:

    • భద్రమైన API కీలు మరియు ధృవీకరణ ఉపయోగించండి
    • ఇన్‌పుట్‌లను వాలిడేట్ చేసి శుభ్ర పరచండి
    • బాహ్య API కాల్స్‌కు రేట్ పరిమితి అమలు చేయండి

  5. పరీక్షలు:

    • సమగ్ర టెస్ట్ కవరేజ్ ఉండాలి
    • వేర్వేరు ఇన్‌పుట్ రకాల మరియు అద్భుత సందర్భాలతో పరీక్షించండి
    • టెస్ట్ ప్రక్రియలను డాక్యుమెంట్ చేయండి

కమ్యూనిటీ సహకారం మరియు ఉత్తమ పద్ధతులు

ప్రభావవంతమైన సహకారం ఒక అభివృద్ధి దశలో ఉన్న MCP ఎకోసిస్టమ్‌కు కీలకం.

కమ్యూనికేషన్ ఛానెల్స్

  • GitHub Issues మరియు చర్చలు
  • Microsoft Tech Community
  • Discord మరియు Slack ఛానెల్స్
  • Stack Overflow (ట్యాగ్: model-context-protocol లేదా mcp)

కోడ్ సమీక్షలు

MCP కాంట్రిబ్యూషన్ల సమీక్ష చేసే సమయంలో:

  1. స్పష్టత: కోడ్ స్పష్టంగా మరియు బాగా డాక్యుమెంట్ చేయబడిందా?
  2. సరిగా పనిచేస్తుందా?: అది ఆశించినట్లుగా పనిచేస్తుందా?
  3. సంయోజితత్వం: ప్రాజెక్ట్ సాంప్రదాయాలతో అనుగుణంగా ఉందా?
  4. సంపూర్ణత: టెస్టులు మరియు డాక్యుమెంటేషన్ చేర్చబడిందా?
  5. భద్రత: ఎటువంటి భద్రతా సమస్యలున్నాయా?

వెర్షన్ సపూర్తి

MCP కోసం డెవలప్‌మెంట్ చేస్తున్నప్పుడు:

  1. ప్రోటోకాల్ వెర్షనింగ్: మీ టూల్ మద్దతునిచ్చే MCP ప్రోటోకాల్ వెర్షన్‌కు అనుగుణంగా ఉండండి
  2. క్లయింట్ కంపాటిబిలిటీ: వెనుకు సరిపోకుండా ఉండటం పరిగణించండి
  3. సర్వర్ కంపాటిబిలిటీ: సర్వర్ అమలు మార్గదర్శకాలను అనుసరించండి
  4. బ్రేక్ఇంగ్ చేంజెస్: ఏవైనా బ్రేక్ఇంగ్ మార్పులను స్పష్టంగా డాక్యుమెంట్ చేయండి

కమ్యూనిటీ ప్రాజెక్ట్ ఉదాహరణ: 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)

# రిజిస్ట్రి కోసం ఫాస్ట్API అప్లికేషన్
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కు సహకారం కోర్ ప్రోటోకాల్ మెరుగుదలల నుంచి కస్టమ్ టూల్సు వరకు ఉండవచ్చు
  • కాంట్రిబ్యూషన్ గైడ్‌లైన్స్ అనుసరించడం మీ PR జీఆర్ అవ్వడానికి అవకాశం పెంచుతుంది
  • MCP టూల్స్‌ను సృష్టించి పంచుకోవడం ఎకోసిస్టమ్‌ను అభివృద్ధి చేసే విలువైన మార్గం
  • MCP యొక్క వృద్ధికి మరియు మెరుగుదలకు కమ్యూనిటీ సహకారం అవసరం

వ్యాయామం

  1. MCP ఎకోసిస్టమ్‌లో మీ నైపుణ్యాలు మరియు ఆసక్తుల ఆధారంగా సహకరించగల ఓ ప్రాంతాన్ని గుర్తించండి
  2. MCP రిపాజిటరీను ఫోర్క్ చేసుకుని స్థానిక డెవలప్‌మెంట్ వాతావరణం సెట్ చేయండి
  3. కమ్యూనిటీకి ప్రయోజనకరమైన చిన్న మెరుగుదల, బగ్ ఫిక్స్ లేదా టూల్ ను సృష్టించండి
  4. మీ కాంట్రిబ్యూషన్‌ను సరైన పరీక్షలు మరియు డాక్యుమెంటేషన్‌తో వివరించండి
  5. సరైన రిపాజిటరీకు పుల్ రిక్వెస్ట్ సబ్మిట్ చేయండి

అదనపు వనరులు

తర్వాత ఏమిటి

తర్వాత: పూర్వపు అనుసరణ నుండి పాఠాలు

విమర్శనాత్మక గమనిక: ఈ పత్రం AI అనువాద సేవ Co-op Translator ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, యంత్ర అనువాదాల్లో పొరపాట్లు లేదా తప్పుదోవలు ఉండే అవకాశముంది. మగువ భాషలో ఉన్న అసలు పత్రాన్ని అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారం కోసం వృత్తి పరమైన మానవ అనువాదం చేయించుకోవడం మంచిది. ఈ అనువాదం వలన కలిగే ఎటువంటి అపార్థాలు లేదా తప్సిలుల కోసం మేము బాధ్యులు కాదు.

Reference in New Issue View Git Blame Copy Permalink