(לחץ על התמונה למעלה כדי לצפות בסרטון של השיעור הזה)
שיעור זה מתמקד כיצד להשתתף בקהילת MCP, לתרום לאקוסיסטם של MCP, ולעקוב אחר שיטות עבודה מומלצות לפיתוח שיתופי. הבנת הדרך להשתתף בפרויקטים של MCP בקוד פתוח היא חיונית עבור אלו המעוניינים לעצב את עתיד הטכנולוגיה הזאת.
בסיום השיעור תוכל:
- להבין את מבנה הקהילה והאקוסיסטם של MCP
- להשתתף בצורה אפקטיבית בפורומים ודיונים של קהילת MCP
- לתרום למאגרי הקוד הפתוח של MCP
- ליצור ולשתף כלים ושרתים מותאמים אישית של MCP
- לעקוב אחר שיטות עבודה מומלצות לפיתוח ושיתוף ב-MCP
- לגלות משאבים ומסגרות קהילתיות לפיתוח MCP
האקוסיסטם של MCP מורכב מרכיבים ומשתתפים שונים שעובדים יחד לקידום הפרוטוקול.
- אחראים על פרוטוקול הליבה: ארגון GitHub הרשמי של Model Context Protocol מנהל את המפרטים הראשיים והיישומים ההתייחסותיים של MCP
- מפתחי כלים: יחידים וצוותים שיוצרים כלים ושרתים ל-MCP
- ספקי אינטגרציה: חברות שמשלבות את MCP במוצרים ובשירותים שלהן
- משתמשים סופיים: מפתחים וארגונים שמשתמשים ב-MCP באפליקציות שלהם
- תורמים: חברי קהילה שתורמים קוד, תיעוד או משאבים אחרים
- לקוחות MCP - רשימה של לקוחות התומכים באינטגרציות MCP
- שרתים קהילתיים של MCP - רשימה מתפתחת של שרתים שפותחו על ידי הקהילה
- שרתים מצוינים של MCP - רשימה נבחרת של שרתי MCP
- PulseMCP - מרכז קהילתי ועלון גיליון לגילוי משאבים של MCP
- שרת דיסקורד - התחברו עם מפתחי MCP
- מימושי SDK לשפות שונות
- פוסטים בבלוג וסרטוני הדרכה
האקו-סיסטם של MCP מקבל בברכה סוגים שונים של תרומות:
-
תרומות קוד:
- שיפורים בפרוטוקול הליבה
- תיקוני באגים
- יישומי כלים ושרתים
- ספריות לקוח/שרת בשפות שונות
-
תיעוד:
- שיפור תיעוד קיים
- יצירת הדרכות ומדריכים
- תרגום תיעוד
- יצירת דוגמאות ואפליקציות לדוגמה
-
תמיכה בקהילה:
- מענה לשאלות בפורומים ובדיונים
- בדיקות ודיווח על בעיות
- ארגון אירועים קהילתיים
- חונכות לתורמים חדשים
כדי לתרום לפרוטוקול הליבה של MCP או ליישומים הרשמיים, עקוב אחרי העקרונות מתוך הנחיות התרומה הרשמיות:
-
פשטות ומינימליזם: מפרט MCP מכתיב רף גבוה להוספת מושגים חדשים. קל יותר להוסיף דברים למפרט מאשר להסיר.
-
גישה קונקרטית: שינויים במפרט צריכים להתבסס על אתגרים יישומיים ספציפיים, לא על ספקולציות.
-
שלבי הצעת פתרון:
- הגדרה: חקר את הבעיה, ואימות שיתר משתמשי 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;
}# דוגמת תרומה: כלי לעיבוד נתוני CSV לספריית הסטנדרט 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:
# חילוץ פרמטרים
operation = request.parameters.get("operation")
output_format = request.parameters.get("outputFormat", "json")
# קבלת נתוני CSV מגליון ישיר או כתובת URL
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:
- התחל קטן: התחל בתיעוד, תיקוני באגים, או שיפורים קטנים
- עקוב אחר מדריך הסגנון: שמור על סגנון קוד וקונבנציות הפרויקט
- כתוב בדיקות: כלל בדיקות יחידה לתרומות הקוד שלך
- תעד את עבודתך: הוסף תיעוד ברור לתכונות חדשות או שינויים
- הגש בקשות משיכה ממוקדות: שמור על בקשות משיכה ממוקדות לסוגיה או תכונה אחת
- שיתוף פעולה עם משוב: היה תגובתי למשוב על התרומות שלך
# שכפול המאגר
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:
-
SDK רשמיים (תואמים עם מפרט MCP 2025-11-25):
-
מסגרות קהילתיות:
- MCP-Framework - בניית שרתי MCP ביופי ומהירות ב-TypeScript
- MCP Declarative Java SDK - שרתי MCP מונעי אנוטציות עם Java
- Quarkus MCP Server SDK - מסגרת Java לשרתי MCP
- Next.js MCP Server Template - פרויקט התחלה ב-Next.js לשרתי 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// קובץ תצורה pom.xml לחבילת כלי MCP שניתן לשתף
<!--
<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:
# mcp_nlp_tools/
# ├── רישיון
# ├── קובץ 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 מאובטחים ואימות
- אמת ונקה קלטים
- יישם הגבלת קצב לקריאות חיצוניות
-
בדיקות:
- כלל כיסוי בדיקות מקיף
- בדוק עם סוגי קלט שונים ומקרים קיצוניים
- תעד את נהלי הבדיקה
שיתוף פעולה אפקטיבי הוא מפתח לאקוסיסטם MCP משגשג.
- נושאים ודיונים ב-GitHub
- קהילת Microsoft Tech
- ערוצי Discord ו-Slack
- Stack Overflow (תג:
model-context-protocolאו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 והקם סביבת פיתוח מקומית
- צור שיפור קטן, תיקון באג, או כלי שישפר את הקהילה
- תעד את תרומתך עם בדיקות ותיעוד נאותים
- הגש בקשת משיכה למאגר המתאים
הבא: שיעורים מאימוץ מוקדם
כתב ויתור:
מסמך זה תורגם באמצעות שירות תרגום מבוסס בינה מלאכותית Co-op Translator. אף שאנו שואפים לדיוק, יש לזכור כי תרגומים אוטומטיים עלולים להכיל שגיאות או אי-דיוקים. המסמך המקורי בשפת המקור שלו הוא המקור הרשמי והמהימן. למידע קריטי מומלץ להשתמש בתרגום מקצועי של אדם. איננו נושאים באחריות על כל אי הבנות או פרשנויות שגויות הנובעות מהשימוש בתרגום זה.