Ana içeriğe geç

Model Context Protocol aslında neyi standartlaştırıyor

· 7 dakikalık okuma

Her yapay zekâ uygulaması aynı şeylere ulaşmak istiyor: repository, issue tracker, bir veritabanı, dokümantasyon. Model Context Protocol'den önce bu bağlantıların her biri her uygulama için ayrı ayrı yazılıyordu. Bir editör için yapılmış entegrasyon, bir sonrakinde işe yaramıyordu.

MCP, tek bir entegrasyonun bu dili konuşan her uygulamada çalışmasını sağlayan bir uzlaşma. Etrafındaki gürültünün düşündürdüğünden çok daha küçük ve bence en iyi tarafı da bu. Bu yazı, MCP'nin gerçekte neyi sabitlediğini anlatıyor; hepsini spesifikasyonun güncel sürümüne, 2026-07-28 revizyonuna göre kontrol ettim.

N çarpı M problemi​

N tane yapay zekâ uygulaması ve M tane araç varken eski dünya N çarpı M entegrasyon gerektiriyordu. Her uygulamanın kendi plugin formatı vardı; her araç üreticisi birkaç uygulamayı seçip desteklemiş, gerisini görmezden gelmişti.

Ortak bir protokol bunu N artı M'ye indiriyor. Her uygulama client tarafını bir kez, her araç server tarafını bir kez yazıyor ve herhangi ikisi birbiriyle konuşabiliyor. Spesifikasyon fikrin nereden geldiğini açıkça söylüyor: aynı şeyi programlama dilleri ve editörler için yapan Language Server Protocol. Bir dil artık her editör için ayrı bir plugin yerine tek bir language server yayınlıyor.

Host, client ve server​

Spesifikasyon üç rol tanımlıyor ve aralarındaki fark ilk bakışta göründüğünden daha önemli.

  • Host, LLM uygulamasının kendisi: Claude Code, VS Code, Cursor, bir sohbet uygulaması. Konuşmayı tutan, modelle konuşan ve kullanıcıdan onay isteyen odur.
  • Client, host'un içindeki bir bağlantı. Her client tam olarak bir server ile konuşur; dört server'a bağlı bir host dört client çalıştırır.
  • Server, bağlam ve yetenek sağlar. Yerel bir process de olabilir, uzak bir servis de.

Spesifikasyondaki bir tasarım ilkesi bu şekli açıklıyor: server'lar konuşmanın tamamını okuyamamalı ve diğer server'ların içini görememeli. Geçmişi host tutar ve her server'a ne gideceğine o karar verir. Bir server yalnızca kendisine gönderilen istekleri görür.

Bir server'ın sunabileceği üç şey​

Bir server en fazla üç tür primitive sunar ve spesifikasyon her birinin kontrolünü farklı bir tarafa veriyor.

PrimitiveKontrol kimdeÖrnek
Tool'larModelBir sorgu çalıştırmak, issue açmak
Resource'larUygulamaDosya içeriği, bir şema, git geçmişi
Prompt'larKullanıcıBir iş akışını başlatan slash komutu

Tool'lar, modelin çağırmaya karar verdiği fonksiyonlar. Bir tool keyfî kod çalıştırabildiği için spesifikasyon, bir çağrıyı reddedebilecek bir insanın her zaman döngüde olması gerektiğini söylüyor. Client'ların "read-only" gibi tool annotation'larını, server güvenilir değilse güvenilmez kabul etmesi gerekiyor.

Resource'lar, bir URI ile tanımlanan veriler. Onları nasıl kullanacağına host karar verir: bir seçicide gösterebilir, kullanıcının eklemesine izin verebilir ya da otomatik olarak dahil edebilir.

Prompt'lar, kullanıcının bilerek seçtiği şablonlar; genellikle slash komutu olarak karşınıza çıkar.

Spesifikasyonun en faydalı bulduğum kısmı bu tablo. Bir server tasarlarken her özellik için ilk sorum, kontrolün kimde olması gerektiği. Kullanıcı seçmeliyse prompt, model karar vermeliyse tool.

Client'lar da server'lara özellik sunabiliyor. Güncel revizyonun koruduğu özellik elicitation: server'ın kullanıcıdan ek bilgi istemesi. Sampling ve roots hâlâ çalışıyor ama artık deprecated.

Altta JSON-RPC​

Her MCP mesajı UTF-8 ile kodlanmış bir JSON-RPC 2.0 isteği, cevabı ya da bildirimi. Bir tool çağrısı şöyle görünüyor:

{
"jsonrpc": "2.0",
"id": 7,
"method": "tools/call",
"params": {
"name": "convert_time",
"arguments": { "utc": "2026-10-11T09:00:00Z", "timeZone": "Europe/Istanbul" },
"_meta": {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientCapabilities": {}
}
}
}

Spesifikasyon iki tür hatayı birbirinden ayırıyor. Bilinmeyen bir tool ya da bozuk bir istek gibi protokol hataları sıradan JSON-RPC hatalarıdır. Yanlış formatta bir tarih gibi tool çalıştırma hataları ise isError: true ile normal bir sonuç olarak döner; client'ların bunu modele göstermesi gerekir ki model kendini düzeltip tekrar denesin. Bir server'ın faydasının büyük kısmı bu ikinci türde yatıyor.

İki transport​

Protokol her transport üzerinde aynı anlama geliyor. Spesifikasyon iki tane tanımlıyor.

stdio. Client, server'ı bir alt process olarak başlatır. Mesajlar stdin ve stdout üzerinde satır satır ayrılmış JSON'dır. Server stdout'a geçerli bir MCP mesajı olmayan hiçbir şey yazmamalı; log'lar stderr'e gider. Yerelde tek bir komutla kurduğunuz server'ların çoğu bunu kullanıyor.

