Graph of Thoughts (GoT)

from openai import OpenAI

client = OpenAI()

def graph_of_thoughts_simple(task: str) -> str:
    """
    GoT через один промпт: генерация ветвей,
    объединение лучших идей, улучшение результата.
    """
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "Решай задачи методом «граф мыслей»:\n"
                    "1. Предложи 3 разных подхода к решению\n"
                    "2. Оцени плюсы и минусы каждого\n"
                    "3. Объедини лучшие элементы из разных "
                    "подходов в гибридное решение\n"
                    "4. Улучши гибридное решение, устранив "
                    "найденные слабые места"
                ),
            },
            {"role": "user", "content": task},
        ],
        temperature=0.7,
    )
    return response.choices[0].message.content


result = graph_of_thoughts_simple(
    "Разработай архитектуру системы уведомлений "
    "для e-commerce платформы с 1 млн пользователей."
)
print(result)

import anthropic
from dataclasses import dataclass, field

client = anthropic.Anthropic()


@dataclass
class Thought:
    """Вершина графа мыслей."""
    id: str
    content: str
    score: float = 0.0
    parents: list[str] = field(default_factory=list)


class GraphOfThoughts:
    """Реализация Graph of Thoughts с тремя операциями."""

    def __init__(self, task: str):
        self.task = task
        self.thoughts: dict[str, Thought] = {}
        self.counter = 0

    def _next_id(self) -> str:
        self.counter += 1
        return f"t{self.counter}"

    def generate(
        self, parent_ids: list[str] | None = None, n: int = 3
    ) -> list[str]:
        """Генерация новых мыслей."""
        context = ""
        if parent_ids:
            parents = [
                self.thoughts[pid]
                for pid in parent_ids
                if pid in self.thoughts
            ]
            context = "\n".join(
                f"- [{t.id}]: {t.content}" for t in parents
            )

        prompt = f"Задача: {self.task}\n\n"
        if context:
            prompt += f"Контекст:\n{context}\n\n"
        prompt += (
            f"Предложи {n} различных подхода или идеи. "
            "Каждый на новой строке, начиная с номера."
        )

        message = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            messages=[{"role": "user", "content": prompt}],
        )

        new_ids = []
        for line in message.content[0].text.split("\n"):
            line = line.strip()
            if line and line[0].isdigit():
                content = line.lstrip("0123456789.)- ").strip()
                if content:
                    tid = self._next_id()
                    self.thoughts[tid] = Thought(
                        id=tid,
                        content=content,
                        parents=parent_ids or [],
                    )
                    new_ids.append(tid)
        return new_ids[:n]

    def merge(self, thought_ids: list[str]) -> str:
        """Объединение нескольких мыслей в одну."""
        ideas = "\n".join(
            f"- [{tid}]: {self.thoughts[tid].content}"
            for tid in thought_ids
            if tid in self.thoughts
        )

        message = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            messages=[
                {
                    "role": "user",
                    "content": (
                        f"Задача: {self.task}\n\n"
                        f"Идеи:\n{ideas}\n\n"
                        "Объедини лучшие элементы этих идей "
                        "в одно гибридное решение. "
                        "Укажи, какие элементы откуда взяты."
                    ),
                }
            ],
        )

        merged_content = message.content[0].text
        tid = self._next_id()
        self.thoughts[tid] = Thought(
            id=tid,
            content=merged_content,
            parents=thought_ids,
        )
        return tid

    def refine(self, thought_id: str) -> str:
        """Улучшение мысли через обратную связь."""
        thought = self.thoughts[thought_id]

        message = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            messages=[
                {
                    "role": "user",
                    "content": (
                        f"Задача: {self.task}\n\n"
                        f"Текущее решение:\n{thought.content}\n\n"
                        "Найди слабые места и улучши решение. "
                        "Объясни, что именно улучшено."
                    ),
                }
            ],
        )

        refined_content = message.content[0].text
        tid = self._next_id()
        self.thoughts[tid] = Thought(
            id=tid,
            content=refined_content,
            parents=[thought_id],
        )
        return tid

    def evaluate(self, thought_id: str) -> float:
        """Оценка качества мысли (0.0 — 1.0)."""
        thought = self.thoughts[thought_id]

        message = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=64,
            messages=[
                {
                    "role": "user",
                    "content": (
                        f"Задача: {self.task}\n\n"
                        f"Решение: {thought.content}\n\n"
                        "Оцени от 0 до 10. Ответь только числом."
                    ),
                }
            ],
        )

        try:
            score = float(
                message.content[0].text.strip().split()[0]
            ) / 10
        except (ValueError, IndexError):
            score = 0.5
        self.thoughts[thought_id].score = score
        return score


got = GraphOfThoughts(
    "Спроектируй систему рекомендаций для книжного магазина"
)

initial_ids = got.generate(n=3)

for tid in initial_ids:
    score = got.evaluate(tid)
    print(f"{tid}: {score:.1f} — {got.thoughts[tid].content[:60]}...")

sorted_ids = sorted(
    initial_ids,
    key=lambda t: got.thoughts[t].score,
    reverse=True,
)
merged_id = got.merge(sorted_ids[:2])

refined_id = got.refine(merged_id)

print(f"\nФинальное решение:\n{got.thoughts[refined_id].content}")