Cursor/Claude için Kendi MCP Sunucunuzu 4 Adımda Kurun

Cursor/Claude için Kendi MCP Sunucunuzu 4 Adımda Kurun

Günümüz yapay zeka destekli geliştirme ortamlarında, Cursor gibi IDE’ler veya Claude gibi güçlü dil modelleri, üretkenliği inanılmaz seviyelere taşıyor. Ancak bu araçları kullanırken gizlilik, maliyet ve performans gibi endişeler ortaya çıkabilir. İşte tam da bu noktada kendi Multi-Cloud Proxy (MCP) sunucunuzu kurmak devreye giriyor. Bu makalede, Cursor veya Claude gibi araçları yerel veya özel API’lerinizle daha güvenli, uygun maliyetli ve yüksek performanslı bir şekilde entegre etmenizi sağlayacak bir MCP sunucusunu adım adım nasıl kuracağınızı detaylı bir şekilde anlatacağız. Bu rehber sayesinde veri kontrolünüzü elinizde tutarken, AI modellerinin gücünden ödün vermeyeceksiniz.

Neden Kendi MCP Sunucunuza İhtiyacınız Var?

Kendi MCP sunucunuzu kurmak, yapay zeka tabanlı geliştirme süreçlerinizde size önemli avantajlar sağlar. Bu avantajlar, özellikle hassas verilerle çalışırken veya maliyetleri optimize etmek istediğinizde kritik hale gelir.

Gizlilik ve Veri Güvenliği

Harici AI hizmetlerini kullanırken, kodunuz veya verileriniz üçüncü taraf sunucularına gönderilir. Bu durum, özellikle kurumsal veya kişisel gizliliği yüksek projelerde önemli güvenlik riskleri oluşturabilir. Kendi MCP sunucunuzu kurarak, hassas verilerinizin şirket ağınızdan veya yerel makinenizden ayrılmamasını sağlayabilirsiniz. Sunucu, istekleri işlerken verileri doğrudan harici sağlayıcılara göndermek yerine, belirli kurallar çerçevesinde yönlendirme veya maskeleme yapabilir. Bu sayede, veri ihlali riskini minimize eder ve veri egemenliğinizi korursunuz.

Maliyet Kontrolü ve Optimizasyon

Büyük dil modellerinin (LLM) API çağrıları, özellikle yoğun kullanımlarda önemli maliyetlere yol açabilir. Kendi MCP sunucunuz, bu maliyetleri optimize etmenize olanak tanır. Örneğin, daha uygun maliyetli veya ücretsiz yerel LLM’leri (Ollama, Llama.cpp gibi) ana model olarak kullanabilir, sadece belirli ve karmaşık istekler için pahalı harici API’lere yönlendirme yapabilirsiniz. Ayrıca, aynı isteğin birden fazla kez yapılması durumunda önbellekleme (caching) mekanizmaları uygulayarak gereksiz API çağrılarını ortadan kaldırabilir, böylece faturalarınızı önemli ölçüde düşürebilirsiniz.

Düşük Gecikme ve Yüksek Performans

Harici API’lere yapılan her çağrı, ağ gecikmesi (latency) ve bant genişliği sınırlamaları nedeniyle yavaşlayabilir. Kendi sunucunuzu yerel ağınızda veya size yakın bir konumda barındırarak bu gecikmeyi minimuma indirebilirsiniz. Özellikle yerel olarak çalışan AI modelleriyle entegre edildiğinde, yanıt süreleri neredeyse anlık hale gelir. Bu, Cursor gibi interaktif araçlarda kod tamamlama, hata ayıklama veya sohbet tabanlı yardım alırken çok daha akıcı ve kesintisiz bir deneyim sunar.

Özelleştirme ve Esneklik

