Claude'da Model, Effort ve Adaptive Thinking: Kalite, Hız ve Maliyet Dengesi

Sürüm notu: Bu yazıdaki kodlar .NET 10, Anthropic C# SDK 13.8.0 ve Claude API version 2026-10-21 ile derlenmiş, birim testleri ve değerlendirme aracının fiyat hesabı modu çalıştırılmıştır. Model listesi, fiyatlar, varsayılan effort değerleri ve thinking davranışı 15 Kasım 2026'da platform.claude.com'daki models overview, pricing, effort ve thinking sayfalarından alınmıştır. Bu yazıda resmî belgelerden yararlanılmıştır; fiyatlar değişebilir, kullanmadan önce pricing sayfasına bak.

Önce Tahmin Et

Product Owner Selin, sitedeki serilerin ortak örnek uygulaması Bookstore (bir online kitapçı) için iade taleplerini otomatik sınıflandırmak istiyor: "Hasarlı geldi", "yanlış kitap geldi", "vazgeçtim" gibi altı etiket. Ekipteki görüş ikiye ayrılmış. Ayşe "en iyi model hangisiyse onu kullanalım, yanlış etiket pahalıya patlar" diyor. Emre ise "bu bir sınıflandırma, en ucuz model yeter" diyor.

Tahminin ne? Opus 5.5'i düşük effort'ta çalıştırmak mı, Sonnet 5.5'i yüksek effort'ta çalıştırmak mı daha pahalıya gelir? Ve bir sınıflandırma görevinde thinking'in açık olması ne değiştirir? Bu yazıda güncel Claude modellerini, output_config.effort parametresini ve adaptive thinking'i göreceğiz, sonra bu soruyu tahminle değil ölçerek cevaplayacak küçük bir değerlendirme aracı yazacağız. Maliyet ve latency'nin sağlayıcıdan bağımsız mantığı LLM Temelleri serisinin on altıncı yazısında anlatıldı.

Güncel Model Ailesi (15 Kasım 2026)

Models overview sayfasındaki dört güncel model:

MTok bir milyon token demek. Dördünün de context window'u 1M token ve senkron Messages API'de çıktı sınırı 128K token. Haiku 5.5'in fiyatı prompt uzunluğuna bağlı: prompt 100.000 token'ı aşarsa input 0,50 ve output 2,50 dolara çıkıyor. Prompt uzunluğuna cache'ten okunan ve cache'e yazılan token'lar da dahil. Diğer modeller 1M token'ın tamamında aynı fiyatı uyguluyor; pricing sayfası 900K token'lık bir isteğin 9K token'lık bir istekle aynı birim fiyatı ödediğini söylüyor. Message Batches yüzde 50 indirimli. Cache okumaları normalde input fiyatının yüzde 10'u; Opus 5.5 ve Sonnet 5.5'te yüzde 5, Fable 5.2'de yüzde 2,5.

Belgenin önerisi şu: emin değilsen çoğu iş için Opus 5.5 ile başla. Fable 5.2 zorlu akıl yürütme ve uzun soluklu agent işleri için, ya da Opus 5.5 yüksek effort'ta bile yetmediğinde. Haiku 5.5 sınıflandırma, extraction ve routing gibi yüksek hacimli, latency'ye duyarlı işler için tarif ediliyor. "Choosing a model" sayfası iki yaklaşım sunuyor: Haiku 5.5 ile başlayıp yalnız gerekirse yukarı çıkmak, ya da Opus 5.5 ile başlayıp effort'u veya modeli zamanla düşürmek. Sayfa ayrıca effort'u ayarlamanın çoğu zaman model değiştirmekten daha etkili olduğunu söylüyor. Bizim görevimiz tam olarak birinci yaklaşımın tarif ettiği iş.

Eski modellerin takvimi de önemli. Model deprecations sayfasına göre Claude Sonnet 4.5 (claude-sonnet-4-5-20250929) 30 Kasım 2026'da Claude API'de emekliye ayrılıyor ve önerilen yerine geçen claude-sonnet-5-5. Kodunda eski bir model ID'si varsa bu tarihten sonra istekler başarısız olur. Models API'deki lifecycle ve retires_at alanları bunu programatik olarak izlemeni sağlıyor.

