MCP (Model Context Protocol): AI Entegrasyon Standardı

1// MCP ÖNCESİ: Her AI-araç çifti için özel kod
2// N uygulama × M araç = N×M entegrasyon 😱
3const integrations = {
4  'claude + github': customGithubIntegration(),
5  'claude + slack': customSlackIntegration(),
6  'chatgpt + github': anotherGithubIntegration(),
7  'chatgpt + slack': anotherSlackIntegration(),
8  // ... 100 entegrasyon
9};
10 
11// MCP SONRASI: Standart protokol
12// N uygulama × 1 protokol + M araç × 1 protokol = N+M entegrasyon 🎉
13const mcpServer = new MCPServer('github');  // 1 kez yaz
14// Tüm MCP-uyumlu AI client'ları otomatik bağlanır

1// MCP bileşenleri arası iletişim akışı
2interface MCPArchitecture {
3  host: {
4    name: 'Claude Desktop' | 'VS Code' | 'Cursor';
5    role: 'Kullanıcı arayüzü, AI model bağlantısı';
6    manages: MCPClient[];  // Birden fazla client yönetir
7  };
8 
9  client: {
10    role: '1:1 server bağlantısı, protokol yönetimi';
11    capabilities: {
12      roots: boolean;     // Dosya sistemi kök dizinleri
13      sampling: boolean;  // AI model çağrısı yapabilme
14    };
15  };
16 
17  server: {
18    role: 'Araç/veri sağlama';
19    exposes: {
20      tools: Tool[];          // Çalıştırılabilir fonksiyonlar
21      resources: Resource[];  // Okunabilir veri kaynakları
22      prompts: Prompt[];      // Önceden tanımlı prompt şablonları
23    };
24  };
25}
26 
27// İletişim akışı:
28// Kullanıcı → Host → Client → Server → Dış Araç/Veri
29// Dış Araç/Veri → Server → Client → Host → AI Model → Kullanıcı

1// stdio transport ile MCP Server
2import { Server } from '@modelcontextprotocol/sdk/server/index.js';
3import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
4 
5const server = new Server(
6  { name: 'my-tool-server', version: '1.0.0' },
7  { capabilities: { tools: {} } }
8);
9 
10// Tool tanımla
11server.setRequestHandler('tools/list', async () => ({
12  tools: [
13    {
14      name: 'get_weather',
15      description: 'Belirtilen şehrin hava durumunu getirir',
16      inputSchema: {
17        type: 'object',
18        properties: {
19          city: { type: 'string', description: 'Şehir adı' },
20          unit: { type: 'string', enum: ['celsius', 'fahrenheit'] },
21        },
22        required: ['city'],
23      },
24    },
25  ],
26}));
27 
28// Tool çalıştır
29server.setRequestHandler('tools/call', async (request) => {
30  if (request.params.name === 'get_weather') {
31    const { city, unit = 'celsius' } = request.params.arguments;
32    const weather = await fetchWeather(city, unit);
33    return {
34      content: [
35        { type: 'text', text: JSON.stringify(weather, null, 2) },
36      ],
37    };
38  }
39  throw new Error('Bilinmeyen tool');
40});
41 
42// Sunucuyu başlat
43const transport = new StdioServerTransport();
44await server.connect(transport);

1// Streamable HTTP transport
2import { StreamableHTTPServerTransport } from
3  '@modelcontextprotocol/sdk/server/streamableHttp.js';
4import express from 'express';
5 
6const app = express();
7 
8app.post('/mcp', async (req, res) => {
9  const transport = new StreamableHTTPServerTransport('/mcp', res);
10  await server.connect(transport);
11  await transport.handleRequest(req, res);
12});
13 
14// Session yönetimi
15app.get('/mcp', async (req, res) => {
16  // SSE stream (server → client bildirimleri)
17  const transport = new StreamableHTTPServerTransport('/mcp', res);
18  await transport.handleSSERequest(req, res);
19});
20 
21app.delete('/mcp', async (req, res) => {
22  // Session sonlandırma
23  const sessionId = req.headers['mcp-session-id'];
24  await sessionManager.terminate(sessionId);
25  res.status(200).end();
26});
27 
28app.listen(3001, () => console.log('MCP Server: http://localhost:3001/mcp'));

1// MCP Tool yapısı
2interface MCPTool {
3  // Benzersiz isim
4  name: string;
5 
6  // AI modelin anlayacağı açıklama
7  description: string;
8 
9  // JSON Schema ile parametre tanımı
10  inputSchema: {
11    type: 'object';
12    properties: Record;
13    required?: string[];
14  };
15 
16  // Opsiyonel: İnsan onayı gerektiren tehlikeli işlemler
17  annotations?: {
18    destructiveHint?: boolean;   // Silme, değiştirme
19    idempotentHint?: boolean;    // Tekrar çağrılabilir
20    readOnlyHint?: boolean;      // Sadece okuma
21    openWorldHint?: boolean;     // Dış dünyayla etkileşim
22  };
23}
24 
25// Gerçek dünya örneği: Firestore MCP Tool'ları
26const firestoreTools: MCPTool[] = [
27  {
28    name: 'firestore_query',
29    description: 'Firestore koleksiyonundan belge sorgula. Filtre, sıralama ve limit destekler.',
30    inputSchema: {
31      type: 'object',
32      properties: {
33        collection: { type: 'string', description: 'Koleksiyon adı (ör: blog_posts)' },
34        where: {
35          type: 'array',
36          items: {
37            type: 'object',
38            properties: {
39              field: { type: 'string' },
40              op: { type: 'string', enum: ['==', '!=', '<', '>', '<=', '>=', 'in', 'array-contains'] },
41              value: {},
42            },
43          },
44          description: 'Filtre koşulları',
45        },
46        orderBy: { type: 'string', description: 'Sıralama alanı' },
47        limit: { type: 'number', description: 'Maksimum belge sayısı' },
48      },
49      required: ['collection'],
50    },
51    annotations: { readOnlyHint: true, idempotentHint: true },
52  },
53  {
54    name: 'firestore_write',
55    description: 'Firestore koleksiyonuna belge yaz veya güncelle.',
56    inputSchema: {
57      type: 'object',
58      properties: {
59        collection: { type: 'string' },
60        documentId: { type: 'string', description: 'Belge ID (opsiyonel, otomatik üretilir)' },
61        data: { type: 'object', description: 'Yazılacak veri' },
62        merge: { type: 'boolean', description: 'Mevcut belgeyle birleştir' },
63      },
64      required: ['collection', 'data'],
65    },
66    annotations: { destructiveHint: true, idempotentHint: false },
67  },
68];