Streamable HTTP. Server tek bir endpoint sunar ve client'tan gelen her mesaj yeni bir HTTP POST'tur. Server ya tek bir JSON nesnesiyle ya da o isteğe özel bir SSE stream'iyle cevap verir. Server'ların Origin header'ını doğrulaması zorunlu; yerelde çalışan bir server da bütün arayüzler yerine 127.0.0.1'e bağlanmalı. Eski HTTP+SSE transport'u deprecated.

Capability negotiation artık her istekte​

Önceki revizyonlarda her bağlantı bir initialize el sıkışmasıyla başlıyordu; client ve server burada bir protokol sürümünde anlaşıp capability'lerini paylaşıyordu. 2026-07-28 revizyonu bunu kaldırdı ve bu, güncel spesifikasyondaki en büyük değişiklik.

MCP artık stateless. Her istek, yukarıdaki örnekte olduğu gibi, protokol sürümünü ve client'ın capability'lerini _meta içinde taşıyor. Server'ların server/discover'ı uygulaması zorunlu; bu çağrı desteklenen protokol sürümlerini, capability'leri ve server'ın kimliğini döndürüyor. Client isterse önce onu çağırır, isterse doğrudan istek gönderip UnsupportedProtocolVersionError'ı ele alır. Protokol seviyesindeki session'lar ve Mcp-Session-Id header'ı Streamable HTTP'den kalktı. Çağrılar arasında state tutması gereken bir server kendi handle'ını üretiyor ve bu handle sıradan bir tool argümanı olarak geri gönderiliyor.

Bence doğru karar. Stateless bir server sıradan bir HTTP servisi: bir load balancer'ın arkasında durabilir, yeniden başlayabilir ve sticky session olmadan ölçeklenebilir.

C# ile bir server​

Resmî C# SDK'sı NuGet'teki ModelContextProtocol paketi. Onunla ve Microsoft.Extensions.Hosting ile bu, eksiksiz bir stdio server:

using System.ComponentModel;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ModelContextProtocol;
using ModelContextProtocol.Server;

var builder = Host.CreateApplicationBuilder(args);

// stdout protokole ait, bu yüzden bütün log satırları stderr'e gidiyor.
builder.Logging.AddConsole(o => o.LogToStandardErrorThreshold = LogLevel.Trace);

builder.Services
.AddMcpServer()
.WithStdioServerTransport()
.WithToolsFromAssembly();

await builder.Build().RunAsync();

[McpServerToolType]
public static class TimeTools
{
[McpServerTool(Name = "convert_time", ReadOnly = true)]
[Description("Convert a UTC time to local time in an IANA time zone.")]
public static string ConvertTime(
[Description("UTC time in ISO 8601, e.g. 2026-10-11T09:00:00Z")] DateTimeOffset utc,
[Description("IANA time zone id, e.g. Europe/Istanbul")] string timeZone)
{
if (!TimeZoneInfo.TryFindSystemTimeZoneById(timeZone, out var zone))
throw new McpException($"Unknown time zone '{timeZone}'. Use an IANA id such as Europe/Istanbul.");

return TimeZoneInfo.ConvertTime(utc, zone).ToString("yyyy-MM-dd HH:mm zzz");
}
}

WithToolsFromAssembly, [McpServerToolType] ile işaretlenmiş her sınıfı bulur ve her [McpServerTool] metodunu bir tool'a çevirir; açıklamalar ve parametrelerden üretilen bir input şeması da cabası. Exception'a dikkat: SDK, fırlatılan bir McpException'ı isError işaretli bir tool sonucu olarak ve mesajına dokunmadan döndürüyor; diğer exception'lar ise iç detaylar sızmasın diye genel bir mesaja dönüşüyor. Yani mesaj model için yazılıyor ve geçerli bir değerin neye benzediğini söylüyor.

MCP ne değildir​

Bir agent framework'ü değil. MCP'nin planlayıcısı, döngüsü, hafızası yok; hangi modeli kullandığınızla da ilgilenmiyor. Bir tool'u ne zaman çağıracağına ve sonuçla ne yapacağına host karar verir. MCP yalnızca host'un tool'a nasıl ulaşacağını tanımlar.

Tek başına güvenlik değil. Spesifikasyonda authorization isteğe bağlı. Kullanıldığında HTTP transport'ları için geçerli ve OAuth 2.1 üzerine kurulu; bir stdio server'ın credential'larını ortamdan alması bekleniyor. Geçerli bir token olsa bile authorization bir server'a kimin çağırdığını söyler, belirli bir çağrının akıllıca olup olmadığını değil. Onay, approval ve bir tool'un neye izinli olduğu host'un ve server'ın sorumluluğunda kalıyor.

İyi bir tool'un garantisi değil. Protokol, server ne sunuyorsa onu taşır. Bir REST API'yi endpoint endpoint kopyalayan bir server, JSON-RPC'si ne kadar doğru olursa olsun, model için kullanması zor bir server olmaya devam eder. Bunu ayrıca bir LLM'in doğru kullanabileceği tool'lar tasarlamak yazısında anlattım.

MCP'nin standartlaştırdığı şey fiş: roller, üç primitive ve kontrolün kimde olduğu, mesaj formatı, iki transport ve iki tarafın birbirinin neyi desteklediğini nasıl öğrendiği. Spesifikasyon bir akşamda okunacak kadar kısa ve onu okumak, hakkında yazılan her şeyin yarattığı kafa karışıklığından kurtulmanın en hızlı yolu.