Effort: Kalite, Hız ve Maliyet Ayarı

Effort, isteğe output_config.effort ile verilen tek bir değer: low, medium, high, xhigh ya da max. Effort sayfasına göre bu değer yalnız thinking'i değil cevabın bütün token'larını etkiliyor: metin, tool çağrıları ve argümanları, thinking. Düşük effort daha az ve daha kısa tool çağrısı demek. Belge bunun katı bir token bütçesi değil, davranışsal bir sinyal olduğunu vurguluyor: düşük effort'ta da model zor bir soruda düşünüyor, sadece daha az.

Dikkat edilecek ilk nokta varsayılanlar. Çoğu modelde varsayılan high; Opus 5.5 ve Haiku 5.5'te medium. Yani Opus 5'ten Opus 5.5'e geçen ve effort göndermeyen bir istek, belgenin deyişiyle bir seviye aşağıda çalışıyor. Varsayılan değeri açıkça göndermek, hiç göndermemekle tamamen aynı davranışı veriyor. İkinci nokta xhigh ve max: her modelde yok. Güncel dört modelde beşi de var, ama eski bir modele geçersen Models API'deki capabilities.effort alanına bakman gerekiyor.

Model bazlı öneriler kısaca şöyle. Haiku 5.5 için belge çoğu iş için medium ile başlamayı, sohbet ve basit yüksek hacimli işler için low'u öneriyor; ama uzun agent prompt'larında low'da modelin bir aramayı atlayabileceği ya da erken durabileceği uyarısını da yapıyor. Sonnet 5.5'te sohbet ve latency'ye duyarlı işler için medium ya da low. Opus 5.5'te xhigh veya max kullanıyorsan büyük bir max_tokens ver; bu sınır thinking dahil toplam çıktının katı sınırı. Hepsinde ortak tavsiye aynı: ayarı eski modelden kopyalama, kendi değerlendirme setinde bir effort taraması yap.

Adaptive Thinking: Hangi Modelde Neyi Kapatabilirsin?

Güncel modellerde thinking varsayılan olarak açık ve adaptive: modelin ne kadar düşüneceğine kendisi karar veriyor, effort bu kararı yönlendiriyor. Thinking sayfasındaki tablodan dört model için ilgili kısım:

Buradan üç sonuç çıkıyor. Eski thinking: {type: "enabled", budget_tokens: ...} ayarı dört modelin hiçbirinde çalışmıyor, 400 dönüyor. Opus 5.5 ve Fable 5.2'de thinking kapatılamıyor; maliyeti ve derinliği yalnız effort ile kontrol ediyorsun. Sonnet 5.5'te disabled yerine between_tools var: cevaptan önceki düşünmeyi kapatıyor ama tool çağrıları arasındaki kısa ilerleme notları devam ediyor.

display alanı thinking metninin sana dönüp dönmeyeceğini belirliyor. Güncel modellerde varsayılan omitted: thinking block'u geliyor ama thinking alanı boş. summarized istersen modelin akıl yürütmesinin bir özeti dönüyor; ham akıl yürütme hiçbir ayarla dönmüyor. Faturalama ikisinde de aynı. Belge iki noktayı ayrıca belirtiyor: özet yerine orijinal thinking token'larının tamamı faturalanıyor, yani gördüğün metin ile faturadaki sayı tutmuyor; omitted'ın faydası maliyet değil, streaming'de ilk text token'ının daha erken gelmesi.

SDK'da bu ayarlar ThinkingConfigParam union'ına implicit dönüşen class'lar. Sınıflandırıcının ayarına isteğe bağlı bir thinking alanı ekledik:

// Haiku 5.5: effort high ve altında thinking kapatılabilir
ClassifierSettings haiku = new("claude-haiku-5-5", Effort.Low, new ThinkingConfigDisabled());

// Sonnet 5.5: "disabled" 400 verir; up-front thinking'i between_tools kapatır
ClassifierSettings sonnet = new("claude-sonnet-5-5", Effort.Medium, new ThinkingConfigBetweenTools());

