Tree of Thoughts

Beispiel - Lösung einer Mathematikaufgabe:
Problem: Finde eine Gleichung die 24 ergibt mit 4, 9, 10, 13

Gedanke 1: Beginne mit der größten Zahl: 13 + ...
Gedanke 2: Nutze Multiplikation als Hauptoperation: 4 × ...
Gedanke 3: Kombiniere kleine Zahlen zuerst: (4 + 9) × ...
Gedanke 4: Verwende Division strategisch: ... ÷ 4
Gedanke 5: Subtrahiere von einem großen Produkt: ... - 10

Bewertungskriterien:
- Wahrscheinlichkeit für Erfolg (hoch/mittel/niedrig)
- Machbarkeit der Fortsetzung
- Übereinstimmung mit Problemzielen
- Logische Konsistenz

Bewertungsbeispiel:
Gedanke 1: "13 + 4 = 17" → Mittleres Potenzial
Gedanke 2: "4 × 9 = 36" → Hohes Potenzial (näher zu 24)
Gedanke 3: "(4 + 9) × 2 = 26" → Sehr hohes Potenzial

BFS-Strategie:
Ebene 1: Alle ersten Gedanken generieren und bewerten
Ebene 2: Beste Gedanken aus Ebene 1 weiterentwickeln
Ebene 3: Beste Gedanken aus Ebene 2 weiterentwickeln
...

Vorteil: Vermeidet vorschnelle Entscheidungen
Nachteil: Kann bei tiefen Problemen langsam sein

DFS-Strategie:
Wähle besten ersten Gedanken
→ Entwickle ihn vollständig weiter
→ Wenn Sackgasse: Backtrack zu Alternative
→ Wiederhole bis Lösung gefunden

Vorteil: Kann schnell zu Lösungen führen
Nachteil: Kann in Sackgassen geraten

import openai
import json
from typing import List, Dict, Any

class TreeOfThoughts:
    def __init__(self, api_key: str):
        self.client = openai.OpenAI(api_key=api_key)
        self.search_strategy = "BFS"  # oder "DFS"
        
    def generate_thoughts(self, problem: str, context: str = "", num_thoughts: int = 3) -> List[str]:
        """Generiert mehrere Gedanken für ein Problem"""
        prompt = f"""
        Problem: {problem}
        Kontext: {context}
        
        Generiere {num_thoughts} verschiedene Ansätze zur Lösung dieses Problems.
        Format: 
        1. [Erster Ansatz]
        2. [Zweiter Ansatz]
        3. [Dritter Ansatz]
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.8
        )
        
        # Parse die Antwort und extrahiere die Gedanken
        thoughts = self._parse_thoughts(response.choices[0].message.content)
        return thoughts
    
    def evaluate_thoughts(self, thoughts: List[str], problem: str) -> Dict[str, float]:
        """Bewertet Gedanken auf einer Skala von 0-1"""
        evaluation_prompt = f"""
        Problem: {problem}
        
        Bewerte diese Ansätze auf einer Skala von 0-1:
        {chr(10).join([f"{i+1}. {thought}" for i, thought in enumerate(thoughts)])}
        
        Gib für jeden Ansatz eine Bewertung (0-1) und kurze Begründung.
        Format: 
        1. Score: 0.X - Begründung
        2. Score: 0.X - Begründung
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": evaluation_prompt}],
            temperature=0.3
        )
        
        return self._parse_evaluations(response.choices[0].message.content)
    
    def expand_best_thoughts(self, thoughts: List[str], evaluations: Dict[str, float], 
                           problem: str, top_k: int = 2) -> Dict[str, List[str]]:
        """Erweitert die besten Gedanken zu konkreten Lösungen"""
        # Sortiere Gedanken nach Bewertung
        sorted_thoughts = sorted(thoughts, key=lambda t: evaluations.get(t, 0), reverse=True)
        best_thoughts = sorted_thoughts[:top_k]
        
        expansions = {}
        for thought in best_thoughts:
            expand_prompt = f"""
            Problem: {problem}
            Gewählter Ansatz: {thought}
            
            Entwickle diesen Ansatz zu 3 konkreten Lösungsschritten:
            1. [Erster konkreter Schritt]
            2. [Zweiter konkreter Schritt]
            3. [Dritter konkreter Schritt]
            """
            
            response = self.client.chat.completions.create(
                model="gpt-4",
                messages=[{"role": "user", "content": expand_prompt}],
                temperature=0.7
            )
            
            expansions[thought] = self._parse_thoughts(response.choices[0].message.content)
        
        return expansions
    
    def solve_problem(self, problem: str, max_depth: int = 3) -> Dict[str, Any]:
        """Löst ein Problem mit Tree of Thoughts"""
        solution_tree = {
            "problem": problem,
            "levels": [],
            "final_solution": None
        }
        
        current_context = problem
        
        for depth in range(max_depth):
            # Generiere Gedanken
            thoughts = self.generate_thoughts(current_context)
            
            # Bewerte Gedanken
            evaluations = self.evaluate_thoughts(thoughts, problem)
            
            # Speichere Level
            level_data = {
                "depth": depth,
                "thoughts": thoughts,
                "evaluations": evaluations
            }
            solution_tree["levels"].append(level_data)
            
            # Erweitere beste Gedanken
            if depth < max_depth - 1:
                expansions = self.expand_best_thoughts(thoughts, evaluations, problem)
                level_data["expansions"] = expansions
                
                # Update context für nächste Iteration
                best_thought = max(thoughts, key=lambda t: evaluations.get(t, 0))
                current_context = f"{problem}