Kendi MCP sunucunuz, AI isteklerini ve yanıtlarını dilediğiniz gibi özelleştirme ve dönüştürme konusunda size tam esneklik sağlar. İstekleri belirli kriterlere göre farklı modellere yönlendirebilir, yanıtları belirli formatlara dönüştürebilir, hata işleme mantığını geliştirebilir veya kendi iş akışlarınıza özel ek katmanlar ekleyebilirsiniz. Bu özelleştirme yeteneği, standart API’lerin sunduğu sınırlamaların ötesine geçerek, geliştirme süreçlerinizi tamamen kontrol etmenizi ve kendi ihtiyaçlarınıza göre optimize etmenizi sağlar.

Adım 1: Gerekli Ön Hazırlıklar ve Araçlar

MCP sunucunuzu kurmaya başlamadan önce, gerekli tüm yazılım ve donanım gereksinimlerini karşıladığınızdan emin olmalısınız. Bu adım, sorunsuz bir kurulum süreci için temel oluşturur.

Donanım ve Yazılım Gereksinimleri

Bir MCP sunucusu, genellikle çok yüksek donanım gereksinimlerine ihtiyaç duymaz, ancak AI modellerini yerel olarak çalıştırmayı planlıyorsanız durum değişebilir.

• Donanım:
  • CPU: Çoğu proxy işlemi için modern bir dört çekirdekli CPU yeterlidir. Yerel LLM’leri çalıştırmak istiyorsanız daha güçlü bir CPU (veya GPU) gerekebilir.
  • RAM: En az 8 GB RAM önerilir. Yerel LLM’ler için 16 GB veya daha fazlası idealdir.
  • Depolama: SSD, hızlı okuma/yazma performansı için tercih edilir. İşletim sistemi ve kütüphaneler için yeterli alan (en az 20 GB) gereklidir.
  • Ağ Bağlantısı: Kararlı ve hızlı bir internet bağlantısı, harici API’lere erişim için önemlidir.
• Yazılım:
  • İşletim Sistemi: Linux (Ubuntu, Debian), macOS veya Windows (WSL ile daha iyi performans) kullanabilirsiniz.
  • Python: Python 3.8 veya üzeri sürümü yüklü olmalıdır.
  • PIP: Python paket yöneticisi (genellikle Python ile birlikte gelir).

Python ve PIP Kurulumu

Python, sunucumuzun kalbi olacak. Kurulumu işletim sisteminize göre değişiklik gösterebilir:

• Linux (Ubuntu/Debian):

  sudo apt update
  sudo apt install python3 python3-pip

• macOS: Homebrew ile kolayca kurabilirsiniz:

  brew install python

• Windows: Python'ın resmi web sitesinden (python.org) indirme ve kurulum sihirbazını kullanın. Kurulum sırasında "Add Python to PATH" seçeneğini işaretlemeyi unutmayın.

Kurulumu doğrulayın:

python3 --version
pip3 --version

Sanal Ortam Oluşturma

Projenizin bağımlılıklarını sisteminizdeki diğer Python projelerinden izole etmek için bir sanal ortam kullanmak en iyi uygulamadır.

# Proje dizininizi oluşturun ve içine girin
mkdir mcp_server
cd mcp_server

# Sanal ortamı oluşturun
python3 -m venv venv

# Sanal ortamı etkinleştirin
# Linux/macOS
source venv/bin/activate

# Windows
.\venv\Scripts\activate

Sanal ortam etkinleştirildiğinde, komut satırınızın başında (venv) gibi bir ibare göreceksiniz.

Gerekli Kütüphanelerin Yüklenmesi

Sunucumuz için FastAPI, Uvicorn ve Requests gibi temel kütüphanelere ihtiyacımız var.

