Claude Extended Thinking: AI'ın Derin Düşünme Modu

1Input → Model → Output (tek adım)

1Input → Düşünme Aşamasi (reasoning tokens) → Doğrulama → Output

1// Extended Thinking API çağrısı örneği
2const response = await anthropic.messages.create({
3  model: 'claude-sonnet-4-20250514',
4  max_tokens: 16000,
5  thinking: {
6    type: 'enabled',
7    budget_tokens: 10000 // düşünme için ayrılmış token bütçesi
8  },
9  messages: [{
10    role: 'user',
11    content: 'Bu recursive fonksiyonun zaman karmaşıklığını analiz et...'
12  }]
13});
14 
15// Düşünme sürecini ve sonuçu ayrı ayrı al
16const thinkingBlock = response.content.find(b => b.type === 'thinking');
17const textBlock = response.content.find(b => b.type === 'text');
18 
19console.log('Düşünme süreci:', thinkingBlock?.thinking);
20console.log('Nihai cevap:', textBlock?.text);

1# Örnek: Claude'un ic düşünme süreci (thinking tokens)
2"""
3Adım 1: Problemi anlama
4- Kullanıcı bir binary tree'de en uzun yol bulmami istiyor
5- Bu klasik "diameter of binary tree" problemi
6 
7Adım 2: Yaklaşım seçim

8- DFS ile her node'un sol ve sağ derinliğini hesaplayabilirim
9- Her node için diameter = sol_derinlik + sag_derinlik
10- Global maximum'u takip etmem gerekiyor
11 
12Adım 3: Edge case kontrolleri
13- Bos ağaç → 0
14- Tek node → 0
15- Sadece sol/sağ alt ağaç → derinlik
16 
17Adım 4: Çözümu kodlama
18- Recursive DFS fonksiyonu yaziyorum
19- Her çağırımda max_diameter güncelliyorum
20- Time: O(n), Space: O(h) - h ağaç yüksek

21 
22Adım 5: Doğrulama
23- Örnek ağaç ile test ediyorum: [1,2,3,4,5]
24- Beklenen diameter: 3 (4→2→1→3 veya 5→2→1→3)
25- Kodumun çıktısı: 3 ✓
26"""

1// Görev tipine göre dinamik budget ayarlama
2function getThinkingBudget(taskType: string): number {
3  const budgets: Record<string, number> = {
4    'simple_question': 0,        // Extended Thinking gereksiz
5    'code_review': 5000,         // Orta karmaşıklık
6    'algorithm_design': 10000,   // Yüksek
 karmaşıklık
7    'system_architecture': 15000, // Çok yüksek
 karmaşıklık
8    'math_proof': 20000,         // Maksimum düşünme gerekli
9    'debugging_complex': 12000,  // Karmaşık hata ayıklama
10  };
11  return budgets[taskType] ?? 8000; // Varsayılan: 8K
12}
13 
14// Kullanım
15const budget = getThinkingBudget('algorithm_design');
16const response = await anthropic.messages.create({
17  model: 'claude-sonnet-4-20250514',
18  max_tokens: 16000,
19  thinking: {
20    type: 'enabled',
21    budget_tokens: budget
22  },
23  messages: [{ role: 'user', content: prompt }]
24});

1// Streaming ile düşünme sürecini izleme
2const stream = anthropic.messages.stream({
3  model: 'claude-sonnet-4-20250514',
4  max_tokens: 16000,
5  thinking: { type: 'enabled', budget_tokens: 10000 },
6  messages: [{ role: 'user', content: prompt }]
7});
8 
9for await (const event of stream) {
10  if (event.type === 'content_block_delta') {
11    if (event.delta.type === 'thinking_delta') {
12      console.log('[Düşünme]', event.delta.thinking);
13    } else if (event.delta.type === 'text_delta') {
14      console.log('[Cevap]', event.delta.text);
15    }
16  }
17}

1// Claude Extended Thinking'in üretebildiği karmaşık cache çözümu
2// Düşünme süreci: LRU + TTL + Memory pressure + Disk persistence
3 
4actor SmartCache<Key: Hashable & Sendable, Value: Sendable> {
5    private struct CacheEntry {
6        let value: Value
7        let createdAt: Date
8        let ttl: TimeInterval
9        var lastAccessedAt: Date
10        var accessCount: Int
11 
12        var isExpired: Bool {
13            Date().timeIntervalSince(createdAt) > ttl
14        }
15    }
16 
17    private var storage: [Key: CacheEntry] = [:]
18    private let maxSize: Int
19    private let defaultTTL: TimeInterval
20 
21    init(maxSize: Int = 100, defaultTTL: TimeInterval = 300) {
22        self.maxSize = maxSize
23        self.defaultTTL = defaultTTL
24    }
25 
26    func get(_ key: Key) -> Value? {
27        guard var entry = storage[key], !entry.isExpired else {
28            storage.removeValue(forKey: key)
29            return nil
30        }
31        entry.lastAccessedAt = Date()
32        entry.accessCount += 1
33        storage[key] = entry
34        return entry.value
35    }
36 
37    func set(_ key: Key, value: Value, ttl: TimeInterval? = nil) {
38        if storage.count >= maxSize {
39            evictLeastRecentlyUsed()
40        }
41        storage[key] = CacheEntry(
42            value: value,
43            createdAt: Date(),
44            ttl: ttl ?? defaultTTL,
45            lastAccessedAt: Date(),
46            accessCount: 0
47        )
48    }
49 
50    private func evictLeastRecentlyUsed() {
51        guard let lruKey = storage.min(by: {
52            $0.value.lastAccessedAt < $1.value.lastAccessedAt
53        })?.key else { return }
54        storage.removeValue(forKey: lruKey)
55    }
56}