// Opus 5.5: thinking kapatılamaz; yalnız display değişir
ClassifierSettings opus = new("claude-opus-5-5", Effort.High, new ThinkingConfigAdaptive { Display = Display.Summarized });

RawBodyData'dan (system ve messages alanları çıkarılmış hâlde) üç isteğin gövdesi; üçüncüsünde fast mode da açık:

{"model":"claude-haiku-5-5","max_tokens":2048,"output_config":{"effort":"low"},"thinking":{"type":"disabled"}}
{"model":"claude-sonnet-5-5","max_tokens":2048,"output_config":{"effort":"medium"},"thinking":{"type":"between_tools"}}
{"model":"claude-opus-5-5","max_tokens":2048,"output_config":{"effort":"high"},"thinking":{"type":"adaptive","display":"summarized"},"speed":"fast"}

Fast Mode ve Task Budgets

Fast mode, aynı modeli daha hızlı bir inference ayarıyla çalıştırıyor. Fast mode sayfasına göre saniyedeki output token'ı 2,5 kata kadar artıyor; kazanç ilk token süresinde değil çıktı hızında. Güncel modellerde Fable 5.2 ve Opus 5.5'te var. Opus 5.5 için fiyat input 8, output 40 dolar, yani normal fiyatın iki katı; beta header gerekmiyor. Fast mode'un ayrı bir rate limit'i var, aşılınca retry-after header'lı bir 429 dönüyor, ve Batch API ile kullanılamıyor. SDK'da isteğin Speed property'si:

MessageCreateParams fast = ReturnClassifier.BuildRequest("It arrived wet.", opus) with { Speed = Speed.Fast };

Bookstore'da bunu yalnız kullanıcının beklediği, uzun cevap üreten işlerde düşünürüz; bir iade sınıflandırması için gereksiz.

