Yapay Zekanın Evrensel Arabirimi: Model Context Protocol (MCP) ve Sıfırdan Özel MCP Sunucusu Geliştirme

Giriş: LLM'lerin Entegrasyon Çıkmazı ve Standardizasyon İhtiyacı

Büyük Dil Modelleri (LLM'ler), doğal dili anlama ve üretme konusunda muazzam bir yetkinliğe ulaştı. Ancak bir yapay zeka modelinin ne kadar zeki olursa olsun izolasyon içinde kaldığı sürece etkisi, eğitim verisiyle veya ona sağlanan statik bağlamla sınırlıdır. Günümüz yapay zeka mimarilerinde asıl kırılma noktası, bu modelleri dış dünyadaki veri kaynaklarıyla, kurumsal veri tabanlarıyla ve canlı API'lerle güvenli, dinamik ve sürdürülebilir bir biçimde konuşturabilmekten geçiyor.

Yakın zamana kadar yapay zeka sistemlerinde harici araç ve veri kaynak entegrasyonu ciddi bir mühendislik yükü getiriyordu. Bir LLM'i GitHub, Slack, Supabase veya yerel dosya sisteminize bağlamak istediğinizde, her bir servis için özel olarak hazırlanmış API entegrasyon kodları yazmanız, her yeni servis güncellemesinde entegrasyonları revize etmeniz ve modeller değiştikçe kod tabanını baştan kurgulamanız gerekiyordu. "Her yeni uç nokta (endpoint) için ayrı kod yazma" mecburiyeti, sistemlerin ölçeklenebilirliğini düşürürken bakım maliyetlerini hızla artırıyordu.

Önemli Not: Tam da bu entegrasyon karmaşasının ortasında, Model Context Protocol (MCP) sektöre bir standardizasyon getirmek üzere Anthropic tarafından açık kaynaklı bir protokol olarak tanımlandı.

MCP'yi yapay zeka ekosisteminde tanımlamak için kullanılan en isabetli analoji "LLM'lerin USB-C veya USB Girişi" olmasıdır. Nasıl ki USB standardı hayatımıza girmeden önce bilgisayarımıza bağlayacağımız her çevre birimi (klavye, yazıcı, harici disk) için farklı bir konektör ve sürücü mimarisi gerekliyorduysa, MCP öncesindeki yapay zeka entegrasyonları da benzer şekilde parçalı ve özelleştirilmiş durumdaydı. MCP, yapay zeka modelleri ile harici veri sağlayıcıları arasında evrensel, tak-çalıştır (plug-and-play) mantığında açık bir iletişim dili inşa eder.

Bu protokol sayesinde yapay zeka modeli (Client/Host), bağlanacağı sunucunun (MCP Server) arka planda hangi API dokümantasyonuna sahip olduğunu, servis sağlayıcının kodlarında nasıl güncellemeler yapıldığını veya hangi endpoint'lerin değiştiğini detaylıca bilmek zorunda kalmaz. İletişim, MCP katmanının sunduğu ortak şema üzerinden gerçekleştiği için veri kaynağındaki revizyonlar veya model değişiklikleri entegrasyonu bozmaz.

Sonuç olarak MCP, yapay zeka sistemlerini basit kod tamamlama araçları olmaktan çıkarıp harici dünyada aksiyon alabilen, bağımsız kararlar verebilen ve kurumsal veri ekosistemine sorunsuz entegre olabilen otonom yapay zeka ajanlarına (Agentic AI) dönüştüren kritik bir mimari standarttır.

Bölüm 1: Geleneksel API Mimarisi vs. Model Context Protocol (MCP)

Yapay zeka sistem mimarilerinde otonom araç kullanımı (Tool Use / Function Calling) uzun süredir doğrudan RESTful veya GraphQL API istekleri üzerinden yönetiliyordu. Ancak bu geleneksel yaklaşım, sistemler karmaşıklaştıkça belirgin mimari darboğazlar ve bakım yükleri getirmeye başladı. MCP'nin sunduğu paradigma değişimini anlayabilmek için öncelikle klasik entegrasyon yöntemlerinin sınırlarını ve MCP'nin getirdiği katmanlı soyutlama yapısını teknik bir derinlikle incelemek gerekir.

Klasik API Yaklaşımının Sınırları ve Mimari Darboğazlar

Geleneksel API entegrasyonlarında yapay zeka modeli ile dış dünya arasındaki iletişim, modele ilgili API'nin şemasının (OpenAPI/Swagger şemaları gibi) istem alanı (prompt context) içinde sunulması ve modelden üretilen JSON çıktısının uygulama katmanında ayrıştırılarak ilgili uç noktaya (endpoint) manuel olarak POST, PUT veya GET istekleriyle iletilmesi esasına dayanır. Bu yaklaşım basit ölçekli sistemlerde iş görse de kurumsal ölçekte şu temel problemlerle karşılaşır:

Sıkı Bağlılık (Tightly Coupled Architecture) ve Bakım Yükü: Veri sağlayıcı tarafındaki (örneğin GitHub, Slack veya bir CRM platformu) en ufak bir uç nokta güncellemesi, parametre ismi değişikliği veya versiyon yükseltmesi, model tarafında yazılan tüm entegrasyon kodlarının kırılmasına yol açar. Geliştirici ekibin her bir entegrasyon uç noktası için sürekli revizyon yapması ve kod tabanını yenilemesi gerekir.
Ölçeklenememezlik ve Karmaşıklık Artışı: Sistem bünyesine eklenen her yeni servis (GitHub, PostgreSQL, Jira, Web Scraper vb.), modele sunulması gereken parametre ve şema karmaşıklığını katlanarak artırır. Modelin bağlam penceresi (context window) gereksiz API dokümantasyonlarıyla dolar ve bu durum hem yanıt verme süresini (latency) hem de maliyetleri olumsuz etkiler.
Model Bağımlılığı ve Yeniden Yazım Zorunluluğu: Kullanılan yapay zeka modeli değiştirildiğinde (örneğin OpenAI modellerinden Anthropic Claude veya yerel bir açık kaynak modele geçildiğinde), işlev çağırma (function calling) yapıları modeller arasında farklılık gösterdiği için entegrasyon katmanının yeniden kurgulanması gerekir.

MCP Yaklaşımının Çözümü: Üç Temel İlke Üzerinden Soyutlama

Model Context Protocol (MCP), istemci (Client) ile veri sağlayıcı (Server) arasına standart bir iletişim protokol katmanı yerleştirerek bu bağımlılığı ortadan kaldırır. Yapay zeka modeli artık dış servisin REST API dokümantasyonunu bilmek veya API çağrısını manuel kurgulamak zorunda kalmaz.

MCP, veri kaynaklarını ve işlevsellikleri üç temel soyutlama ilkesi üzerinden sunar:

1. Tools (Araçlar): Yapay zeka modelinin harici sistemler üzerinde aksiyon almasını ve yan etkileri olan (side-effect) işlemleri yürütmesini sağlayan fonksiyonel yapılardır. Örneğin; bir veritabanına kayıt eklemek, bir GitHub reposunda Pull Request (PR) açmak veya WhatsApp üzerinden mesaj iletmek birer Tool tanımıdır. Model, bu fonksiyonların iç mantığını (implementation details) bilmez; yalnızca adını, açıklamasını ve beklediği girdi şemasını görerek protokol üzerinden çağrı yapar.
2. Resources (Kaynaklar): Modelin pasif olarak okuma yapabileceği, veri ve bağlam sağlayan yapılardır. Dosya sistemi içerikleri, veritabanı şemaları, uygulama logları veya API'den gelen yanıtlar birer Resource olarak tanımlanır. Model, herhangi bir yan etki oluşturmadan bu kaynakları bağlam olarak kendi çalışma alanına dahil edebilir.
3. Prompts (İstekler / Şablonlar): Kullanıcı ve model etkileşimini standartlaştıran, önceden tanımlanmış istem şablonlarıdır. MCP sunucusu, belirli iş akışlarını otomatikleştirmek için optimize edilmiş hazır komut setlerini istemciye sunabilir.

MCP Mimari Bileşenlerinin Anatomisi

Bir MCP ekosistemi, istemci ile sunucu arasında durumsuz (stateless) veya durumlu (stateful) bağlantılar kurabilen 4 ana bileşenden oluşur:

MCP HOST / CLIENT
(Cursor, Windsurf, Claude Desktop, VS Code, Otonom Ajanlar vb.)
               |
MCP Protocol (stdio / SSE)
               |
          MCP SERVER
(GitHub MCP, Supabase MCP, Custom TypeScript/Python MCP vb.)
               |
Yerel Sürücüler / API / Uzak Bağlantılar
               |
        VERİ KAYNAKLARI
(PostgreSQL, Remote APIs, Local Filesystem, GitHub vb.)

MCP Host / Client (İstemci Katmanı): MCP protokolünü destekleyen ve yapay zeka modelini bünyesinde barındıran çalışma ortamıdır (IDE'ler: Cursor, Windsurf, VS Code; Masaüstü Uygulamaları: Claude Desktop veya özel otonom ajan yazılımları). Host, kullanıcının girdisini alır, bağlı olduğu MCP sunucularını keşfeder (discovery phase) ve yeteneklerine göre modellerin bu sunucularla iletişim kurmasını sağlar.
MCP Protocol (İletişim Katmanı): İstemci ile sunucu arasındaki mesajlaşma standartlarını belirleyen protokoldür. Genellikle standart girdi/çıktı akışları (stdio) veya uzaktan erişim durumlarında SSE (Server-Sent Events) / HTTP kanalları üzerinden JSON-RPC formatında çalışır. Model bağımsız bir katmandır; arkadaki LLM değişse bile protokol bağlantısı sabit kalır.
MCP Server (Sunucu Katmanı): Belirli bir veri kaynağının veya servis sağlayıcısının yeteneklerini Tools, Resources ve Prompts formatında protokole açık hale getiren aracı yazılımdır. Sunucu, veri kaynağına özgü karmaşıklığı kendi içinde soyutlar; dışarıya yalnızca standart MCP arayüzünü sunar.
Veri Kaynakları (Data Sources): Sistem tarafından erişilmek istenen nihai hedeflerdir. Yerel dosya sistemi, SQL/NoSQL veritabanları, harici REST servisleri veya WhatsApp/Slack gibi iletişim platformları bu katmanda yer alır.

Bölüm 2: Hazır MCP Ekosistemi ve Gerçek Dünya Senaryoları

Model Context Protocol'ün (MCP) sunduğu mimari soyutlama, açık kaynak topluluğu ve büyük teknoloji sağlayıcıları tarafından hızla benimsenmiştir. Günümüz yapay zeka ekosisteminde, geliştiricilerin veya kurumların sıfırdan servis entegrasyonu yazmasına gerek kalmadan doğrudan sistemlerine entegre edebilecekleri geniş bir hazır MCP sunucu (MCP Server) kütüphanesi bulunmaktadır.

Bu sunucular, modern yazılım geliştirme, veri kazıma, veritabanı yönetimi ve çoklu ortam (multimodal) iletişim süreçlerini otonom yapay zeka ajanlarına açan temel yapı taşlarıdır. Sektörde en sık kullanılan kritik MCP sunucularını ve bunların sunduğu pratik yetenekleri teknik bazda inceleyelim:

1. GitHub MCP: Versiyon Kontrolü ve CI/CD Süreçlerinin Otonomizasyonu

Depo ve Dal Yönetimi: Yeni uzak depoları (Create Repository) oluşturabilir, mevcut repolardaki dosyaları okuyabilir ve izole özellik dalları (Create Branch) açabilir.
Kod Pushlama ve İnceleme: Değişiklikleri uzak repoya yükleyebilir (Push File), iş kalemlerini (Issues) listeleyip durumlarını güncelleyebilir ve kod arama sorguları çalıştırabilir.
Otomatik Pull Request (PR) Akışı: Yapay zeka ajanı, kodlama görevini tamamladıktan sonra değişiklik listesini ve açıklama (description) metnini kendi hazırlayarak Create Pull Request aracını tetikler ve kodu incelemeye sunar.

2. Firecrawl & Browsertools MCP: Web Scripting ve Tarayıcı Düzeyinde Hata Ayıklama (Debugging)

Firecrawl MCP: İnternet üzerindeki karmaşık web sayfalarını (YouTube, Medium, dokümantasyon siteleri vb.) doğrudan LLM'lerin anlayabileceği temiz Markdown/JSON formatına dönüştürür. İçerik arama (Search), belirli URL'leri derinlemesine tarama (Crawl) ve sayfa yapısını analiz etme yetenekleriyle ajanların canlı web verisiyle beslenmesini sağlar.
Browsertools MCP: Doğrudan tarayıcı ortamına entegre olarak uygulamanın çalışma zamanı (runtime) davranışlarını izler. Tarayıcının konsol loglarını (console.log, hatalar), ağ isteklerini (Network tabındaki 404, 500 veya CORS hataları) dinler ve DOM öğelerini seçerek görsel ekran görüntüleri (Snapshot/Screenshot) alır. Bu sayede ajan, kod yazarken oluşan bir arayüz veya ağ hatasını doğrudan canlı tarayıcı verisi üzerinden tespit edip otonom olarak düzeltir.

3. Supabase MCP: Doğal Dille Veritabanı ve Şema Yönetimi

Şema Analizi ve Migration: Geliştiricinin SQL yazmasına gerek kalmadan, doğal dille ifade edilen gereksinimlere göre veritabanı şemalarını inceler, migration dosyaları hazırlayarak yeni tablolar ve kolonlar ekler.
Veri Manipülasyonu ve Sorgulama: Güvenli çalışma ortamı üzerinden Execute SQL komutlarıyla sorgular çalıştırır, veri ekler (Insert), günceller ve okuma operasyonlarını yürütür.
Backend Bağımsız Arayüzler: Geliştiricinin bir backend servisi yazmasına gerek kalmadan doğrudan MCP protokolü üzerinden veri modelleri ile ön yüz (frontend) bileşenleri arasında veri akışı kurmasını sağlar.

4. ElevenLabs & WhatsApp MCP: Çoklu Ortam (Audio/Messaging) Entegrasyonları

ElevenLabs MCP: Metinden sese (Text-to-Speech) dönüştürme yeteneklerini protokole açar. Modelin ürettiği yanıtlar ses dosyasına dönüştürülerek yerel sistemde yürütülebilir (Play Audio). Bu yapı, işletmeler için doğal insan sesine sahip sesli asistanlar ve müşteri temsilcisi botları kurgulamada kullanılır.
WhatsApp MCP: Bir Go/Mingo köprüsü (bridge) üzerinden WhatsApp Web istemcisine QR kod eşleşmesi ile bağlanır. Ajanın kişileri aramasına (Search Contact), mesaj geçmişini okumasına, medya/dosya indirmesine ve hedeflenen numaralara dinamik mesajlar veya sesli yanıtlar göndermesine imkan tanır.

Özet Entegrasyon Matrisi

MCP Sunucusu	Temel Kullanım Alanı	Sunduğu Ana Araçlar (Tools)
GitHub	Versiyon Kontrolü & CI/CD	`create_repository`, `push_files`, `create_pull_request`
Firecrawl	Web Scrapping & Veri Toplama	`scrape_url`, `crawl_website`, `search_web`
Browsertools	Canlı Debugging & DOM Analizi	`get_console_logs`, `get_network_errors`, `take_snapshot`
Supabase	Veritabanı & Şema Yönetimi	`list_tables`, `execute_sql`, `apply_migration`
ElevenLabs	Ses Sentezleme & Asistan	`text_to_speech`, `play_audio`
WhatsApp	Otonom İletişim & Mesajlaşma	`send_message`, `list_chats`, `get_contact_history`

Bölüm 3: Uçtan Uca MCP Orkestrasyonu (Örnek Senaryo)

Model Context Protocol'ün (MCP) gerçek gücü, tek bir sunucu entegrasyonundan ziyade birden fazla MCP sunucusunun bağımsız işlevlerini tek bir orkestrasyon altında birleştirebilme yeteneğinden gelir. Geleneksel mimarilerde farklı disiplinlerdeki (veri kazıma, yapay zeka analizi, veritabanı kaydı ve arayüz sunumu) servisleri birbirine bağlamak için devasa bir ara yazılım (middleware) katmanı ve karmaşık entegrasyon hatları (pipelines) kurgulamak gerekir. MCP mimarisinde ise yapay zeka ajanı, farklı MCP sunucularının araçlarını (tools) ve kaynaklarını (resources) orkestre eden akıllı bir yönetim katmanı olarak işlev görür.

Mimarinin Genel Yapısı ve Veri Akış Hattı

Kurgulayacağımız senaryoda amaç; hedeflenen bir YouTube kanalının son videolarını çekmek, yorum verilerini toplamak, bu verileri duygu/içerik analizinden geçirmek, çıkan analitik veriyi ilişkisel bir veritabanına kaydetmek ve nihayetinde bunu dinamik bir dashboard üzerinde sunmaktır.

Bu iş akışını yürütmek için 3 temel MCP bileşeni ve bir LLM motoru eş zamanlı orkestre edilir:

Custom YouTube MCP Server: Kanal videolarını arayan, video detaylarını ve ham yorumları (comments) çeken özel sunucu.
Gemini / LLM Engine (Analiz Katmanı): Çekilen yorumları içerik kalitesi, izleyici talepleri ve geliştirme önerileri açısından analiz eden akıl yürütme motoru.
Supabase MCP Server: Analiz edilen veriyi SQL migration ve şema yapılarına uygun şekilde veritabanında saklayan sunucu.

MCP HOST / AGENT
(Orkestrasyonu Yürüten LLM / İstemci Çalışma Alanı)
               |
  (1. Veri Çekme)               (2. Analiz)                (3. Veri Kaydı)
               v                              v                             v
          YouTube MCP                 Gemini / LLM Engine              Supabase MCP
(Search, List, Get Comments)  --> (Duygu Analizi, Özetleme, İyileştirme Önerileri)  --> (Schema Migration, Insert SQL)
                                                                            |
                                                                            v
                                                                    Dashboard Arayüzü
                                                                    (HTML / CSS / JS)

Adım Adım Orkestrasyon Akışı

Adım 1: YouTube MCP Sunucusu ile Canlı Veri Toplama

Orkestrasyon süreci, ajanın hedeflenen kanalı sorgulamasıyla başlar. Yapay zeka ajanı, YouTube MCP Server üzerinden sırasıyla şu araçları tetikler:

get_channel_videos: İlgili kanalın son yayınlanan videolarını liste halinden çeker.
get_video_details: Seçilen videonun izlenme, beğeni ve yayın zamanı gibi metriklerini getirir.
get_comments: Videoya yapılmış izleyici yorumlarını filtrelenmiş JSON verisi olarak bağlama dahil eder.

Adım 2: LLM Analiz Katmanı (Gemini API / Analiz Motoru)

Toplanan ham yorum verisi, LLM'in bağlam penceresine (context window) aktarılır. Model, tanımlanmış istem şablonları (prompts) doğrultusunda şu çıkarımları yapar:

İzleyici duygu durumunun (pozitif, negatif, nötr) yüzdesel dağılımı.
İçerikte iyileştirilmesi gereken teknik ve içeriksel noktalar.
Bir sonraki çekilecek video için izleyicilerden gelen konu önerileri.

Adım 3: Supabase MCP Sunucusu ile Veri Kalıcılığı (Persistence)

Elde edilen analitik veri ve özet bilgisi geçici hafızada bırakılmaz. Yapay zeka ajanı, Supabase MCP Server ile iletişime geçerek veritabanı operasyonunu başlatır:

Şayet veritabanında gerekli tablolar yoksa apply_migration aracı ile youtube_videos ve comment_analyses tablolarını otomatik oluşturur.
Analiz sonuçlarını ve video metriklerini execute_sql veya insert araçlarını kullanarak ilişkisel yapıda veritabanına işler.

Adım 4: Verinin Dinamik Sunumu ve Dashboard Üretimi

Orkestrasyonun son aşamasında yapay zeka ajanı, veritabanına kaydettiği yapılandırılmış veriyi doğrudan okuyacak bir ön yüz bileşeni (HTML5, Modern CSS, Vanilla JS) kurgular. Kullanıcı, canlı veritabanı uç noktalarına bağlanan bu dashboard üzerinden videoların analitik performansını, yorum özetlerini ve iyileştirme tavsiyelerini interaktif bir şekilde görüntüler.

Bölüm 4: Uygulamalı Rehber: TypeScript SDK ile Sıfırdan YouTube MCP Server Kodlama

Teorik mimariyi ve orkestrasyon mantığını kavradıktan sonra, sıfırdan özel bir MCP sunucusunun (Custom MCP Server) nasıl inşa edileceğini pratik olarak inceleyelim. Bu bölümde, TypeScript SDK (@modelcontextprotocol/sdk) kullanarak YouTube Data API ve Gemini API ile entegre çalışan uçtan uca özel bir MCP sunucusu geliştireceğiz.

Geliştireceğimiz sunucu, yapay zeka modellerine (Cursor, Windsurf, Claude Desktop vb.) şu temel araçları (Tools) kazandıracak:

search_videos: Anahtar kelimeye göre video arama.
get_channel_videos: Belirli bir kanalın videolarını çekme.
get_video_details: Video detaylarını ve istatistiklerini alma.
get_comments: Videoya ait izleyici yorumlarını toplama.
analyze_comments_with_ai: Toplanan yorumları Gemini API ile duygu ve içerik analizinden geçirme.

1. Proje Yapılandırması ve Bağımlılıkların Kurulması

İlk olarak Node.js ortamında boş bir TypeScript projesi başlatıyoruz ve gerekli SDK paketlerini yüklüyoruz:

mkdir youtube-mcp-server
cd youtube-mcp-server
npm init -y

Ardından MCP SDK'sını, Google API kütüphanelerini ve TypeScript bağımlılıklarını ekliyoruz:

npm install @modelcontextprotocol/sdk googleapis @google/genai express
npm install -D typescript @types/node ts-node

tsconfig.json dosyamızı Node.js ve modern ECMAScript standartlarına uygun olarak yapılandırıyoruz:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*"]
}

package.json dosyamıza derleme (build) ve çalıştırma (start) betiklerini ekliyoruz:

"scripts": {
  "build": "tsc",
  "start": "node dist/index.js"
}

2. Sunucu Mimarisi ve Araçların (Tools) Tanımlanması

src/index.ts dosyamızı oluşturarak MCP sunucu mimarisini, YouTube API istemcisini ve araç şemalarını kurguluyoruz.

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { google } from "googleapis";
import { GoogleGenAI } from "@google/genai";

// API Anahtarlarının Yapılandırılması
const YOUTUBE_API_KEY = process.env.YOUTUBE_API_KEY || "YOUR_YOUTUBE_API_KEY";
const GEMINI_API_KEY = process.env.GEMINI_API_KEY || "YOUR_GEMINI_API_KEY";

const youtube = google.youtube({
  version: "v3",
  auth: YOUTUBE_API_KEY,
});

const ai = new GoogleGenAI({ apiKey: GEMINI_API_KEY });

// MCP Sunucusunun Başlatılması
const server = new Server(
  {
    name: "youtube-mcp-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

3. Araç Listesinin (ListTools) Protokole Sunulması

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "search_videos",
        description: "YouTube üzerinde belirli bir kelimeye göre video arar.",
        inputSchema: {
          type: "object",
          properties: {
            query: { type: "string", description: "Aranacak kelime" },
            maxResults: { type: "number", description: "Dönecek maksimum sonuç (varsayılan: 5)" },
          },
          required: ["query"],
        },
      },
      // ... Diğer araç tanımlamaları
    ],
  };
});