• FastAPI: Modern, hızlı (Starlette ve Pydantic'e dayalı) bir web framework'ü.
• Uvicorn: ASGI sunucusu, FastAPI uygulamasını çalıştırmak için kullanılır.
• Requests: HTTP istekleri yapmak için popüler bir kütüphane.
• python-dotenv: Çevre değişkenlerini yönetmek için (API anahtarları gibi).

pip install fastapi uvicorn requests python-dotenv

Bu adımları tamamladığınızda, MCP sunucunuzu geliştirmeye başlamak için hazır bir ortama sahip olacaksınız.

Adım 2: Temel Proxy Sunucusu Mantığını Geliştirme

Şimdi sıra, AI isteklerini yönlendirecek ve işleyecek temel proxy sunucusu mantığını oluşturmaya geldi. Bu adımda FastAPI'nin gücünden faydalanacağız.

FastAPI ile API Oluşturma

Öncelikle, sunucumuzun ana dosyasını (örneğin main.py) oluşturalım ve FastAPI uygulamasını başlatalım. Bu dosya, gelen istekleri dinleyecek ve yönlendirecek ana mantığı içerecek.

# main.py
from fastapi import FastAPI, Request, HTTPException, status
from fastapi.responses import JSONResponse
import requests
import os
from dotenv import load_dotenv

# .env dosyasındaki değişkenleri yükle
load_dotenv()

app = FastAPI()

# Hedef AI API URL'sini .env dosyasından al
# Varsayılan olarak Ollama'nın yerel API'si ayarlanmıştır.
TARGET_AI_API_URL = os.getenv("TARGET_AI_API_URL", "http://localhost:11434/v1/chat/completions")
# Harici API anahtarı (örn: Claude, OpenAI)
EXTERNAL_API_KEY = os.getenv("EXTERNAL_API_KEY")

@app.get("/")
async def read_root():
    return {"message": "MCP Proxy Sunucusu Çalışıyor!"}

@app.post("/v1/chat/completions")
async def proxy_chat_completions(request: Request):
    # Gelen isteğin gövdesini al
    request_body = await request.json()

    # İstek başlıklarını kopyala, ancak host ve content-length gibi başlıkları dışarıda bırak
    headers = {k: v for k, v in request.headers.items() if k.lower() not in ["host", "content-length"]}

    # Eğer harici bir API anahtarı tanımlanmışsa, Authorization başlığını ekle
    if EXTERNAL_API_KEY:
        # Örnek: Claude API için X-API-Key veya OpenAI için Authorization Bearer
        # Kullanacağınız API'ye göre bu kısmı ayarlayın.
        # Örneğin Claude için:
        # headers["x-api-key"] = EXTERNAL_API_KEY
        # headers["anthropic-version"] = "2023-06-01" # Claude için versiyon başlığı
        
        # Örneğin OpenAI için:
        headers["Authorization"] = f"Bearer {EXTERNAL_API_KEY}"


    try:
        # Hedef AI API'ye isteği ilet
        response = requests.post(TARGET_AI_API_URL, json=request_body, headers=headers, stream=True)
        response.raise_for_status() # HTTP hatalarını yakala

        # Yanıtı doğrudan istemciye akış olarak ilet
        return JSONResponse(content=response.json(), status_code=response.status_code)

    except requests.exceptions.RequestException as e:
        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Proxy isteği başarısız oldu: {e}")

Bu kod parçası, /v1/chat/completions endpoint'ine gelen tüm POST isteklerini alacak ve bunları TARGET_AI_API_URL adresine yönlendirecektir. Bu endpoint, hem OpenAI hem de Ollama gibi birçok LLM hizmeti tarafından kullanılan standart bir formattır.

İstekleri Yönlendirme ve İşleme

Yukarıdaki kodda requests.post fonksiyonu, gelen isteği hedef API'ye iletmek için kullanılır. Bu noktada, isteği değiştirebilir veya zenginleştirebilirsiniz:

• Model Seçimi: Gelen isteğin gövdesindeki model alanına göre farklı hedef URL'lere yönlendirme yapabilirsiniz. Örneğin, "model": "gpt-4" ise OpenAI'ye, "model": "llama2" ise yerel Ollama sunucusuna yönlendirme gibi.
• Parametre Dönüşümü: Bazı API'ler farklı parametre isimleri veya formatları bekleyebilir. İstek gövdesini hedef API'nin beklediği formata dönüştürebilirsiniz.
• İstek Ekleme: Her isteğe otomatik olarak bir API anahtarı veya başka bir kimlik doğrulama bilgisi ekleyebilirsiniz.

Yanıtları Yönetme ve Dönüştürme

Hedef API'den gelen yanıtı da işleyebilir ve dönüştürebilirsiniz:

• Yanıt Filtreleme: Yanıttan hassas bilgileri çıkarabilir veya belirli alanları maskeleyebilirsiniz.
• Yanıt Dönüşümü: Yanıt formatını, istemcinizin (Cursor gibi) beklediği formata uyacak şekilde değiştirebilirsiniz.
• Hata İşleme: Hedef API'den gelen hataları yakalayıp, istemciye daha anlamlı hata mesajları döndürebilirsiniz.
• Önbellekleme (Caching): Belirli istekler için yanıtları önbelleğe alarak tekrar eden aynı isteklerde hedef API'ye gitmeyi engelleyebilir, böylece gecikmeyi azaltıp maliyeti düşürebilirsiniz.

Güvenlik ve Kimlik Doğrulama (Opsiyonel)

Proxy sunucunuzun güvenliğini artırmak için temel kimlik doğrulama mekanizmaları ekleyebilirsiniz. Örneğin, gelen isteğin belirli bir API anahtarı içerip içermediğini kontrol edebilirsiniz:

# main.py dosyasında proxy_chat_completions fonksiyonunun başına eklenebilir
# İstemciden beklenen bir API anahtarı
EXPECTED_CLIENT_API_KEY = os.getenv("CLIENT_API_KEY")

@app.post("/v1/chat/completions")
async def proxy_chat_completions(request: Request):
    if EXPECTED_CLIENT_API_KEY:
        client_api_key = request.headers.get("X-Client-API-Key") # veya Authorization başlığı
        if not client_api_key or client_api_key != EXPECTED_CLIENT_API_KEY:
            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Geçersiz istemci API anahtarı")
    
    # ... (geri kalan kod)

Bu, sunucunuza yetkisiz erişimi engellemeye yardımcı olur. .env dosyanıza CLIENT_API_KEY="sizin_cok_gizli_anahtarınız" şeklinde ekleyebilirsiniz.

Adım 3: AI Modelleriyle Entegrasyon ve Test

Temel proxy mantığını kurduktan sonra, sıra onu gerçek AI modelleriyle entegre etmeye ve doğru çalıştığından emin olmak için test etmeye geliyor.

Yerel LLM Entegrasyonu (Ollama, Llama.cpp örnekleri)

Yerel LLM'ler, gizlilik ve maliyet avantajları nedeniyle popülerdir. Ollama, çeşitli LLM'leri yerel olarak çalıştırmayı kolaylaştıran harika bir araçtır. Eğer Ollama'yı kurduysanız ve bir model çalıştırıyorsanız (örneğin ollama run llama2), genellikle http://localhost:11434/v1/chat/completions adresinde bir OpenAI uyumlu API sunar.

.env dosyanızı aşağıdaki gibi güncelleyerek proxy'nizi Ollama'ya yönlendirebilirsiniz:

# .env
TARGET_AI_API_URL="http://localhost:11434/v1/chat/completions"
EXTERNAL_API_KEY="" # Yerel LLM kullanırken bu boş kalabilir

Bu sayede, Cursor'dan gelen tüm istekler önce MCP sunucunuza, oradan da yerel Ollama modelinize yönlendirilir.

Harici API'lerle Köprü Kurma (Claude, OpenAI API'leri)