1// Resource tanımlama
2server.setRequestHandler('resources/list', async () => ({
3  resources: [
4    {
5      uri: 'config://app-settings',
6      name: 'Uygulama Ayarları',
7      description: 'Mevcut uygulama konfigürasyonu',
8      mimeType: 'application/json',
9    },
10    {
11      uri: 'db://users/active',
12      name: 'Aktif Kullanıcılar',
13      description: 'Son 30 günde aktif olan kullanıcı listesi',
14      mimeType: 'application/json',
15    },
16  ],
17}));
18 
19// Resource içeriğini oku
20server.setRequestHandler('resources/read', async (request) => {
21  const { uri } = request.params;
22 
23  if (uri === 'config://app-settings') {
24    return {
25      contents: [
26        {
27          uri,
28          mimeType: 'application/json',
29          text: JSON.stringify(getAppSettings()),
30        },
31      ],
32    };
33  }
34});

1// package.json
2// {
3//   "name": "my-mcp-server",
4//   "version": "1.0.0",
5//   "type": "module",
6//   "dependencies": {
7//     "@modelcontextprotocol/sdk": "^1.12.0"
8//   }
9// }
10 
11// index.ts — Tam çalışan MCP Server örneği
12import { Server } from '@modelcontextprotocol/sdk/server/index.js';
13import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
14 
15const server = new Server(
16  { name: 'portfolio-helper', version: '1.0.0' },
17  {
18    capabilities: {
19      tools: {},
20      resources: {},
21    },
22  }
23);
24 
25// Tool: Blog arama
26server.setRequestHandler('tools/list', async () => ({
27  tools: [
28    {
29      name: 'search_blogs',
30      description: 'Blog yazılarında anahtar kelime araması yapar',
31      inputSchema: {
32        type: 'object',
33        properties: {
34          query: { type: 'string', description: 'Arama sorgusu' },
35          category: { type: 'string', description: 'Kategori filtresi' },
36          limit: { type: 'number', description: 'Sonuç limiti', default: 5 },
37        },
38        required: ['query'],
39      },
40    },
41    {
42      name: 'get_project_stats',
43      description: 'Proje istatistiklerini getirir (indirme, puan, kullanıcı)',
44      inputSchema: {
45        type: 'object',
46        properties: {
47          projectSlug: { type: 'string' },
48        },
49        required: ['projectSlug'],
50      },
51    },
52  ],
53}));
54 
55// Tool handler
56server.setRequestHandler('tools/call', async (request) => {
57  const { name, arguments: args } = request.params;
58 
59  switch (name) {
60    case 'search_blogs': {
61      const results = await searchBlogs(args.query, args.category, args.limit);
62      return {
63        content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
64      };
65    }
66    case 'get_project_stats': {
67      const stats = await getProjectStats(args.projectSlug);
68      return {
69        content: [{ type: 'text', text: JSON.stringify(stats, null, 2) }],
70      };
71    }
72    default:
73      throw new Error(`Bilinmeyen tool: ${name}`);
74  }
75});
76 
77// Başlat
78const transport = new StdioServerTransport();
79await server.connect(transport);

1// MCP güvenlik katmanları
2interface MCPSecurityModel {
3  // 1. Transport güvenliği
4  transport: {
5    localOnly: 'stdio';                // Lokal = en güvenli
6    remote: 'HTTPS + mTLS';            // Uzak = şifreli + karşılıklı auth
7    authentication: 'OAuth 2.1';       // Token tabanlı kimlik doğrulama
8  };
9 
10  // 2. Yetkilendirme
11  authorization: {
12    principle: 'least privilege';       // Minimum yetki
13    toolLevel: 'per-tool-permission';   // Her tool için ayrı izin
14    userApproval: 'destructive-ops';    // Yıkıcı işlemler = onay
15  };
16 
17  // 3. Girdi doğrulama
18  inputValidation: {
19    schema: 'JSON Schema strict';       // Katı şema doğrulama
20    sanitization: 'injection-prevention'; // Enjeksiyon önleme
21    rateLimiting: 'per-client-per-tool'; // İstemci+tool bazlı limit
22  };
23 
24  // 4. Çıktı kontrolü
25  outputControl: {
26    dataMinimization: true;    // Gereken minimum veriyi döndür
27    piiRedaction: true;        // Kişisel veri maskeleme
28    sizeLimit: '10MB';         // Yanıt boyut limiti
29  };
30}