4. Araç Çağrılarının (CallTool) İşlenmesi ve İş Mantığı

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    if (name === "search_videos") {
      const response = await youtube.search.list({
        part: ["snippet"],
        q: args.query as string,
        maxResults: (args.maxResults as number) || 5,
        type: ["video"],
      });

      return {
        content: [{ type: "text", text: JSON.stringify(response.data.items, null, 2) }],
      };
    }
    // ... Diğer if blokları
    throw new Error(`Bilinmeyen araç: ${name}`);
  } catch (error: any) {
    return {
      content: [{ type: "text", text: `Hata oluştu: ${error.message}` }],
      isError: true,
    };
  }
});

5. Sunucunun stdio Taşıyıcısı Üzerinden Başlatılması

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("YouTube MCP Server stdio modunda çalışıyor...");
}

main().catch((error) => {
  console.error("Sunucu başlatma hatası:", error);
  process.exit(1);
});

6. Derleme ve IDE (Cursor / Windsurf) Entegrasyonu

Kodumuzu tamamladıktan sonra JavaScript çıktısını alıyoruz:

npm run build

Şimdi bu sunucuyu Cursor veya Windsurf gibi MCP destekli bir IDE'ye eklemek için ilgili editörün MCP Ayarları (Settings > MCP) bölümüne aşağıdaki JSON konfigürasyonunu ekliyoruz:

