Anthropic tarafından 26 Kasım 2024'te tanıtılan Model Context Protocol (MCP), yapay zeka modelleri ile harici veri kaynakları arasındaki boşluğu kapatmayı amaçlayan açık bir standarttır. Bu protokol, kritik bir zorluğa değinmektedir: metin oluşturmada güçlü olsalar da, gelişmiş Büyük Dil Modelleri (LLM'ler) bile genellikle gerçek zamanlı verilerden ve araçlardan izole edilir, bu da pratik kullanımlarını sınırlar. MCP Sunucuları, ayrılmaz bileşenler olarak, Claude gibi yapay zeka asistanlarının dosyalara, veritabanlarına, API'lere ve daha fazlasına erişmesini sağlayarak, ilgili, eyleme geçirilebilir yanıtlar verme yeteneklerini artırır.
MCP'nin önemi, yapay zeka gelişimini kasıp kavuran parçalanmayı azaltarak entegrasyonları standartlaştırma potansiyelinde yatmaktadır. Evrensel bir protokol sağlayarak, bilgi silolarını ve eski sistem engellerini yıkarak, sınır modellerinin daha iyi, daha alakalı yanıtlar üretmesine yardımcı olmayı amaçlamaktadır.
25 Mart 2025 itibarıyla, ekosistem hızla büyümekte, topluluk katkıları ve Block ve Apollo gibi erken benimseyenlerin sistemlerine MCP'yi entegre etmesi gibi kurumsal benimsemelerle büyümektedir.
Bugün Apidog'u ücretsiz indirin ve iş akışınızı nasıl dönüştürebileceğini keşfedin!
MCP Sunucuları Nedir?
Model Context Protocol'ün (MCP) bir parçası olan MCP sunucuları, Anthropic'ten gelenler gibi yapay zeka modellerinin harici verilere ve araçlara bağlanmasına ve bunları kullanmasına yardımcı olan özel programlardır. Kasım 2024'te tanıtılan bu sunucular, yapay zekanın, bilgisayarınızdaki dosyalar, veritabanları ve hatta GitHub gibi hizmetler gibi şeylere erişerek, yalnızca metin üretmekten daha fazlasını yapmasını sağlar; hepsi güvenli ve standartlaştırılmış bir şekilde.
MCP sunucularını, yapay zekanın dış dünyayla etkileşim kurmasını sağlayan köprüler olarak düşünün; tıpkı USB portlarının farklı cihazları bilgisayarınıza takmanıza izin vermesi gibi. Örneğin, bir yapay zekadan bir belgeyi özetlemesini isterseniz, dosyayı doğrudan sisteminizden çekebilir. Veya bir GitHub sorunu oluşturmanız gerekiyorsa, yapay zeka bunu da bir MCP sunucusu sayesinde yapabilir. Veri (dosyalar gibi), araçlar (API çağrıları gibi) veya istemler (etkileşim için kılavuzlar) sağlayabilirler ve yapay zekayı kodlama, araştırma veya proje yönetimi gibi görevler için daha kullanışlı hale getirirler.
Beklenmedik bir ayrıntı, topluluğun ne kadar hızlı büyüdüğü, hem resmi entegrasyonlar hem de topluluk katkıları dahil olmak üzere 250'den fazla sunucu mevcut ve hızla genişleyen canlı bir ekosistem gösteriyor.
MCP Sunucularının Çalışma Şekli (Ve API'lerden Nasıl Farklıdırlar)
MCP, belgede özetlendiği gibi bir istemci-sunucu modeli üzerinde çalışır. Mimari şunları içerir:
- MCP Ana Bilgisayarları: Claude Desktop, IDE'ler veya harici verilerden yararlanmak isteyen yapay zeka araçları gibi uygulamalar.
- MCP İstemcileri: Sunucularla güvenli, bire bir bağlantıları koruyan, verimli iletişimi sağlayan protokol istemcileri.
- MCP Sunucuları: Her biri standartlaştırılmış Model Context Protocol aracılığıyla belirli yetenekleri ortaya koyan hafif programlar. Bu yapı, ana bilgisayarların çeşitli sunuculara bağlanmak için istemcileri kullanmasıyla, her biri benzersiz işlevler sunan, kesintisiz entegrasyona olanak tanır. Protokol üç ana maruz kalma türünü destekler:
- Kaynaklar: Yapay zekanın bağlamına yükleyebileceği dosyalar, belgeler veya veritabanı sorguları gibi veri kaynakları. Örneğin, bir dosya sistemi sunucusu yerel belgelere erişime izin verebilir.
- Araçlar: Yapay zekanın yapabileceği eylemler, örneğin API çağrıları yapmak veya komutları yürütmek. Bir örnek, aynı depoda ayrıntılı olarak açıklanan, depo yönetimini sağlayan bir GitHub sunucusudur.
- İstemler: LLM etkileşimleri için yeniden kullanılabilir şablonlar, yapay zekanın belirli senaryolardaki davranışına rehberlik eder.
Protokol, istemciler ve sunucular arasında durum bilgisi olan bağlantıları ve yetenek müzakeresini sağlayan JSON-RPC 2.0'a dayanmaktadır. Bu teknik temel, ilerleme takibi, iptal ve hata raporlama gibi özelliklerle güvenilirliği artıran sağlam, güvenli iletişime olanak tanır.
Peki, MCP'ler Aslında Ne Yapabilir?
MCP sunucuları çok yönlü olacak şekilde tasarlanmıştır ve çok çeşitli ihtiyaçları karşılar. Uygulamaya bağlı olarak yerel veya uzaktan çalıştırılabilirler ve öncelikle güvenlik ilkeleriyle oluşturulmuştur. Her sunucu, yetkisiz erişimi önlemek için net sistem sınırlarını koruyarak kendi kaynaklarını kontrol eder.
Bu güvenlik, özellikle hassas verilerle uğraşırken, bağlantıların güvenli olmasını ve izinlerin sıkı bir şekilde yönetilmesini sağlamak için çok önemlidir.
Teknik olarak, sunucular yeteneklerini JSON-RPC uç noktaları aracılığıyla ortaya koyar ve istemcilerin mevcut kaynakları, araçları ve istemleri sorgulamasına olanak tanır.
Örneğin, bir sunucu, belirtilen bir dosyanın içeriğini döndüren bir "readFile" kaynağı veya GitHub'ın API'siyle etkileşim kuran bir "createIssue" aracı sunabilir. Protokol ayrıca, belirtildiği gibi, özyinelemeli ve dinamik olabilen, aracılık eden yapay zeka etkileşimlerini sağlayan örnekleme gibi sunucu tarafından başlatılan davranışları da destekler.
MCP Sunucularıyla İlgileniyor musunuz? Bunları Şimdi Deneyebilirsiniz
MCP sunucularının ekosistemi zengin ve büyüyor, faydalarını gösteren çok sayıda örnek var, GitHub - awesome-mcp-servers adresindeki depoda listelendiği gibi:
- Dosya Sistemi MCP Sunucusu: Yapay zekanın dosyaları okumasını ve yazmasını sağlar, kişisel notlara veya komut dosyalarına erişmek için kullanışlıdır, GitHub - filesystem adresindeki referans uygulamasında görüldüğü gibi.
- GitHub MCP Sunucusu: Sorun oluşturma veya kod gönderme gibi etkileşimleri kolaylaştırır, geliştirici iş akışlarını geliştirir, GitHub - github adresinde ayrıntılı olarak açıklanmıştır.
- Web Kazıma MCP Sunucusu: Yapay zekanın web içeriğini aramasına ve çıkarmasına olanak tanır, gerçek zamanlı veri sağlar, tavily-ai/tavily-mcp gibi topluluk sunucularında belirtildiği gibi.
- Veritabanı MCP Sunucuları: PostgreSQL veya MongoDB gibi SQL veya NoSQL veritabanlarına erişim sunar, veri sorgularını etkinleştirir, GitHub - postgres adresinde görüldüğü gibi.
- API Entegrasyon MCP Sunucuları: Yapay zekanın bilgi tabanını genişleterek Slack, Trello veya hava durumu API'leri gibi hizmetlere bağlanır, GitHub - slack gibi örneklere sahiptir. Bu sunucular, GitHub - servers adresindeki üçüncü taraf sunucularında listelendiği gibi, Kubernetes yönetim sunucuları gibi topluluk katkılarıyla ekosisteme eklenen protokolün esnekliğini gösterir.
MCP Sunucusu ve API'ler Arasındaki Fark Nedir?
Hem MCP sunucuları hem de geleneksel API'ler, yazılımın harici hizmetlerle etkileşim kurmasına izin verirken, amaçları yapay zeka bağlamında farklıdır:
- Amaç: Geleneksel API'ler, yazılım iletişimi için genel amaçlı arayüzlerdir ve genellikle yapay zeka modellerine sorgu göndermek veya harici hizmetlere erişmek için kullanılır. MCP sunucuları, yapay zeka modellerine standartlaştırılmış bir biçimde veri, araç ve istemler üzerinde odaklanarak bağlam sağlamak için özel olarak tasarlanmıştır.
- Etkileşim: Geleneksel bir API ile, yapay zeka modelinin API'yi nasıl çağıracağını, yanıtını nasıl ayrıştıracağını ve bu bilgiyi bağlamına nasıl entegre edeceğini bilmesi gerekir. Bir MCP sunucusu ile, sunucu veri kaynağı veya araçla etkileşimi yönetir ve bilgileri, temel veri kaynağının ayrıntılarını bilmeye gerek kalmadan, yapay zeka modelinin kolayca anlayabileceği ve kullanabileceği bir şekilde sunar.
- Standardizasyon: MCP, çeşitli sunucular için tak ve çalıştır hale getiren standartlaştırılmış bir protokol sağlar; geleneksel API'ler ise her hizmet için özel entegrasyon gerektirebilir.
- Güvenlik: MCP sunucuları, yerleşik kimlik doğrulama ve erişim kontrolleri ile güvenlik için optimize edilmiştir; geleneksel API'ler ise uygulamaya bağlı olarak ek güvenlik önlemleri gerektirebilir.
Örneğin, geleneksel bir kurulumda, yapay zeka hava durumu verilerini almak, JSON yanıtlarını ayrıştırmak ve bunları bağlamına entegre etmek için bir REST API'sini çağırması gerekebilir. Bir MCP sunucusu ile, sunucu bir "get_weather" aracı sunabilir ve yapay zeka bunu parametrelerle çağırarak kullanıma hazır biçimlendirilmiş verileri alır.
MCP Sunucuları Nasıl Kurulur (Örnek Olarak Claude ile)
Model Context Protocol (MCP),
MCP sunucuları üç ana yetenek türü sağlayabilir:
- Kaynaklar: İstemciler tarafından okunabilen dosya benzeri veriler (API yanıtları veya dosya içerikleri gibi)
- Araçlar: LLM tarafından çağrılabilen işlevler (kullanıcı onayı ile)
- İstemler: Kullanıcıların belirli görevleri tamamlamasına yardımcı olan önceden yazılmış şablonlar
Ortamınızı Kurma
Başlamadan önce, şunlara sahip olduğunuzdan emin olun:
- Python 3.10 veya üzeri yüklü
- Node.js (JavaScript/TypeScript uygulamaları kullanılıyorsa)
- Python veya JavaScript programlamaya temel aşinalık
- Claude gibi LLM'ler hakkında bilgi
UV Paket Yöneticisini Yükleme
UV, Python MCP projeleri için önerilen paket yöneticisidir:
# MacOS/Linux
curl -LsSf <https://astral.sh/uv/install.sh> | sh
# Ardından terminalinizi yeniden başlattığınızdan emin olun
Bir MCP Sunucusu Oluşturma
Örnek olarak basit bir hava durumu sunucusu oluşturalım.
Bu sunucu iki araç sağlayacaktır: get-alerts ve get-forecast.
Adım 1: Proje Yapısını Kurun
# Projemiz için yeni bir dizin oluşturun
uv init weather
cd weather
# Sanal ortam oluşturun ve etkinleştirin
uv venv
source .venv/bin/activate # On Windows: .venv\\\\Scripts\\\\activate
# Bağımlılıkları yükleyin
uv add "mcp[cli]" httpx
# Sunucu dosyamızı oluşturun
touch weather.py
Adım 2: Sunucuyu Uygulayın
İşte hava durumu sunucumuzun (weather.py içinde) eksiksiz bir uygulaması:
from typing import Any
import httpx
from mcpserver.fastmcp import FastMCP
# FastMCP sunucusunu başlat
mcp = FastMCP("weather")
# Sabitler
NWS_API_BASE = "<https://api.weather.gov>"
USER_AGENT = "weather-app/1.0"
async def make_nws_request(url: str) -> dict[str, Any] | None:
"""Uygun hata işleme ile NWS API'sine bir istekte bulunun."""
headers = {
"User-Agent": USER_AGENT,
"Accept": "application/geo+json"
}
async with httpx.AsyncClient() as client:
try:
response = await client.get(url, headers=headers, timeout=30.0)
response.raise_for_status()
return response.json()
except Exception:
return None
def format_alert(feature: dict) -> str:
"""Bir uyarı özelliğini okunabilir bir dizeye biçimlendirin."""
props = feature["properties"]
return f"""
Olay: {props.get('event', 'Bilinmiyor')}
Alan: {props.get('areaDesc', 'Bilinmiyor')}
Ciddiyet: {props.get('severity', 'Bilinmiyor')}
Açıklama: {props.get('description', 'Açıklama mevcut değil')}
Talimatlar: {props.get('instruction', 'Belirli bir talimat verilmedi')}
"""
@mcp.tool()
async def get_alerts(state: str) -> str:
"""Bir ABD eyaleti için hava durumu uyarılarını alın.
Argümanlar:
state: İki harfli ABD eyalet kodu (örneğin, CA, NY)
"""
url = f"{NWS_API_BASE}/alerts/active/area/{state}"
data = await make_nws_request(url)
if not data or "features" not in data:
return "Uyarılar alınamadı veya uyarı bulunamadı."
if not data["features"]:
return "Bu eyalet için aktif uyarı yok."
alerts = [format_alert(feature) for feature in data["features"]]
return "\\\\n---\\\\n".join(alerts)
@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
"""Bir konum için hava durumu tahminini alın.
Argümanlar:
latitude: Konumun enlemi
longitude: Konumun boylamı
"""
# İlk olarak tahmin ızgara uç noktasını alın
points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
points_data = await make_nws_request(points_url)
if not points_data:
return "Bu konum için tahmin verileri alınamadı."
# Tahmin URL'sini nokta yanıtından alın
forecast_url = points_data["properties"]["forecast"]
forecast_data = await make_nws_request(forecast_url)
if not forecast_data:
return "Ayrıntılı tahmin alınamadı."
# Dönemleri okunabilir bir tahmine biçimlendirin
periods = forecast_data["properties"]["periods"]
forecasts = []
for period in periods[:5]: # Yalnızca sonraki 5 dönemi göster
forecast = f"""
{period['name']}: Sıcaklık: {period['temperature']}°{period['temperatureUnit']}
Rüzgar: {period['windSpeed']} {period['windDirection']}
Tahmin: {period['detailedForecast']}
"""
forecasts.append(forecast)
return "\\\\n---\\\\n".join(forecasts)
if __name__ == "__main__":
# Sunucuyu başlatın ve çalıştırın
mcp.run(transport='stdio')
Adım 3: Sunucunuzu Çalıştırın
Sunucunuzu doğrudan test etmek için şunu çalıştırın:
uv run weather.py
Claude for Desktop'a Bağlanma
Claude for Desktop, MCP sunucularınızla etkileşim kurmanın basit bir yoludur.
Adım 1: Claude for Desktop'u Yükleyin
Claude for Desktop'un yüklü ve en son sürüme güncellenmiş olduğundan emin olun.
Adım 2: Claude for Desktop'u Yapılandırın
- Claude for Desktop Uygulama yapılandırmanızı bir metin düzenleyicide açın:
# macOS
code ~/Library/Application\\\\ Support/Claude/claude_desktop_config.json
2. Sunucu yapılandırmanızı ekleyin:
{
"mcpServers": {
"weather": {
"command": "uv",
"args": [
"--directory",
"/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather",
"run",
"weather.py"
]
}
}
}
Şunlardan emin olun:
- Sunucu dizininize mutlak yolu kullanın
- Komutun ortamınızla eşleştiğinden emin olun (örneğin,
uvveyauv'ye giden tam yol)
Adım 3: Claude for Desktop'u Yeniden Başlatın
Yapılandırmayı kaydettikten sonra, Claude for Desktop'u tamamen yeniden başlatın.
Adım 4: Sunucunuzu Test Edin
Claude for Desktop giriş kutusunun sağ alt köşesindeki çekiç simgesini arayın. Ona tıklamak, sunucunuzun araçlarını göstermelidir.
Artık Claude'a şu gibi sorular sorabilirsiniz:
- "Sacramento'da hava nasıl?"
- "Teksas'taki aktif hava durumu uyarıları nelerdir?"
Claude MCP Sunucuları için Özel Bir MCP İstemcisi Oluşturma
Claude for Desktop kullanmak yerine, kendi özel istemcinizi oluşturabilirsiniz.
Adım 1: İstemci Projesini Kurun
# Proje dizini oluşturun
uv init mcp-client
cd mcp-client
# Sanal ortam oluşturun
uv venv
source .venv/bin/activate # On Windows: .venv\\\\Scripts\\\\activate
# Gerekli paketleri yükleyin
uv add mcp anthropic python-dotenv
# Ana dosyamızı oluşturun
touch client.py
Adım 2: API Anahtarınızı Kurun
Anthropic API anahtarınızla bir .env dosyası oluşturun:
ANTHROPIC_API_KEY=<buraya anahtarınız>
Adım 3: İstemciyi Uygulayın
İşte temel bir istemci uygulaması (client.py içinde):
import asyncio
import sys
from typing import Optional
from contextlib import AsyncExitStack
from mcp.client.stdio import ClientSession, StdioServerParameters, stdio_client
from anthropic import Anthropic
from dotenv import load_dotenv
load_dotenv() # .env dosyasından ortam değişkenlerini yükleyin
class MCPClient:
def __init__(self):
# Oturumu ve istemci nesnelerini başlatın
self.session: Optional[ClientSession] = None
self.exit_stack = AsyncExitStack()
self.anthropic = Anthropic()
async def connect_to_server(self, server_script_path: str):
"""Bir MCP sunucusuna bağlanın
Argümanlar:
server_script_path: Sunucu komut dosyasına giden yol (py veya js)
"""
is_python = server_script_path.endswith('.py')
is_js = server_script_path.endswith('.js')
if not (is_python or is_js):
raise ValueError("Sunucu komut dosyası bir .py veya .js dosyası olmalıdır")
command = "python" if is_python else "node"
server_params = StdioServerParameters(command=command, args=[server_script_path], env=None)
stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
self.stdio, self.write = stdio_transport
self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
await self.session.initialize()
# Mevcut araçları listeleyin
response = await self.session.list_tools()
tools = response.tools
print("\\\\nSunucuya bağlandı, araçlar:", [tool.name for tool in tools])
async def process_query(self, query: str) -> str:
"""Claude ve mevcut araçları kullanarak bir sorguyu işleyin"""
messages = [
{
"role": "user",
"content": query
}
]
response = await self.session.list_tools()
available_tools = [{
"name": tool.name,
"description": tool.description,
"input_schema": tool.input_schema
} for tool in response.tools]
# İlk Claude API çağrısı
response = self.anthropic.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1000,
messages=messages,
tools=available_tools
)
# Yanıtı işleyin ve araç çağrılarını yönetin
final_text = []
assistant_message_content = []
for content in response.content:
if content.type == 'text':
final_text.append(content.text)
assistant_message_content.append(content)
elif content.type == 'tool_use':
tool_name = content.name
tool_args = content.input
# Araç çağrısını yürütün
result = await self.session.call_tool(tool_name, tool_args)
final_text.append(f"[Araç çağrılıyor {tool_name} argümanlarla {tool_args}]")
assistant_message_content.append(content)
messages.append({
"role": "assistant",
"content": assistant_message_content
})
messages.append({
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": content.id,
"content": result
}
]
})
# Claude'dan sonraki yanıtı alın
response = self.anthropic.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1000,
messages=messages,
tools=available_tools
)
final_text.append(response.content[0].text)
return "\\\\n".join(final_text)
async def chat_loop(self):
"""Etkileşimli bir sohbet döngüsü çalıştırın"""
print("\\\\nMCP İstemcisi Başlatıldı!")
print("Sorgularınızı yazın veya çıkmak için 'quit' yazın.")
while True:
try:
query = input("\\\\nSorgu: ").strip()
if query.lower() == 'quit':
break
response = await self.process_query(query)
print("\\\\n" + response)
except Exception as e:
print(f"\\\\nHata: {str(e)}")
async def cleanup(self):
"""Kaynakları temizleyin"""
await self.exit_stack.aclose()
async def main():
if len(sys.argv) < 2:
print("Kullanım: python client.py <sunucu_komut_dosyasına_giden_yol>")
sys.exit(1)
client = MCPClient()
try:
await client.connect_to_server(sys.argv[1])
await client.chat_loop()
finally:
await client.cleanup()
if __name__ == "__main__":
asyncio.run(main())
Adım 4: İstemciyi Çalıştırın
İstemcinizi hava durumu sunucunuzla kullanmak için:
uv run client.py /path/to/weather.py
Claude for Desktop ile Önceden Oluşturulmuş MCP Sunucularını Kullanma
Claude for Desktop, çeşitli önceden oluşturulmuş MCP sunucularını destekler. Örnek olarak bir dosya sistemi sunucusunun nasıl kullanılacağını görelim.
Adım 1: Dosya Sistemi Sunucusunu Yapılandırın
- Claude for Desktop ayarlarını açın ve "Yapılandırmayı Düzenle"ye tıklayın
- Yapılandırma dosyanızı şunlarla güncelleyin:
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/username/Desktop",
"/Users/username/Downloads"
]
}
}
}
username'i gerçek kullanıcı adınızla değiştirin ve yolları gerektiği gibi ayarlayın.
Adım 2: Yeniden Başlatın ve Test Edin
Claude for Desktop'u yeniden başlattıktan sonra, dosya sistemi araçlarını şunlar için kullanabilirsiniz:
- Dosyaları okuyun
- Dosyaları yazın
- Dosyaları arayın
- Dosyaları taşıyın
Örnek istemler:
- "Bir şiir yazıp masaüstüme kaydedebilir misin?"
- "İndirme klasörümdeki işle ilgili bazı dosyalar nelerdir?"
- "Masaüstümdeki tüm görüntüleri alıp 'Görüntüler' adlı yeni bir klasöre taşıyabilir misin?"
Sonuç
MCP sunucuları, güçlü dil modelleri ile harici araçlar arasındaki boşluğu kapatarak yapay zeka işlevselliğinde önemli bir ilerlemeyi temsil eder. Bu kılavuzu izleyerek, Claude'un yeteneklerini geliştirmek için MCP sunucularının nasıl oluşturulacağını, yapılandırılacağını ve kullanılacağını öğrendiniz.
Model Context Protocol'ün standartlaştırılmış yaklaşımı, yapay zeka modellerinin gerçek zamanlı verilere erişebilmesini, eylemler gerçekleştirebilmesini ve sistemlerle güvenli, kontrollü bir şekilde etkileşim kurabilmesini sağlar. Bu, yapay zeka asistanlarını geliştirme, veri analizi, içerik oluşturma ve daha fazlası genelinde gerçek dünya uygulamaları için daha pratik hale getirir.
MCP ekosistemi büyümeye devam ettikçe, geliştiriciler yapay zekayla mümkün olanları genişleten giderek daha gelişmiş sunucular oluşturuyor. Önceden oluşturulmuş sunucular kullanıyor veya özel çözümler geliştiriyor olsanız da, MCP daha yetenekli yapay zeka uygulamaları oluşturmak için esnek bir temel sağlar.
Genellikle API entegrasyonlarını içeren MCP sunucularıyla çalışmaya devam ederken, MCP uygulamanızın iş akışını tamamlayabilen kapsamlı bir API geliştirme platformu olan Apidog'u keşfetmek isteyebilirsiniz.