Eğer daha güçlü veya spesifik modeller için harici API'lere ihtiyaç duyuyorsanız, MCP sunucunuzu bu API'lere köprü kuracak şekilde yapılandırabilirsiniz.

• Claude API için:

  Claude API, genellikle https://api.anthropic.com/v1/messages adresini kullanır. Ancak, Cursor gibi araçlar genellikle OpenAI'nin /v1/chat/completions formatını bekler. Bu durumda, proxy sunucunuzun gelen isteği Claude'un beklediği formata dönüştürmesi ve yanıtı da tekrar OpenAI formatına çevirmesi gerekir. Bu, main.py dosyanızda daha karmaşık bir dönüştürme mantığı gerektirecektir.

  Basit bir yaklaşımla, eğer Claude'un OpenAI uyumlu bir API katmanı varsa, onu kullanabilirsiniz. Aksi takdirde, TARGET_AI_API_URL'yi Claude'un endpoint'ine ayarlayıp, EXTERNAL_API_KEY'yi Claude API anahtarınızla doldurmanız gerekir. Ayrıca, Claude'un X-API-Key ve Anthropic-Version başlıklarını eklemek için main.py dosyasındaki başlık kısmını düzenlemeniz gerekecektir (yukarıdaki kod örneğinde yorum satırlarında belirtilmiştir).

  # .env
  TARGET_AI_API_URL="https://api.anthropic.com/v1/messages" # Claude'un mesajlar endpoint'i
  EXTERNAL_API_KEY="sk-ant-api03-YOUR_CLAUDE_API_KEY"