{
  "mcpServers": {
    "youtube-custom-mcp": {
      "command": "node",
      "args": ["/ABSOLUTE/PATH/TO/youtube-mcp-server/dist/index.js"],
      "env": {
        "YOUTUBE_API_KEY": "AIzaSy...",
        "GEMINI_API_KEY": "AIzaSy..."
      }
    }
  }
}

Bölüm 5: MCP Geliştirirken Dikkat Edilmesi Gereken Güvenlik ve Performans Hususları

Model Context Protocol (MCP), yapay zeka ajanlarına harici sistemler üzerinde aksiyon alma yeteneği kazandırırken mimari düzeyde kritik güvenlik ve performans sorumluluklarını da beraberinde getirir. Bir MCP sunucusu geliştirmek veya kurumsal bir ajanı dış dünyaya açmak, yalnızca standart bir REST API yazmak gibi değerlendirilmemelidir.

1. Hassas Veri ve Kimlik Doğrulama Güvenliği (API Key / Access Token Yönetimi)

Sert Kodlanmış (Hardcoded) Kimlik Bilgilerinden Kaçınma: API anahtarları veya kişisel erişim jetonları kesinlikle sunucu kodlarının içinde statik olarak tutulmamalıdır.
Ortam Değişkenleri (Environment Variables) Kullanımı: Tüm hassas bilgiler istemci (Host) konfigürasyon dosyaları üzerinden env parametresiyle dinamik olarak enjekte edilmelidir.
Minimum Yetki Prensibi: MCP sunucusuna verilen GitHub token'ı veya veritabanı kullanıcısı yalnızca ihtiyaç duyduğu spesifik aksiyonları gerçekleştirecek yetkilere sahip olmalıdır.