Task budgets ise beta (task-budgets-2026-03-13 header'ı ile). output_config.task_budget ile modele bir agent döngüsünün tamamı için token bütçesi veriyorsun; model kalan bütçeyi görüp işini ona göre bitiriyor. Belge bunun effort'un yerine geçmediğini, onu tamamladığını söylüyor: effort her adımın ne kadar dikkatli düşünüleceğini, task budget toplam işin sınırını belirliyor. Agent döngüsünü beşinci yazıda kuracağız.

Bookstore: İade Talebi Sınıflandırıcı

Sınıflandırıcı kısa bir system prompt, tek bir user mesajı ve effort'tan oluşuyor:

using Anthropic;
using Anthropic.Models.Messages;
using Bookstore.Api.Ai;

namespace Bookstore.Api.Returns;

public sealed record ClassifierSettings(string Model, Effort Effort, ThinkingConfigParam? Thinking = null);

public sealed record Classification(ReturnReason? Reason, string RawText, ReplyOutcome Outcome, TokenUsage Usage);

public sealed class ReturnClassifier(IAnthropicClient claude)
{
    public const string SystemPrompt = """
        You classify return requests for Bookstore, an online bookstore.
        Reply with exactly one label and nothing else:
        Damaged, WrongItem, NotAsDescribed, ChangedMind, LateDelivery, Other.
        Damaged: the book arrived torn, wet or broken. WrongItem: a different title or edition arrived.
        NotAsDescribed: the book differs from the product page. ChangedMind: the customer no longer wants it.
        LateDelivery: it arrived too late to be useful. Other: anything else.
        """;

    public static MessageCreateParams BuildRequest(string requestText, ClassifierSettings settings)
    {
        MessageCreateParams request = new()
        {
            Model = settings.Model,
            // Cevap kısa ama yüksek effort'ta thinking için yer bırak.
            MaxTokens = 2048,
            System = SystemPrompt,
            OutputConfig = new OutputConfig { Effort = settings.Effort },
            Messages = [new UserMessageParam { Content = requestText }],
        };

        // İstenmedikçe thinking gönderme: her modelin kendi varsayılanı var.
        return settings.Thinking is null ? request : request with { Thinking = settings.Thinking };
    }

    public async Task<Classification> ClassifyAsync(string requestText, ClassifierSettings settings, CancellationToken cancellationToken)
    {
        Message message = await claude.Messages.Create(BuildRequest(requestText, settings), cancellationToken);
        ClaudeReply reply = ClaudeReplyReader.Read(message);
        return new Classification(ParseLabel(reply.Text), reply.Text, reply.Outcome, reply.Usage);
    }

    public static ReturnReason? ParseLabel(string text) =>
        Enum.TryParse(text.Trim().TrimEnd('.'), ignoreCase: true, out ReturnReason reason) ? reason : null;
}

Etiketleri system prompt'ta tanımlarıyla verdik; Prompt Engineering serisinin classification yazısında etiket açıklamalarının neden önemli olduğunu konuşmuştuk. Cevabı Enum.TryParse ile alıyoruz ve tek bir etiket dışında bir şey gelirse null dönüyoruz. Bu yaklaşımın zayıf noktası belli: model "The book is damaged" gibi bir cümle yazarsa sınıflandırma kaybolur. Altıncı yazıda aynı görevi structured outputs ile şemaya bağlayacağız.

MaxTokens 2048. Cevap tek kelime ama Haiku 5.5 medium'da da düşünebiliyor ve thinking max_tokens'a dahil. Sınırı dar tutup cevabın max_tokens ile kesildiğini görmek, en sık yaşanan hatalardan biri.

Fiyat hesabını da bir sınıfa koyduk:

namespace Bookstore.Api.Ai;

// Milyon token başına USD; kaynak platform.claude.com/docs/en/about-claude/pricing (2026-11-15'te kontrol edildi).
public sealed record ModelPrice(decimal Input, decimal CacheWrite5m, decimal CacheRead, decimal Output);

public static class ClaudePricing
{
    private const long HaikuLongPromptThreshold = 100_000;

    private static readonly Dictionary<string, ModelPrice> Prices = new()
    {
        ["claude-fable-5-2"] = new(8.00m, 10.00m, 0.20m, 40.00m),
        ["claude-opus-5-5"] = new(4.00m, 5.00m, 0.20m, 20.00m),
        ["claude-sonnet-5-5"] = new(2.00m, 2.50m, 0.10m, 10.00m),
        ["claude-haiku-5-5"] = new(0.10m, 0.125m, 0.01m, 0.50m),
    };

    // Haiku 5.5'te prompt (input + cache read + cache write) 100.000 token'ı aşınca fiyat yükselir.
    private static readonly ModelPrice HaikuLongPrompt = new(0.50m, 0.625m, 0.05m, 2.50m);

    public static IReadOnlyCollection<string> KnownModels => Prices.Keys;

    public static decimal EstimateUsd(string model, TokenUsage usage)
    {
        if (!Prices.TryGetValue(model, out ModelPrice? price))
        {
            throw new ArgumentException($"No price for model '{model}'.", nameof(model));
        }

        long promptTokens = usage.Input + usage.CacheRead + usage.CacheWrite;
        if (model == "claude-haiku-5-5" && promptTokens > HaikuLongPromptThreshold)
        {
            price = HaikuLongPrompt;
        }

        // Thinking token'ları zaten Output'un içinde; ayrı bir fiyatları yok.
        decimal total = usage.Input * price.Input
                        + usage.CacheWrite * price.CacheWrite5m
                        + usage.CacheRead * price.CacheRead
                        + usage.Output * price.Output;
        return total / 1_000_000m;
    }
}

Testler hem etiket ayrıştırmayı hem de fiyat formülünü sabitliyor:

using System.Text.Json;
using Anthropic.Models.Messages;
using Bookstore.Api.Ai;
using Bookstore.Api.Returns;

namespace Bookstore.Api.Tests;

public sealed class ReturnClassifierTests
{
    [Theory]
    [InlineData("Damaged", ReturnReason.Damaged)]
    [InlineData(" wrongitem.\n", ReturnReason.WrongItem)]
    [InlineData("The book is damaged", null)]
    public void ParseLabel_AcceptsOnlyOneLabel(string text, ReturnReason? expected) =>
        Assert.Equal(expected, ReturnClassifier.ParseLabel(text));

    [Fact]
    public void BuildRequest_SendsEffortInOutputConfig()
    {
        MessageCreateParams request = ReturnClassifier.BuildRequest("It arrived wet.", new ClassifierSettings("claude-haiku-5-5", Effort.Low));
        JsonElement body = JsonSerializer.SerializeToElement(request.RawBodyData);

        Assert.Equal("low", body.GetProperty("output_config").GetProperty("effort").GetString());
        Assert.False(body.TryGetProperty("thinking", out _));
    }

    [Fact]
    public void BuildRequest_HaikuWithThinkingDisabled()
    {
        MessageCreateParams request = ReturnClassifier.BuildRequest("It arrived wet.",
            new ClassifierSettings("claude-haiku-5-5", Effort.Low, new ThinkingConfigDisabled()));
        JsonElement body = JsonSerializer.SerializeToElement(request.RawBodyData);

        Assert.Equal("disabled", body.GetProperty("thinking").GetProperty("type").GetString());
    }
}

public sealed class ClaudePricingTests
{
    [Fact]
    public void EstimateUsd_UsesBaseInputAndOutputPrices()
    {
        // Sonnet 5.5'te 1M input + 1M output: $2 + $10.
        decimal cost = ClaudePricing.EstimateUsd("claude-sonnet-5-5", new TokenUsage(1_000_000, 1_000_000, 0, 0, 0));
        Assert.Equal(12.00m, cost);
    }

    [Fact]
    public void EstimateUsd_HaikuPromptOver100kUsesTheHigherPrice()
    {
        decimal shortPrompt = ClaudePricing.EstimateUsd("claude-haiku-5-5", new TokenUsage(100_000, 0, 0, 0, 0));
        decimal longPrompt = ClaudePricing.EstimateUsd("claude-haiku-5-5", new TokenUsage(100_001, 0, 0, 0, 0));

        Assert.Equal(0.01m, shortPrompt);
        Assert.Equal(0.0500005m, longPrompt);
    }
}

Passed!  - Failed:     0, Passed:    14, Skipped:     0, Total:    14, Duration: 53 ms - Bookstore.Api.Tests.dll (net10.0)

Küçük Bir Değerlendirme Düzeneği

Ayşe ile Emre'nin tartışmasının cevabı modelin genel başarısında değil, bu görevdeki başarısında. Bunu ölçmek için 12 örnekli küçük bir değerlendirme seti (returns-eval.json) ve her model ve effort kombinasyonu için doğruluk, medyan latency, output token'ı ve maliyet yazan bir console aracı hazırladık. Değerlendirmenin genel yöntemini .NET ile Yapay Zeka serisinin onuncu yazısında ve Prompt Engineering serisinin son yazısında ele almıştık.

using System.Diagnostics;
using System.Globalization;
using System.Text.Json;
using Anthropic;
using Anthropic.Models.Messages;
using Bookstore.Api.Ai;
using Bookstore.Api.Returns;

// Kullanım:
// dotnet run -- estimate [inputTokens] [outputTokens]   yalnız fiyat hesabı, API çağrısı yok
// dotnet run -- run                                     ANTHROPIC_API_KEY gerekir, API'yi çağırır
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
string mode = args.Length > 0 ? args[0] : "estimate";

if (mode == "estimate")
{
    long input = args.Length > 1 ? long.Parse(args[1]) : 450;
    long output = args.Length > 2 ? long.Parse(args[2]) : 60;
    TokenUsage perRequest = new(input, output, CacheRead: 0, CacheWrite: 0, Thinking: 0);

    Console.WriteLine($"Assumed tokens per request: input={input} output={output}");
    Console.WriteLine($"{"model",-20}{"per request",14}{"per 1,000",12}");
    foreach (string model in ClaudePricing.KnownModels)
    {
        decimal one = ClaudePricing.EstimateUsd(model, perRequest);
        Console.WriteLine($"{model,-20}{one,14:0.000000}{one * 1000,12:0.0000}");
    }

    return;
}

List<EvalCase> cases = JsonSerializer.Deserialize<List<EvalCase>>(
    File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "returns-eval.json")),
    new JsonSerializerOptions(JsonSerializerDefaults.Web))!;

