Thinking

Thinking bezeichnet die revolutionäre Fähigkeit moderner KI-Modelle, ihre internen Überlegungen transparent zu machen. Diese neue Generation von "Reasoning Models" denkt nicht nur - sie zeigt uns, wie sie denkt, und ermöglicht dadurch tiefere Einblicke und präzisere Kontrolle über KI-generierte Ergebnisse.

Was ist Thinking?

Thinking ist ein Mechanismus, bei dem KI-Modelle ihre Gedankengänge explizit durcharbeiten, ähnlich wie Menschen beim lauten Denken. Es repräsentiert einen fundamentalen Wandel in der KI-Architektur: weg von reiner Mustererkennung hin zu echtem, nachvollziehbarem Reasoning.

Die Evolution der Thinking Models

Von Pattern Matching zu echtem Reasoning

Traditionelle LLMs wie GPT-4 oder frühere Claude-Versionen basieren primär auf statistischen Mustern. Sie "wissen" nicht wirklich, warum sie antworten, wie sie antworten - sie folgen gelernten Patterns.

Technische Grundlagen des Thinking

Serial Test-Time Compute

Thinking Models nutzen "Serial Test-Time Compute" - sie verwenden zusätzliche Rechenzeit während der Inferenz, um bessere Ergebnisse zu erzielen:

Verschiedene Thinking Patterns

1. Chain-of-Thought (CoT)

Thinking: "Okay, ich muss diese Verkaufsdaten analysieren.
Schritt 1: Gesamtumsatz berechnen...
Schritt 2: Trends identifizieren...
Schritt 3: Anomalien suchen..."

2. Tree of Thoughts (ToT)

Thinking: "Ich sehe drei mögliche Ansätze:
Ansatz A: Direkte Berechnung... hmm, führt zu Widerspruch
Ansatz B: Zerlegung in Teilprobleme... vielversprechend
Ansatz C: Mustererkennung... auch möglich
Verfolge B weiter..."

3. Self-Reflection

Thinking: "Moment, meine Berechnung ergibt 150%.
Das kann nicht stimmen. Lass mich nochmal prüfen...
Ah, ich habe einen Dezimalfehler gemacht."

Anthropic Claude - Extended Thinking

Die Claude-Philosophie: Ein Gehirn, zwei Modi

Claude 3.7 Sonnet wurde mit einer anderen Philosophie als andere Reasoning-Modelle entwickelt. Wie Menschen ein einziges Gehirn für schnelle Antworten und tiefes Nachdenken nutzen, glaubt Anthropic, dass Reasoning eine integrierte Fähigkeit sein sollte - kein separates Modell.

Implementation in Claude

import anthropic

client = anthropic.Anthropic()

# Methode 1: Explizite Thinking-Anweisung
response = client.messages.create(
    model="claude-3-7-sonnet",
    max_tokens=4000,
    messages=[{
        "role": "user",
        "content": "Think for up to 5000 tokens: Analysiere die Vor- und Nachteile von Remote-Arbeit aus verschiedenen Perspektiven."
    }],
    # Beta-Feature für Extended Thinking
    headers={"anthropic-beta": "interleaved-thinking-2025-05-14"}
)

# Methode 2: Mit thinking_budget Parameter
response = client.messages.create(
    model="claude-3-7-sonnet",
    max_tokens=2000,
    messages=[{
        "role": "user",
        "content": "Entwickle eine Geschäftsstrategie für ein nachhaltiges Startup."
    }],
    thinking_budget=10000,  # 10K Tokens für Überlegungen
    headers={"anthropic-beta": "thinking-2025-07-15"}
)

# Zugriff auf Thinking und finale Antwort
print("=== DENKPROZESS ===")
for content in response.content:
    if content.type == "thinking":
        print(content.text)
    