2. Yan Etki (Side-Effect) Güvenliği ve Yanlış Araç Tetikleme Riski

Yıkıcı İşlemler İçin İnsan Onayı (Human-in-the-Loop): Veritabanı silme veya toplu mesaj gönderme gibi kritik yan etkileri olan araçlar çalıştırılmadan önce istemci katmanında kullanıcı onayına (Confirmation Step) sunulmalıdır.
Strict Schema ve Validasyon: İstemciden (Host/LLM) gelen girdi parametreleri sunucu tarafında mutlaka sıkı bir doğrulamadan geçirilmelidir.

3. Bağlam Penceresi (Context Window) ve Araç Sınırı Yönetimi

İstemci Araç Sınırı (Tool Limits): Birçok IDE veya istemci ortamı, performans düşüşünü önlemek için aynı anda aktif olabilecek araç sayısına bir üst sınır koyar. Modüler ve spesifik görev odaklı küçük sunucular tasarlanmalıdır.
Veri Biçimlendirme ve Filtreleme: MCP sunucusu bir araç çağrısının yanıtı olarak ham, devasa JSON nesneleri dönmemelidir. Gereksiz detaylar modelin bağlam penceresini şişirerek hem maliyeti hem de yanıt süresini artırır.

4. Hata Yönetimi (Error Handling) ve Dayanıklılık (Resilience)

