MCP vs Function Calling vs Tool Use: Hangisini Seçmeli?

LLM’inize bir araç bağlamak istiyorsunuz. Dökümantasyona bakıyorsunuz; karşınıza üç farklı terim çıkıyor: MCP, function calling, tool use. Bunlar birbirinden farklı mı, yoksa aynı şeyin farklı isimleri mi? Hangisini ne zaman kullanmalısınız?

Mimari farkları, kod örnekleri ve seçim kriterlerini burada karşılaştırıyoruz.

Hızlı Karşılaştırma Tablosu

MCP: Standartlaşmış Araç Katmanı

Model Context Protocol (MCP), Anthropic’in 2024 sonunda yayımladığı açık bir standarttır. Hedefi basittir: LLM’leri harici araçlara bağlamak için her projede sıfırdan yeniden yazılan kodun önüne geçmek.

MCP mimarisi üç bileşen üzerine kuruludur:

• MCP Server: Araçları tanımlayan ve çalıştıran ayrı bir süreç. Dosya okuma, veritabanı sorgusu, web araması gibi fonksiyonlar burada yaşar.
• MCP Client: LLM uygulaması. Server’a bağlanır, mevcut araçları keşfeder, çağrıları iletir.
• Host: İkisini koordine eden ortam (Claude Desktop, VS Code, Cursor gibi).

İletişim JSON-RPC 2.0 üzerinden akar. Bir araç MCP server’da bir kez tanımlanır; Claude, GPT-4o, Gemini gibi farklı modeller aynı server’a bağlanabilir. Bu “bir kez yaz, her yerde çalıştır” modeli, özellikle çok araçlı sistemlerde bakım yükünü ciddi ölçüde azaltır.

Güçlü yanları araç bağımsızlığı ve yeniden kullanılabilirliktir. Server izolasyonu da önemli: server çökse host ve diğer istemciler etkilenmez. GitHub, Slack, Jira, Notion gibi hazır topluluk server’ları da mevcut.

Dezavantaj tarafında ek server kurulumu ve bakımı bekleniyor. Küçük projeler için bu başlangıç yatırımı gereksiz karmaşıklık katabilir; debugging için de bir katman daha ekleniyor.

Function Calling: Doğrudan API Araç Çağrısı

Function calling, OpenAI’nın 2023’te tanıttığı ve bugün Gemini, Mistral ve pek çok sağlayıcının benimsediği API düzeyinde bir mekanizmadır.

Çalışma mantığı şöyle: Uygulamanız, API çağrısına araç tanımlarını JSON schema formatında ekler. Model, kullanıcının isteğini değerlendirir, hangi aracı çağıracağına karar verir ve argümanları üretir. Uygulamanız bu argümanlarla gerçek fonksiyonu çalıştırır, sonucu modele geri gönderir ve döngü tamamlanır.

Araçlar uygulamanın içinde yaşar, ayrı bir server yoktur. Başlangıç için en az dirençli yol bu.

Güçlü yanı kurulum gerektirmemesi: API çağrısına ek parametreler yeterli. Python, TypeScript ve Go için resmi SDK’lar ve pek çok üçüncü taraf entegrasyon mevcut.

Kısıtı ise vendor bağımlılığı. OpenAI schema’sı Anthropic API’siyle doğrudan uyumlu değil; araçlar uygulamaya bağlı olduğundan başka projede tekrar yazılması gerekiyor.

Tool Use: Anthropic’in Araç Mekanizması

“Tool use” kavramsal olarak function calling ile eş anlamlıdır; fark terminoloji ve Claude API’sinin spesifik yapısındadır.

Claude API’sinde araçlar tools dizisinde tanımlanır. Model bir araç çağırmaya karar verdiğinde tool_use tipiyle bir içerik bloğu döndürür. Uygulamanız bu çağrıyı işler ve sonucu tool_result bloğuyla bir sonraki mesajda geri gönderir.

import anthropic

client = anthropic.Anthropic()

tools = [
    {
        "name": "get_weather",
        "description": "Belirtilen şehrin anlık hava durumu bilgisini döndürür.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "Şehir adı"}
            },
            "required": ["city"]
        }
    }
]

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "İstanbul'da hava nasıl?"}]
)

MCP ile karşılaştırıldığında fark belirgindir: tool use’ta araç tanımı API çağrısının içindedir, MCP’de ise ayrı bir server katmanında yaşar. Kendi MCP server’ı Python ile yazmak isteyenler için bu rehber iyi bir başlangıç noktası.

Kod Örnekleri: Aynı Araç, Üç Yaklaşım

Aynı hava durumu aracını üç yaklaşımla karşılaştırdığımızda fark netleşiyor.

Tool Use (Claude API)

import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "get_weather",
    "description": "Şehrin hava durumunu döndürür.",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {"type": "string"}
        },
        "required": ["city"]
    }
}]

def get_weather(city: str) -> str:
    return f"{city}: 22°C, güneşli"

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "İstanbul havası?"}]
)

if response.stop_reason == "tool_use":
    tool_call = next(b for b in response.content if b.type == "tool_use")
    result = get_weather(tool_call.input["city"])
    print(result)

