Technical Tutorials

Model Bağlam Protokolü (MCP), yapay zeka modellerini harici veri kaynaklarına ve araçlara bağlamak için hızla bir standart haline gelmiştir. Referans uygulama standart HTTP ve WebSockets üzerinden JSON-RPC kullanırken, birçok üretim ortamı daha düşük gecikme, daha sıkı tipleme ve daha verimli veri serileştirmesi gerektirmektedir. İşte tam bu noktada, Google'ın açık kaynaklı yüksek performanslı uzak prosedür çağrısı çerçevesi olan gRPC devreye girer. MCP'yi gRPC üzerinde uygulayarak geliştiriciler, özellikle yüksek verimli veri akışları veya ikili varlıklarla uğraşırken önemli performans avantajlarının kilidini açabilir.

MCP İçin gRPC Neden Düşünülmeli?

Geleneksel HTTP/JSON uygulamaları, hata ayıklaması kolay olsa da, yüksek riskli yapay zeka ortamlarında çeşitli kısıtlamalardan mustarip:

Şişkinlik: JSON uzun boyludur. Görsel veriler veya kapsamlı kod bağlamları gibi büyük yükler için aşırı yük önemli ölçüdedir.
Ayrıştırma Maliyetleri: JSON ayrıştırma, ikili formatlara kıyasla hesaplamalı olarak pahalıdır.
Akış Verimliliği: Sunucu Tarafı Olaylar (SSE) mevcut olsa da, gRPC'nin yerleşik çift yönlü akışı, üstün geri basınç yönetimi ve verimlilik sunar.

gRPC, hem kompakt hem de hızlı ayrıştırılan ikili bir serileştirme formatı olan Protocol Buffers (protobuf) kullanır. Ayrıca, gRPC'nin güçlü tipleme özelliği, yapay zeka istemcisi ile bağlam sunucusu arasındaki arayüzün derleme zamanında titizlikle tanımlanmasını sağlayarak çalışma zamanı hatalarını azaltır.

Protocol Buffers ile Servisi Tanımlama

İlk adım, MCP arayüzünü .proto dosyalarında tanımlamaktır. Genel JSON nesneleri yerine, kaynaklar, istemler ve araçlar için belirli mesajlar tanımlarız.

syntax = "proto3";

package mcp.v1;

service ModelContextService {
  // Belirli bir kaynağı getir
  rpc ReadResource(ReadResourceRequest) returns (Resource);

  // Kullanılabilir araçları listele
  rpc ListTools(ListToolsRequest) returns (ListToolsResponse);

  // Bir aracı çalıştır ve sonuçları geri akıt
  rpc CallTool(CallToolRequest) returns (stream ToolResultChunk);
}

message ReadResourceRequest {
  string uri = 1;
}

message Resource {
  string uri = 1;
  string mime_type = 2;
  bytes content = 3; // Görseller gibi ikili verileri verimli bir şekilde işler
}

message ListToolsRequest {
  string client_id = 1;
}

message ListToolsResponse {
  repeated Tool tool = 1;
}

message Tool {
  string name = 1;
  string description = 2;
  string input_schema_json = 3; // Esneklik için şemayı JSON dizesi olarak tut
}

message CallToolRequest {
  string tool_name = 1;
  string arguments_json = 2;
}

message ToolResultChunk {
  bool is_final = 1;
  string text_chunk = 2;
  bytes binary_chunk = 3;
  bool is_error = 4;
  string error_message = 5;
}

Sunucu Tarafının Uygulanması

Sunucuyu uygulamak, .proto dosyasından istemci ve sunucu taslaklarını (stubs) üretmeyi içerir. Örneğin Python'da, kodu üretmek için grpcio-tools paketini kullanabilirsiniz.

import grpc
from concurrent import futures
import mcp_pb2
import mcp_pb2_grpc

class ModelContextServicer(mcp_pb2_grpc.ModelContextServiceServicer):
    def ReadResource(self, request, context):
        # Veritabanından veya dosya sisteminden kaynağı getirme mantığı
        data = b"Binary image data here"
        return mcp_pb2.Resource(
            uri=request.uri,
            mime_type="image/png",
            content=data
        )

    def CallTool(self, request, context):
        # Büyük bir yanıtın akıtılmasını simüle et
        chunks = ["Processing step 1...", "Processing step 2...", "Done!"]
        for i, text in enumerate(chunks):
            yield mcp_pb2.ToolResultChunk(
                is_final=(i == len(chunks) - 1),
                text_chunk=text
            )

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    mcp_pb2_grpc.add_ModelContextServiceServicer_to_server(ModelContextServicer(), server)
    server.add_insecure_port("[::]:50051")
    server.start()
    print("gRPC MCP Server running on port 50051")
    server.wait_for_termination()

if __name__ == '__main__':
    serve()

İstemci Entegrasyonu: Boşluğu Kapatma

LLM'in (Büyük Dil Modeli) bulunduğu istemci tarafında, entegrasyon katmanı modelin niyetini gRPC çağrılarına dönüştürür. Buradaki temel avantaj, asenkron akışları sorunsuz bir şekilde işleyebilme yeteneğidir. Bir LLM araç çalıştırması istediğinde, istemci, tüm işlemin tamamlanmasını beklemeden kısmi sonuçları model bağlamına geri akıtabilir.

Standart MCP kütüphanelerini kullanan geliştiriciler için, özel bir taşıma katmanı (transport layer) yazmanız gerekebilir. Bu katman, standart JSON-RPC isteklerini keser ve onları .proto dosyanızda tanımlanan ilgili gRPC yöntemlerine eşler. Bu soyutlama, temel yapay zeka uygulama mantığınızı temiz tutmanıza ve arka planda gRPC'nin performansından yararlanmanıza olanak tanır.

Performans Düşünceleri

Benchmark'larda, HTTP/JSON'dan gRPC/Protobuf'a geçiş genellikle şu sonuçları verir:

Yapılandırılmış veriler için ağ yük boyutunda %30-50 oranında azalma.
İkili serileştirmeden (deserialization) kaynaklanan %20 daha hızlı ayrıştırma süreleri.
Yüksek trafikli sunucularda daha düşük CPU kullanımı.

Sonuç

Standart HTTP tabanlı MCP uygulamaları birçok geliştirme ve test senaryosu için yeterli olsa da, gRPC'ye geçiş, üretim ölçeğinde yapay zeka sistemleri için stratejik bir seçimdir. Karmaşık, veri yoğun harici araçları büyük dil modelleriyle entegre ederken gerekli olan sağlamlığı, tipleme ve verimliliği sağlar. MCP ekosistemi olgunlaştıkça, alternatif taşıma katmanları için daha standart destek görmeyi ve yüksek performanslı gRPC uygulamalarının benimsemesinin daha kolay hale gelmesini bekleyebilirsiniz.