print("
=== FINALE ANTWORT ===")
for content in response.content:
    if content.type == "text":
        print(content.text)

Das "Think" Tool

Claude bietet auch ein spezielles "think" Tool für Situationen, wo das Modell externe Informationen verarbeiten muss:

# Think Tool für Tool-Use-Szenarien
tools = [{
    "name": "think",
    "description": "Use this to think through complex problems step by step",
    "input_schema": {
        "type": "object",
        "properties": {
            "thought_process": {"type": "string"}
        }
    }
}]

response = client.messages.create(
    model="claude-3-7-sonnet",
    messages=[{
        "role": "user",
        "content": "Analysiere diese Finanzdaten und entwickle Empfehlungen."
    }],
    tools=tools,
    tool_choice={"type": "any"}
)

Google Gemini - Thinking Mode

Geminis Ansatz: Konfigurierbare Denktiefe

Gemini 2.0 Flash Thinking bietet einen flexiblen Ansatz mit konfigurierbarem "Thinking Token Budget". Dies ermöglicht präzise Kontrolle über die Balance zwischen Geschwindigkeit und Gründlichkeit.

Implementation in Gemini

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

# Basis Thinking Mode
model = genai.GenerativeModel('gemini-2.0-flash-thinking-exp')

# Einfache Nutzung mit Standard-Budget
response = model.generate_content(
    "Erkläre Schritt für Schritt, wie Photosynthese funktioniert"
)

# Erweiterte Konfiguration
response = model.generate_content(
    "Entwickle eine innovative Lösung für urbane Mobilität",
    generation_config=genai.types.GenerationConfig(
        thinking_token_budget=16384,  # 16K Tokens für tiefes Denken
        temperature=0.7,
        max_output_tokens=2000
    )
)

# Zugriff auf getrennte Outputs
print("=== GEMINIS DENKPROZESS ===")
print(response.thinking_text)
print(f"Thinking Tokens verwendet: {response.thinking_token_count}")

print("\n=== FINALE ANTWORT ===")
print(response.text)

# Multimodales Thinking
import PIL.Image

image = PIL.Image.open('complex_diagram.jpg')
response = model.generate_content([
    "Analysiere dieses technische Diagramm und erkläre die Funktionsweise.",
    image
], generation_config=genai.types.GenerationConfig(
    thinking_token_budget=20000  # Mehr Budget für visuelle Analyse
))

# Streaming mit Thinking
for chunk in model.generate_content_stream(
    "Löse dieses komplexe mathematische Problem...",
    generation_config=genai.types.GenerationConfig(
        thinking_token_budget=10000,
        stream_thinking=True  # Zeigt Thinking in Echtzeit
    )
):
    if chunk.thinking_text:
        print(f"[THINKING] {chunk.thinking_text}")
    if chunk.text:
        print(f"[RESPONSE] {chunk.text}")

API-Verfügbarkeit

OpenAI o1/o3 - Reasoning Models

OpenAIs Ansatz: Dedizierte Reasoning-Modelle

Im Gegensatz zu Claudes Hybrid-Ansatz setzt OpenAI auf spezialisierte Reasoning-Modelle. Die o-Serie (o1, o3-mini, o3) ist ausschließlich für komplexes Reasoning optimiert.

Verwendung der o-Modelle

from openai import OpenAI

client = OpenAI()

# o1 Modell für komplexe Reasoning-Aufgaben
response = client.chat.completions.create(
    model="o1-preview",  # oder "o3" für beste Performance
    messages=[{
        "role": "user",
        "content": """Löse folgendes Problem:
        
        In einem Raum sind 3 Schalter. Jeder kontrolliert eine von 3 Glühbirnen 
        im Nebenraum. Du kannst die Schalter beliebig betätigen, aber nur 
        einmal in den Nebenraum gehen. Wie findest du heraus, welcher 
        Schalter welche Birne kontrolliert?"""
    }],
    # o-Modelle haben keine temperature oder top_p Parameter
    max_tokens=2000
)

# Reasoning ist versteckt, nur finale Antwort sichtbar
print(response.choices[0].message.content)

# o3-mini für schnellere, günstigere Reasoning
response = client.chat.completions.create(
    model="o3-mini",
    messages=[{
        "role": "user",
        "content": "Erkläre den Unterschied zwischen Induktion und Deduktion mit Beispielen."
    }],
    reasoning_effort="low"  # Neu in o3: Einstellbare Reasoning-Intensität
)

Praktische Anwendungen von Thinking

Wann Thinking verwenden?

Beispiel-Workflows

Workflow 1: Datenanalyse mit Thinking

# Claude für explorative Datenanalyse
def analyze_data_with_thinking(data_description, budget=15000):
    response = anthropic_client.messages.create(
        model="claude-3-7-sonnet",
        messages=[{
            "role": "user",
            "content": f"""Think for up to {budget} tokens:
            
            Analysiere diese Daten gründlich:
            {data_description}
            
            1. Identifiziere Muster und Anomalien
            2. Entwickle Hypothesen
            3. Schlage Visualisierungen vor
            4. Empfehle nächste Schritte
            """
        }],
        max_tokens=3000,
        headers={"anthropic-beta": "interleaved-thinking-2025-05-14"}
    )
    
    # Extrahiere Thinking und Response
    thinking = [c.text for c in response.content if c.type == "thinking"]
    analysis = [c.text for c in response.content if c.type == "text"]
    
    return {
        "thought_process": "\n".join(thinking),
        "analysis": "\n".join(analysis),
        "tokens_used": response.usage.thinking_tokens
    }

Workflow 2: Strategieentwicklung mit Budget-Kontrolle

# Gemini für Budget-kontrollierte Strategieentwicklung
def develop_strategy(challenge, max_budget=20000):
    budgets = [5000, 10000, 15000, 20000]
    strategies = []
    
    for budget in budgets:
        if budget > max_budget:
            break
            
        response = gemini_model.generate_content(
            f"Entwickle eine Strategie für: {challenge}",
            generation_config=genai.types.GenerationConfig(
                thinking_token_budget=budget
            )
        )
        
        strategies.append({
            "budget": budget,
            "thinking": response.thinking_text,
            "strategy": response.text,
            "confidence": estimate_confidence(response)
        })
    
    # Wähle beste Strategy basierend auf Confidence/Budget-Verhältnis
    return select_optimal_strategy(strategies)

Kosten und Performance

Kostenvergleich der Thinking-Modelle

Performance-Metriken

Best Practices für Thinking

✅ Do's

❌ Don'ts

Praktischer Implementation Guide

Thinking Service Pattern

from enum import Enum
from typing import Optional, Dict, Any

class ThinkingIntensity(Enum):
    NONE = 0
    LOW = 5000
    MEDIUM = 15000
    HIGH = 30000
    EXTREME = 50000

class ThinkingService:
    def __init__(self):
        self.claude_client = anthropic.Anthropic()
        self.gemini_model = genai.GenerativeModel('gemini-2.0-flash-thinking-exp')
        
    def analyze_task_complexity(self, prompt: str) -> ThinkingIntensity:
        """Schätzt die benötigte Thinking-Intensität"""
        complexity_indicators = {
            "schritt für schritt": ThinkingIntensity.MEDIUM,
            "analysiere": ThinkingIntensity.MEDIUM,
            "entwickle eine strategie": ThinkingIntensity.HIGH,
            "beweise": ThinkingIntensity.HIGH,
            "optimiere": ThinkingIntensity.HIGH,
            "kreative lösung": ThinkingIntensity.EXTREME
        }
        
        prompt_lower = prompt.lower()
        for indicator, intensity in complexity_indicators.items():
            if indicator in prompt_lower:
                return intensity
        
        # Wortanzahl als Fallback
        word_count = len(prompt.split())
        if word_count > 200:
            return ThinkingIntensity.HIGH
        elif word_count > 100:
            return ThinkingIntensity.MEDIUM
        else:
            return ThinkingIntensity.LOW
    
    async def think_and_respond(
        self, 
        prompt: str, 
        model: str = "claude",
        intensity: Optional[ThinkingIntensity] = None,
        show_thinking: bool = False
    ) -> Dict[str, Any]:
        """Hauptmethode für Thinking-basierte Responses"""
        
        # Auto-detect intensity if not provided
        if intensity is None:
            intensity = self.analyze_task_complexity(prompt)
        
        start_time = time.time()
        
        if model == "claude":
            response = await self._claude_thinking(prompt, intensity.value)
        elif model == "gemini":
            response = await self._gemini_thinking(prompt, intensity.value)
        else:
            raise ValueError(f"Unsupported model: {model}")
        
        elapsed_time = time.time() - start_time
        
        result = {
            "answer": response["text"],
            "model": model,
            "thinking_tokens": response.get("thinking_tokens", 0),
            "intensity": intensity.name,
            "elapsed_time": elapsed_time,
            "estimated_cost": self._estimate_cost(
                model, 
                response.get("thinking_tokens", 0),
                response.get("output_tokens", 0)
            )
        }
        
        if show_thinking:
            result["thinking_process"] = response.get("thinking", "")
        
        return result
    
    def _estimate_cost(self, model: str, thinking_tokens: int, output_tokens: int) -> float:
        """Schätzt die Kosten basierend auf Token-Usage"""
        pricing = {
            "claude": {"thinking": 0.003, "output": 0.015},  # per 1K tokens
            "gemini": {"thinking": 0.0015, "output": 0.005}
        }
        
        model_pricing = pricing.get(model, pricing["claude"])
        cost = (thinking_tokens / 1000 * model_pricing["thinking"] + 
                output_tokens / 1000 * model_pricing["output"])
        
        return round(cost, 4)

Intelligentes Thinking Routing

class ThinkingRouter:
    """Routet Anfragen zum optimalen Modell basierend auf Anforderungen"""
    
    def route(self, task_type: str, budget: float, deadline: float) -> Dict[str, Any]:
        routes = {
            "math": {
                "low_budget": ("gemini", ThinkingIntensity.MEDIUM),
                "high_budget": ("claude", ThinkingIntensity.HIGH),
                "urgent": ("gemini", ThinkingIntensity.LOW)
            },
            "coding": {
                "low_budget": ("claude", ThinkingIntensity.MEDIUM),
                "high_budget": ("openai-o3", None),  # o3 hat kein konfigurierbares Budget
                "urgent": ("claude", ThinkingIntensity.LOW)
            },
            "creative": {
                "low_budget": ("claude", ThinkingIntensity.HIGH),
                "high_budget": ("claude", ThinkingIntensity.EXTREME),
                "urgent": ("gemini", ThinkingIntensity.MEDIUM)
            },
            "analysis": {
                "low_budget": ("gemini", ThinkingIntensity.HIGH),
                "high_budget": ("claude", ThinkingIntensity.EXTREME),
                "urgent": ("gemini", ThinkingIntensity.MEDIUM)
            }
        }
        
        task_routes = routes.get(task_type, routes["analysis"])
        
        if budget < 0.50:
            return task_routes["low_budget"]
        elif deadline < 30:  # Sekunden
            return task_routes["urgent"]
        else:
            return task_routes["high_budget"]

Die Zukunft von Thinking

Aktuelle Trends 2025

Herausforderungen und Limitationen

• Kosten: Thinking bleibt teuer und limitiert Massenadoption
• Latenz: Tiefes Thinking kann Minuten dauern
• Transparenz vs. Sicherheit: Balance zwischen Einblick und Missbrauchsschutz
• Evaluation: Schwierig zu bewerten, ob Thinking "gut" ist
• User Experience: Wie viel Thinking wollen Nutzer wirklich sehen?