1// iOS'ta Claude Extended Thinking API çağrısı
2import Foundation
3 
4struct ClaudeThinkingService {
5    private let apiKey: String
6    private let baseURL = "https://api.anthropic.com/v1/messages"
7 
8    struct ThinkingRequest: Encodable {
9        let model: String
10        let max_tokens: Int
11        let thinking: ThinkingConfig
12        let messages: [Message]
13 
14        struct ThinkingConfig: Encodable {
15            let type: String
16            let budget_tokens: Int
17        }
18 
19        struct Message: Encodable {
20            let role: String
21            let content: String
22        }
23    }
24 
25    func analyzeCode(_ code: String, budget: Int = 10000) async throws -> String {
26        var request = URLRequest(url: URL(string: baseURL)!)
27        request.httpMethod = "POST"
28        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
29        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
30        request.setValue("2023-06-01", forHTTPHeaderField: "anthropic-version")
31 
32        let body = ThinkingRequest(
33            model: "claude-sonnet-4-20250514",
34            max_tokens: 16000,
35            thinking: .init(type: "enabled", budget_tokens: budget),
36            messages: [.init(role: "user", content: "Bu kodu analiz et: \(code)")]
37        )
38 
39        request.httpBody = try JSONEncoder().encode(body)
40 
41        let (data, _) = try await URLSession.shared.data(for: request)
42        // Response parsing...
43        return String(data: data, encoding: .utf8) ?? ""
44    }
45}

1// Express.js proxy endpoint
2import express from 'express';
3import Anthropic from '@anthropic-ai/sdk';
4 
5const router = express.Router();
6const anthropic = new Anthropic();
7 
8router.post('/api/analyze', async (req, res) => {
9  const { prompt, taskType } = req.body;
10 
11  // Rate limiting ve authentication kontrolu
12  // ...
13 
14  const budget = getThinkingBudget(taskType);
15 
16  try {
17    const response = await anthropic.messages.create({
18      model: 'claude-sonnet-4-20250514',
19      max_tokens: 16000,
20      thinking: { type: 'enabled', budget_tokens: budget },
21      messages: [{ role: 'user', content: prompt }]
22    });
23 
24    // Thinking ve text bloklarını ayir
25    const thinking = response.content
26      .filter(b => b.type === 'thinking')
27      .map(b => b.thinking)
28      .join('\n');
29 
30    const text = response.content
31      .filter(b => b.type === 'text')
32      .map(b => b.text)
33      .join('\n');
34 
35    res.json({
36      answer: text,
37      reasoning: thinking,
38      usage: response.usage
39    });
40  } catch (error) {
41    res.status(500).json({ error: 'Analiz başarısız' });
42  }
43});

1Örnek: 1000 istek/gun senaryosu
2 
3Standart Mod:
4- Ortalama input: 2K token × $3/1M = $0.006
5- Ortalama output: 1K token × $15/1M = $0.015
6- Günlük maliyet: 1000 × ($0.006 + $0.015) = $21
7 
8Extended Thinking (10K budget):
9- Ortalama input: 2K token × $3/1M = $0.006
10- Ortalama output: 1K token × $15/1M = $0.015
11- Ortalama thinking: 8K token × $15/1M = $0.12
12- Günlük maliyet: 1000 × ($0.006 + $0.015 + $0.12) = $141
13 
14Fark: $120/gun (%670 artis)

1// PR review için Extended Thinking kullanımi
2async function reviewPullRequest(diff: string): Promise<ReviewResult> {
3  const response = await anthropic.messages.create({
4    model: 'claude-sonnet-4-20250514',
5    max_tokens: 16000,
6    thinking: { type: 'enabled', budget_tokens: 15000 },
7    messages: [{
8      role: 'user',
9      content: `Bu PR diff'ini iOS best practices açısından incele:
10        - Memory leak riski var mi?
11        - Thread safety ihlali var mi?
12        - Performance darboğazları var mi?
13        - SOLID prensipleri uygulanmış mi?
14 
15        Diff:
16        ${diff}`
17    }]
18  });
19 
20  return parseReviewResponse(response);
21}

1// Kotu prompt
2const badPrompt = "Bu kodu düzelt";
3 
4// Iyi prompt (Extended Thinking için optimize)
5const goodPrompt = `
6Bu Swift kodunu aşağıdaki kriterlere göre analiz et ve iyileştir
:
7 
81. Memory management: Retain cycle var mi?
92. Concurrency: Actor isolation doğru mu?
103. Performance: Gereksiz allocation var mi?
114. Error handling: Tum hata durum
 ele alınmış mi?
12 
13Her kriter için:
14- Mevcut durum
 analizi
15- Tespit edilen sorunlar
16- Çözüm önerisi ve kod örneği
17 
18Kod:
19[kod buraya]
20`;

1import { createHash } from 'crypto';
2 
3const responseCache = new Map<string, { response: string; timestamp: number }>();
4const CACHE_TTL = 3600000; // 1 saat
5 
6async function queryWithCache(prompt: string, budget: number) {
7  const hash = createHash('sha256').update(prompt).digest('hex');
8 
9  const cached = responseCache.get(hash);
10  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
11    return cached.response;
12  }
13 
14  const response = await callExtendedThinking(prompt, budget);
15  responseCache.set(hash, { response, timestamp: Date.now() });
16  return response;
17}