Yapılandırılmış Hata Yanıtları: Sunucu bir API hatası aldığında işlemi çökertmek (crash) yerine, hatanın sebebini belirten anlamlı metin mesajlarını isError: true flag'i ile modele geri dönmelidir.
Otonom Düzeltme (Self-Correction) İmkanı: Hata mesajı net bir şekilde modele iletildiğinde, LLM bu hatayı analiz ederek parametrelerini revize edebilir ve aracı farklı girdilerle yeniden tetikleyerek hatayı otonom olarak çözebilir.

Sonuç: Yapay Zeka Ajanlarının Geleceği ve MCP'nin Sektördeki Yeri

Model Context Protocol (MCP), yapay zeka ekosisteminde yalnızca yeni bir yazılım kütüphanesi veya basit bir araç entegrasyon yöntemi değildir. MCP, yapay zeka sistemlerinin dış dünya ile nasıl etkileşime girmesi gerektiğini tanımlayan mimari bir kırılma noktası ve açık iletişim standardıdır.

Geleneksel entegrasyon modellerinde yaşanan kırılgan kod yapıları, sürekli bakım gerektiren özel API bağlantıları ve modele özgü bağımlılıklar, MCP'nin sunduğu evrensel soyutlama katmanı sayesinde geçerliliğini yitirmektedir. Yapay zeka uygulamaları artık metin üreten pasif arayüzler olmaktan çıkıp; veritabanlarına güvenle erişen, versiyon kontrol sistemlerini yöneten, web üzerinde otonom araştırmalar yapan ve çoklu ortam kanallarını bir arada orkestre edebilen Otonom Yapay Zeka Ajanlarına (Agentic AI) dönüşmektedir.

Yapay zeka mühendisleri ve sistem mimarları için MCP standardını anlamak ve bu protokole uygun özel sunucular (Custom MCP Servers) geliştirebilmek, geleceğin ölçeklenebilir ve güvenli AI sistemlerini inşa etmenin anahtarıdır. Önümüzdeki dönemde, kurumsal yazılım mimarilerinin hemen her noktasında MCP tabanlı mikro servislerin standart hale geldiğini ve veri kaynaklarının yapay zekaya bu evrensel "USB-C" arabirimi üzerinden açıldığını çok daha net bir şekilde göreceğiz.