• OpenAI API için:

  OpenAI API, proxy'mizle en uyumlu olanıdır, çünkü /v1/chat/completions endpoint'ini doğrudan kullanır. Sadece .env dosyanızı güncelleyin:

  # .env
  TARGET_AI_API_URL="https://api.openai.com/v1/chat/completions"
  EXTERNAL_API_KEY="sk-YOUR_OPENAI_API_KEY"

Cursor ile Bağlantı Kurma

Cursor IDE'yi kendi MCP sunucunuza bağlamak oldukça basittir:

1. Cursor'ı açın.
2. Ayarlar'a (Settings) gidin (genellikle sol alttaki çark simgesi).
3. "AI Providers" veya "Language Model" ayarlarına gidin.
4. "Custom URL" veya "OpenAI Compatible API" seçeneğini arayın.
5. URL olarak kendi proxy sunucunuzun adresini girin: http://localhost:8000/v1/chat/completions (eğer sunucunuz 8000 portunda çalışıyorsa).
6. Gerekirse, eğer proxy'nizde kimlik doğrulama etkinse, "API Key" alanına CLIENT_API_KEY değerinizi girin.

Artık Cursor, tüm AI isteklerini sizin MCP sunucunuz üzerinden yapacak!

Sunucuyu Test Etme

Sunucunuzun doğru çalıştığından emin olmak için basit testler yapabilirsiniz.

1. Önce sunucuyu başlatın (bir sonraki adımda detaylıca anlatılacak, şimdilik manuel olarak):

   uvicorn main:app --host 0.0.0.0 --port 8000

2. Yeni bir terminal penceresi açın ve bir curl isteği gönderin:

   curl -X POST http://localhost:8000/v1/chat/completions \
        -H "Content-Type: application/json" \
        -d '{
              "model": "llama2",
              "messages": [
                {"role": "user", "content": "Merhaba, nasılsın?"}
              ],
              "temperature": 0.7
            }'

   Bu istek, proxy sunucunuza gidecek ve oradan TARGET_AI_API_URL'ye yönlendirilecektir. Yanıtı terminalinizde görmelisiniz.

3. Cursor'da bir AI isteği (örneğin kod tamamlama veya sohbet) deneyin ve yanıtın gelip gelmediğini kontrol edin.

Adım 4: Sunucuyu Dağıtma ve Yönetme