// Her satır bir konfigürasyon; Haiku 5.5 bir kez de thinking kapalı koşar.
(string Model, Effort Effort, ThinkingConfigParam? Thinking)[] grid =
[
    ("claude-haiku-5-5", Effort.Low, new ThinkingConfigDisabled()),
    ("claude-haiku-5-5", Effort.Low, null),
    ("claude-haiku-5-5", Effort.Medium, null),
    ("claude-sonnet-5-5", Effort.Low, null),
    ("claude-sonnet-5-5", Effort.Medium, null),
    ("claude-sonnet-5-5", Effort.High, null),
    ("claude-opus-5-5", Effort.Low, null),
    ("claude-opus-5-5", Effort.Medium, null),
    ("claude-opus-5-5", Effort.High, null),
];

using AnthropicClient client = new();
ReturnClassifier classifier = new(client);

Console.WriteLine($"{"model",-20}{"effort",-8}{"thinking",-10}{"accuracy",10}{"p50 ms",9}{"out tok",9}{"USD",10}");
foreach ((string model, Effort effort, ThinkingConfigParam? thinking) in grid)
{
    int correct = 0;
    long outputTokens = 0;
    decimal cost = 0;
    List<long> latencies = [];

    // Bilerek sıralı: küçük bir eval rate limit'e takılmamalı.
    foreach (EvalCase item in cases)
    {
        Stopwatch watch = Stopwatch.StartNew();
        Classification result = await classifier.ClassifyAsync(item.Text, new ClassifierSettings(model, effort, thinking), CancellationToken.None);
        latencies.Add(watch.ElapsedMilliseconds);

        correct += result.Reason?.ToString() == item.Expected ? 1 : 0;
        outputTokens += result.Usage.Output;
        cost += ClaudePricing.EstimateUsd(model, result.Usage);
    }

    latencies.Sort();
    Console.WriteLine($"{model,-20}{effort.ToString().ToLowerInvariant(),-8}{(thinking is null ? "default" : "off"),-10}{(double)correct / cases.Count,10:P0}{latencies[latencies.Count / 2],9}{outputTokens,9}{cost,10:0.0000}");
}