Function Calling (OpenAI API)

from openai import OpenAI
import json

client = OpenAI()

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Şehrin hava durumunu döndürür.",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }
}]

def get_weather(city: str) -> str:
    return f"{city}: 22°C, güneşli"

response = client.chat.completions.create(
    model="gpt-4o",
    tools=tools,
    messages=[{"role": "user", "content": "İstanbul havası?"}]
)

if response.choices[0].finish_reason == "tool_calls":
    tool_call = response.choices[0].message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    result = get_weather(args["city"])
    print(result)

MCP Server (Python SDK)

# server.py — bir kez yaz, her istemci kullansın
from mcp.server import Server
from mcp.server.stdio import stdio_server
import mcp.types as types
import asyncio

app = Server("weather-server")

@app.list_tools()
async def list_tools():
    return [
        types.Tool(
            name="get_weather",
            description="Şehrin hava durumunu döndürür.",
            inputSchema={
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "get_weather":
        city = arguments["city"]
        return [types.TextContent(type="text", text=f"{city}: 22°C, güneşli")]

async def main():
    async with stdio_server() as (read, write):
        await app.run(read, write, app.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

Üç yaklaşımda da get_weather fonksiyonu aynı işi yapıyor. MCP’deki kritik fark: server kodu bir kez yazılıyor, Claude Desktop’tan VS Code’a kadar her istemci bağlanabiliyor. Function calling ve tool use’ta ise araç tanımı her API çağrısında taşınıyor.

Projen İçin Hangisi?

Karar dört temel senaryo üzerinden netleşir:

1. Çok araçlı, çok model ekosistemi → MCP On’dan fazla araç var, birden fazla model kullanıyorsunuz ya da araçları birden fazla uygulamada paylaşmak istiyorsunuz. MCP’nin server/client ayrımı burada gerçek değer üretiyor. Kendi AI agent’ınızı sıfırdan inşa etmeyi düşünüyorsanız, MCP altyapısıyla başlamak uzun vadede bakım yükünü önemli ölçüde düşürür.

2. Hızlı prototip, tek vendor → Function Calling Hızlı bir MVP çıkarmanız gerekiyor, OpenAI veya Gemini kullanıyorsunuz ve araç sayısı az. Function calling burada en düşük dirençli yol; ek kurulum yok, birkaç satır kodla çalışmaya başlıyor.

3. Claude odaklı uygulama, basit araç seti → Tool Use Yalnızca Claude ile çalışıyorsunuz ve karmaşık bir araç ekosistemi planlamıyorsunuz. Tool use, Claude API’siyle yerleşik şekilde çalışır; MCP server kurma yükünü ortadan kaldırır.

4. Mevcut function calling projesini büyütmek → Önce mevcut, sonra MCP katmanı Çalışan bir function calling projeniz var. Araç sayısı artmaya başladıysa ya da farklı modeller eklemeyi düşünüyorsanız, MCP’ye kademeli geçiş mantıklıdır. Tüm araçları bir anda taşımak gerekmez; önce en çok paylaşılan araçları MCP server’a alıp geri kalanı dönüştürebilirsiniz.

Sık Yapılan Hatalar

1. Tek araç için MCP kurmak İki-üç araçlı bir proje için MCP server kurmak aşırı mühendisliktir. Bu ölçekte tool use veya function calling yeterlidir; altyapı yükü değer üretmez.

2. Function calling schema’sını modeller arası kopyalamak OpenAI’ın function formatı Anthropic API’siyle doğrudan uyumlu değildir. Farklı modeller için schema’yı ayrı ayrı yazmak gerekir; aksi takdirde sessiz hatalar ya da API hataları alınır.

3. Tool use ile function calling’i iki ayrı konsept sanmak İkisi aynı mekanizmanın farklı isimleri. Tool use, Anthropic’in kullandığı terim; function calling ise OpenAI’nın popülerleştirdiği ad. Temel işleyiş özdeş: model argüman üretir, uygulama çalıştırır, sonuç geri beslenir.

4. MCP server’ı global state ile çalıştırmak MCP server’lar stateless çalışmalıdır. Global state tutmak, çoklu istemci senaryolarında beklenmedik davranışlara ve zor takip edilen hatalara yol açar.

5. Araç tanımlarında belirsiz description yazmak Modelin doğru aracı seçmesi büyük ölçüde description alanına bağlıdır. “Hava durumu getirir” yerine “Belirtilen şehrin güncel sıcaklığını ve hava koşullarını OpenWeather API’den döndürür” gibi spesifik bir tanım, model kararlarını belirgin şekilde iyileştirir.

Seçim Kriterleri Özeti

JSON schema konusunda kesinlik arıyorsanız Structured Outputs ve Pydantic rehberimiz şema yazımını detaylandırıyor. Bir framework üzerinden araç bağlamayı tercih edenler için LangChain entegrasyonu farklı bir yol sunuyor.

Araç sayısı ikinin altındaysa function calling veya tool use yeterli. Farklı modeller veya ekipler aynı araç setini paylaşmaya başladığında MCP’ye geçmek için doğru zaman gelmiş olur.