Sunucunuzu geliştirdikten ve test ettikten sonra, onu sürekli çalışır durumda tutmak ve yönetmek için uygun yöntemleri uygulamanız gerekir.

Uvicorn ile Sunucuyu Başlatma

Geliştirme sırasında kullandığımız uvicorn main:app --host 0.0.0.0 --port 8000 komutu, sunucuyu başlatır.

• main:app: main.py dosyasındaki app değişkenini belirtir.
• --host 0.0.0.0: Sunucunun tüm ağ arayüzlerinden erişilebilir olmasını sağlar (yerel ağınızdaki diğer cihazlardan erişmek için). Sadece kendi bilgisayarınızdan erişecekseniz 127.0.0.1 veya localhost kullanabilirsiniz.
• --port 8000: Sunucunun 8000 numaralı portta dinlemesini sağlar.

Üretim ortamında daha kararlı bir çalışma için --workers parametresiyle birden fazla worker süreci çalıştırabilirsiniz:

uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

Bu, sunucunuzun daha fazla eşzamanlı isteği işlemesine yardımcı olur.

Arka Planda Çalıştırma (systemd, pm2)

Sunucunuzun terminali kapattığınızda durmamasını sağlamak ve sistem yeniden başlatıldığında otomatik olarak başlamasını sağlamak önemlidir.

• Linux (systemd ile):

  Bir systemd servisi oluşturmak en sağlam yoldur. /etc/systemd/system/mcp_server.service adında bir dosya oluşturun:

  [Unit]
  Description=MCP Proxy Server
  After=network.target
  
  [Service]
  User=your_username # Kendi kullanıcı adınızla değiştirin
  WorkingDirectory=/path/to/your/mcp_server # Proje dizininizin tam yolu
  ExecStart=/path/to/your/mcp_server/venv/bin/uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4
  Restart=always
  
  [Install]
  WantedBy=multi-user.target

  Dosyayı kaydettikten sonra:

  sudo systemctl daemon-reload
  sudo systemctl start mcp_server
  sudo systemctl enable mcp_server # Sistem başlangıcında otomatik başlar
  sudo systemctl status mcp_server

• pm2 (Node.js tabanlı, ancak Python uygulamaları için de kullanılabilir):

  Eğer Node.js yüklüyse, pm2 kullanışlı bir araçtır:

  npm install -g pm2
  pm2 start "uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4" --name "mcp_server"

  pm2 startup komutu ile sistem başlangıcında otomatik başlamasını sağlayabilirsiniz.

• Basit Arka Plan Çalıştırma (geçici):

  nohup ve & kullanarak terminali kapatsanız bile çalışmasını sağlayabilirsiniz, ancak bu yöntem systemd kadar sağlam değildir:

  nohup uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4 &

Güvenlik Duvarı ve Ağ Yapılandırması

Eğer sunucunuza yerel ağınız dışından erişim sağlamak istiyorsanız (ki bu genellikle önerilmez, ancak gerekirse), güvenlik duvarınızda 8000 numaralı portu açmanız gerekebilir.

• Linux (UFW ile):

  sudo ufw allow 8000/tcp
  sudo ufw enable

• Windows: Windows Defender Güvenlik Duvarı ayarlarından 8000 portunu gelen bağlantılar için izin vermelisiniz.

Eğer sunucunuzu internete açıyorsanız, mutlaka güçlü kimlik doğrulama ve HTTPS (SSL/TLS) kullanmalısınız. Bunun için Nginx veya Caddy gibi bir ters proxy (reverse proxy) kullanmak en iyi yöntemdir.

İzleme ve Güncelleme

• Loglar: Sunucunuzun loglarını düzenli olarak kontrol edin (systemctl status mcp_server veya pm2 logları). FastAPI ve Uvicorn, varsayılan olarak terminale önemli bilgileri basar.
• Güncellemeler: Python kütüphanelerinizi ve işletim sisteminizi düzenli olarak güncelleyin.