internal sealed record EvalCase(string Text, string Expected);

Aracın iki modu var. run modu kendi ANTHROPIC_API_KEY'inle 9 konfigürasyonu 12 örnek üzerinde, yani 108 istekle çalıştırıyor ve her satırda doğruluk, p50 latency, toplam output token ve maliyeti yazıyor. estimate modu API'yi hiç çağırmıyor: verdiğin varsayılan token sayılarıyla her model için istek başına ve 1.000 istek başına fiyatı hesaplıyor. Varsayılan değerler 450 input ve 60 output token; bunlar hesap için seçtiğimiz varsayımlar, API'den gelen sayılar değil:

cd tools/Bookstore.ClaudeEval
dotnet run -- estimate
dotnet run -- estimate 1200 300

Assumed tokens per request: input=450 output=60
model                  per request   per 1,000
claude-fable-5-2          0.006000      6.0000
claude-opus-5-5           0.003000      3.0000
claude-sonnet-5-5         0.001500      1.5000
claude-haiku-5-5          0.000075      0.0750
Assumed tokens per request: input=1200 output=300
model                  per request   per 1,000
claude-fable-5-2          0.021600     21.6000
claude-opus-5-5           0.010800     10.8000
claude-sonnet-5-5         0.005400      5.4000
claude-haiku-5-5          0.000270      0.2700

Aynı token sayısında Opus 5.5 Haiku 5.5'in 40 katı, Sonnet 5.5 20 katı. Ama gerçek tabloda token sayıları aynı olmayacak: effort ve thinking, özellikle output token'ını modelden modele değiştiriyor. Bu yüzden run modunun çıktısında ilk bakacağın sütun out tok. Orada iki şey görürsün: thinking'i kapalı Haiku satırının output token'ının diğer Haiku satırlarına göre nasıl değiştiği ve Opus'ta low ile high arasındaki fark.

Tabloyu okurken şu soruları sor. En ucuz satır doğrulukta en pahalısından kaç örnek geride? 12 örnekte bir hata yüzde 8 eder; karar vermeden önce seti büyüt. Hatalar hangi etiketlerde toplanıyor? NotAsDescribed ile WrongItem karışıyorsa sorun büyük ihtimalle etiket tanımında, model değiştirerek çözülmez. p50 latency kullanıcı akışında önemli mi? İade formu gönderildikten sonra arka planda çalışan bir sınıflandırma için birkaç saniyelik fark çoğu zaman önemsiz.