Bisher entwickelter Ansatz: {best_thought}"
            else:
                # Finale Lösung
                best_thought = max(thoughts, key=lambda t: evaluations.get(t, 0))
                solution_tree["final_solution"] = best_thought
        
        return solution_tree
    
    def _parse_thoughts(self, text: str) -> List[str]:
        """Hilfsfunktion zum Parsen von Gedanken aus der Antwort"""
        lines = text.strip().split('
')
        thoughts = []
        for line in lines:
            if line.strip() and (line.strip()[0].isdigit() or line.strip().startswith('-')):
                # Entferne Nummerierung
                thought = line.strip()
                if '. ' in thought:
                    thought = thought.split('. ', 1)[1]
                elif '- ' in thought:
                    thought = thought.split('- ', 1)[1]
                thoughts.append(thought)
        return thoughts
    
    def _parse_evaluations(self, text: str) -> Dict[str, float]:
        """Hilfsfunktion zum Parsen von Bewertungen"""
        # Vereinfachte Implementierung
        evaluations = {}
        lines = text.strip().split('
')
        for line in lines:
            if 'Score:' in line:
                try:
                    score_part = line.split('Score:')[1].split('-')[0].strip()
                    score = float(score_part)
                    # Hier würde man normalerweise den Gedanken extrahieren
                    evaluations[f"thought_{len(evaluations)}"] = score
                except:
                    continue
        return evaluations

# Verwendungsbeispiel
if __name__ == "__main__":
    tot = TreeOfThoughts("your-api-key")
    
    problem = "Entwickle eine Marketingstrategie für ein neues veganes Restaurant"
    solution = tot.solve_problem(problem)
    
    print(json.dumps(solution, indent=2, ensure_ascii=False))

Du bist ein Experte für systematische Problemlösung. Nutze Tree of Thoughts:

Problem: [PROBLEM_BESCHREIBUNG]

Schritt 1: Generiere 4 verschiedene Lösungsansätze
Schritt 2: Bewerte jeden Ansatz (Erfolgswahrscheinlichkeit, Aufwand, Risiko)
Schritt 3: Wähle die 2 besten und entwickle jeweils 3 konkrete Aktionsschritte
Schritt 4: Bewerte die Aktionsschritte und wähle den optimalen Lösungsweg
Schritt 5: Erstelle einen detaillierten Umsetzungsplan

Zeige den kompletten Denkbaum mit Begründungen für alle Entscheidungen.

Nutze Tree of Thoughts für diese kreative Aufgabe:

Aufgabe: [KREATIVE_AUFGABE]

Schritt 1: Brainstorme 5 verschiedene kreative Richtungen
Schritt 2: Bewerte jede Richtung (Originalität, Durchführbarkeit, Wirkung)
Schritt 3: Entwickle für die 2 besten Richtungen jeweils 3 konkrete Konzepte
Schritt 4: Bewerte die Konzepte und wähle das beste
Schritt 5: Arbeite das gewählte Konzept detailliert aus

Zeige den gesamten kreativen Denkprozess.

Als Softwarearchitekt, nutze Tree of Thoughts für diese technische Entscheidung:

Entscheidung: [TECHNISCHE_ENTSCHEIDUNG]
Kontext: [SYSTEM_KONTEXT]

Schritt 1: Identifiziere 4 verschiedene technische Ansätze
Schritt 2: Bewerte jeden Ansatz (Performance, Skalierbarkeit, Wartbarkeit, Kosten)
Schritt 3: Entwickle für die 2 besten Ansätze detaillierte Architekturen
Schritt 4: Analysiere Vor- und Nachteile jeder Architektur
Schritt 5: Treffe eine begründete Entscheidung mit Implementierungsplan

Zeige den kompletten technischen Entscheidungsbaum.

Adaptive Tiefe basierend auf Problemtyp:

🔸 Einfache Probleme (Tiefe 2-3):
- Mathematische Berechnungen
- Faktenfragen
- Einfache Entscheidungen

🔸 Mittlere Probleme (Tiefe 3-4):
- Strategische Planungen
- Kreative Aufgaben
- Technische Designs

🔸 Komplexe Probleme (Tiefe 4-6):
- Unternehmensstrategien
- Forschungsdesigns
- Ethische Dilemmata

Pruning-Kriterien:

1. Score-basiert: Entferne Gedanken mit Score < 0.3
2. Diversität: Behalte nur die 3 verschiedensten Ansätze
3. Ressourcen: Limitiere auf maximal 5 Äste pro Ebene
4. Zeitbasiert: Stoppe Äste, die zu lange brauchen
5. Konsistenz: Entferne widersprüchliche Gedanken

Implementierung:
- Bewerte nach jeder Ebene
- Behalte nur Top-K Äste
- Dokumentiere Pruning-Entscheidungen

Multi-Modell-Ansatz:

🔸 Gedankengenerierung: GPT-4 (kreativ, vielfältig)
🔸 Bewertung: Claude (analytical, strukturiert)
🔸 Expansion: Gemini (detailliert, gründlich)
🔸 Finalisierung: GPT-4 (kohärent, poliert)

Vorteile:
- Nutzt Stärken verschiedener Modelle
- Reduziert Bias eines einzelnen Modells
- Höhere Qualität durch Spezialisierung

Kostenaspekte:
🔸 Token-Verbrauch: 3-5x höher als standard prompting
🔸 Latenz: 2-4x längere Antwortzeiten
🔸 Komplexität: Höhere Implementierungskosten

Nutzen:
🔸 Qualität: Bis zu 70% bessere Lösungen
🔸 Kreativität: Deutlich innovativere Ansätze
🔸 Zuverlässigkeit: Weniger Fehlentscheidungen

ROI-Formel:
Wenn (Qualitätssteigerung × Problemwert) > (Zusatzkosten × Faktor)
→ Dann ist ToT rentabel

Optimierungsstrategien:

1. Intelligentes Pruning
   - Frühe Eliminierung schlechter Äste
   - Diversitäts-basierte Selektion
   - Adaptive Suchtiefe

2. Externe Evaluation
   - Nutze spezialisierte Bewertungsmodelle
   - Implementiere Scoring-Funktionen
   - Crowd-sourced Bewertungen

3. Hybride Ansätze
   - Kombiniere ToT mit anderen Methoden
   - Nutze ToT nur für kritische Entscheidungen
   - Implementiere Fallback-Mechanismen

4. Caching und Wiederverwendung
   - Speichere erfolgreiche Pfade
   - Wiederverwendung ähnlicher Probleme
   - Lernende Bewertungssysteme

Zukünftige Entwicklungen:

🔸 IDE-Integration:
- Automatische ToT für Code-Architektur
- Debugging mit Tree of Thoughts
- Optimierung von Algorithmen

🔸 Business-Tools:
- CRM-Integration für Kundenstrategien
- Projektmanagement mit ToT-Planung
- Automatische Risikobewertung

🔸 Bildungsbereich:
- Tutoring-Systeme mit ToT
- Adaptive Lernpfade
- Problemlösung-Training

🔸 Forschung:
- Wissenschaftliche Hypothesengenerierung
- Experimentdesign mit ToT
- Literaturreview-Systeme