Ölçmeden önceki ilk adayımız Haiku 5.5, low effort ve thinking kapalı; run modunun tablosu bu adayı ya doğrulayacak ya da bir üst satıra taşıyacak. Değerlendirme seti büyüdükçe ve gerçek taleplerden örnek eklendikçe tablo yeniden çalıştırılmalı.

Üretimde Dikkat

Effort'u açıkça gönder. Varsayılanlar modelden modele değişiyor ve yeni bir model sürümüne geçtiğinde sessizce farklı bir effort'ta çalışabiliyorsun. Değeri configuration'da tut ve log'a yaz.

Model ID'sini configuration'da tut. İlk yazıdaki ClaudeOptions.Model bu yüzden var. Bir modelin emeklilik tarihi geldiğinde değişiklik bir deploy değil, bir ayar değişikliği olmalı. Models API'yi düzenli sorgulayıp deprecated olan bir modeli kullanıyorsan uyarı üret.

Maliyeti log'dan hesapla. ClaudePricing gibi bir tablo, her isteğin usage'ından maliyet yazmanı sağlıyor. Fiyat tablosunu koda gömdüğün için pricing sayfasındaki değişiklikleri takip etmen gerekiyor; son yazıda Console'daki maliyet raporlarıyla karşılaştırmayı göreceğiz.

Değerlendirme setini sürümle. Model ya da effort değiştirmeden önce aynı seti yeniden çalıştır. Set, üretimden gelen gerçek ama anonimleştirilmiş örneklerle büyümeli; müşteri adı ve sipariş numarası sete girmemeli.

Sık Düşülen Tuzaklar

budget_tokens göndermek. Eski extended thinking ayarı güncel modellerin hiçbirinde çalışmıyor, 400 dönüyor. Thinking derinliğini effort ile yönet.

Opus 5.5'te thinking'i kapatmaya çalışmak. disabled 400 veriyor. Sonnet 5.5'te de disabled yok; doğrusu between_tools.

Effort'u hiç ayarlamamak. Opus 5.5 medium, Sonnet 5.5 high ile çalışıyor. Aynı kodu iki modelde karşılaştırırken effort'u sabitlemezsen iki farklı ayarı karşılaştırmış olursun.

Her işe en büyük modeli vermek. Bir sınıflandırma için Fable 5.2 kullanmak, aynı token sayısında Haiku 5.5'in 80 katı fiyat demek.

max_tokens'u cevap uzunluğuna göre seçmek. Thinking dahil. Tek kelimelik cevap için bile birkaç bin token bırakmak gerekebilir.

Model ID'sine tarih eki eklemek. Güncel ID'ler tarihsiz; models overview sayfasında Haiku 5.5'in ID'si yalnız claude-haiku-5-5.

Küçük Bir Deneme

★☆☆ estimate modunu kendi varsayımlarınla çalıştır: 3.000 input ve 500 output token için Haiku 5.5 ile Sonnet 5.5 arasındaki 1.000 istek başına farkı hesapla. Sonra input'u 120.000'e çıkar ve Haiku 5.5'in fiyatının neden sıçradığını açıkla.

★★☆ ClaudePricing'e Batch API indirimi için bir parametre ekle (yüzde 50) ve bunu bir testle doğrula. Fast mode fiyatını (Opus 5.5 için 8 / 40) ayrı bir satır olarak ekle.

★★★ Kendi key'inle run modunu çalıştır. Değerlendirme setine Bookstore'un gerçek iade taleplerine benzeyen 20 örnek daha ekle (müşteri verisi olmadan). Tabloda doğruluğu en yüksek ve maliyeti en düşük satırı seç, kararını tek paragrafla yaz.

Buraya kadar bütün cevaplar tek seferde geldi. Dördüncü yazıda streaming'e geçiyoruz: CreateStreaming ile gelen event'ler, text ve thinking delta'larını ayırmak, son usage'ı toplamak ve Bookstore.Api'de bu event'leri Server-Sent Events olarak Angular istemcisine akıtmak.