solver-graph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7aabf701-9792-4a08-8f36-232eeef3303d",
   "metadata": {},
   "source": [
    "# Solver Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f51dfc27-e1ea-4656-b92c-924d1a61274d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dotenv import load_dotenv\n",
    "\n",
    "load_dotenv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6f6b0ac8-9569-4849-a1ee-6918265e65d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "from typing import Annotated, List, Literal, Optional\n",
    "\n",
    "from pydantic import BaseModel, Field\n",
    "\n",
    "\n",
    "class TestInputAndOutput(BaseModel):\n",
    "    \"\"\"Test input and expected output for the programming puzzle.\"\"\"\n",
    "\n",
    "    test_input: Optional[str] = Field(\n",
    "        default=None, description=\"The actual test input.\"\n",
    "    )\n",
    "    expected_output: Optional[int] = Field(\n",
    "        default=None, description=\"The expected output of the test input.\"\n",
    "    )\n",
    "\n",
    "\n",
    "class Solution(BaseModel):\n",
    "    code: str = Field(description=\"Code that solves the given puzzle.\")\n",
    "    model_name: str = Field(description=\"The model that created the solution.\")\n",
    "\n",
    "\n",
    "class SolutionEvaluation(BaseModel):\n",
    "    solution_idx: int = Field(description=\"Index of the solution.\", ge=0)\n",
    "    criterion: str = Field(description=\"Criterion, the solution is evaluated by.\")\n",
    "    score: int = Field(description=\"Score of the solution.\", ge=0, le=10)\n",
    "\n",
    "\n",
    "class SolutionsEvaluations(BaseModel):\n",
    "    solutions_evaluations: List[SolutionEvaluation] = Field(\n",
    "        description=\"List of evaluations of all solutions.\"\n",
    "    )\n",
    "\n",
    "\n",
    "class OverallState(BaseModel):\n",
    "    year: int = Field(description=\"Year of chosen Advent of Code.\", ge=2015, le=2024)\n",
    "    day: int = Field(description=\"Day of chosen Advent of Code (1-25).\", ge=1, le=25)\n",
    "    programming_language: Literal[\"Python\", \"JavaScript\", \"TypeScript\"] = Field(\n",
    "        description=\"The programming language, the puzzle should be solved in.\"\n",
    "    )\n",
    "\n",
    "    puzzle_url: Optional[str] = Field(\n",
    "        default=None, description=\"The URL to the chosen Advent of Code puzzle.\"\n",
    "    )\n",
    "    puzzle_description: Optional[str] = Field(\n",
    "        default=None, description=\"The puzzle description.\"\n",
    "    )\n",
    "\n",
    "    test_input_and_output: Optional[TestInputAndOutput] = Field(\n",
    "        default=None,\n",
    "        description=\"The test input with expected output for the given puzzle.\",\n",
    "    )\n",
    "\n",
    "    solutions: Annotated[List[Solution], operator.add] = Field(\n",
    "        default=[], description=\"A list of all solutions that solve the given puzzle.\"\n",
    "    )\n",
    "    tested_solutions: Annotated[List[Solution], operator.add] = Field(\n",
    "        default=[],\n",
    "        description=\"A list of tested solutions that solve the given puzzle.\",\n",
    "    )\n",
    "\n",
    "    evaluations: Annotated[List[SolutionsEvaluations], operator.add] = Field(\n",
    "        default=[], description=\"A list of all evaluations of all solutions.\"\n",
    "    )\n",
    "    best_solution_idx: Optional[int] = Field(\n",
    "        default=None, description=\"The index of the best solution code.\"\n",
    "    )\n",
    "    best_solution: Optional[str] = Field(\n",
    "        default=None, description=\"The best code to solve the given puzzle.\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "856cc0f4-2d3c-4fd4-9b43-b889727d99d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_advent_of_code_url(year: int, day: int) -> str:\n",
    "    return f\"https://adventofcode.com/{year}/day/{day}\"\n",
    "\n",
    "\n",
    "def get_puzzle_url(state: OverallState) -> OverallState:\n",
    "    return {\"puzzle_url\": get_advent_of_code_url(state.year, state.day)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "99058511-6448-492f-a747-ac8f89a3e0d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "USER_AGENT environment variable not set, consider setting it to identify your requests.\n"
     ]
    }
   ],
   "source": [
    "from langchain_community.document_loaders import WebBaseLoader\n",
    "\n",
    "\n",
    "def get_visible_content_of_website(url: str) -> str:\n",
    "    loader = WebBaseLoader(\n",
    "        web_path=url, bs_get_text_kwargs={\"separator\": \" \", \"strip\": True}\n",
    "    )\n",
    "    document = loader.load()[0]\n",
    "    return document.page_content\n",
    "\n",
    "\n",
    "def get_puzzle_description(state: OverallState) -> OverallState:\n",
    "    return {\"puzzle_description\": get_visible_content_of_website(state.puzzle_url)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0879c43d-3cf5-4dd1-93e8-9c9e7df49e34",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_core.messages import HumanMessage, SystemMessage\n",
    "from langchain_google_genai import ChatGoogleGenerativeAI\n",
    "\n",
    "\n",
    "def get_puzzle_test_input_and_output(state: OverallState) -> OverallState:\n",
    "    model = ChatGoogleGenerativeAI(model=\"gemini-1.5-pro\")\n",
    "    structured_model = model.with_structured_output(schema=TestInputAndOutput)\n",
    "\n",
    "    messages = [\n",
    "        SystemMessage(\n",
    "            content=(\n",
    "                \"You are an expert extraction algorithm. \"\n",
    "                \"Only extract relevant information from the text. \"\n",
    "                \"If you do not know the value of an attribute asked to extract, \"\n",
    "                \"return null for the attribute's value.\",\n",
    "            )\n",
    "        ),\n",
    "        HumanMessage(\n",
    "            content=(\n",
    "                f\"The full puzzle description is:\\n\"\n",
    "                \"```\\n\"\n",
    "                f\"{state.puzzle_description}\"\n",
    "                \"```\"\n",
    "            )\n",
    "        ),\n",
    "    ]\n",
    "\n",
    "    test_input_and_output = structured_model.invoke(messages)\n",
    "    return {\"test_input_and_output\": test_input_and_output}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a5ea4bce-d092-4bb3-9f09-53b4a73e4ec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "\n",
    "from langchain_core.language_models import BaseChatModel\n",
    "from langchain_google_genai import ChatGoogleGenerativeAI\n",
    "from langchain_ollama import OllamaLLM\n",
    "\n",
    "\n",
    "def get_models() -> List[BaseChatModel]:\n",
    "    return [\n",
    "        ChatGoogleGenerativeAI(model=\"gemini-1.5-pro\"),\n",
    "        ChatGoogleGenerativeAI(model=\"gemini-1.5-flash\"),\n",
    "        ChatGoogleGenerativeAI(model=\"gemini-1.5-flash-8b\"),\n",
    "        OllamaLLM(base_url=\"http://ollama:11434\", model=\"llama3.2:1b\"),\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "954a5ccd-db12-4e98-8cb0-0faf2f066d80",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from functools import partial\n",
    "from typing import Callable, Optional\n",
    "\n",
    "from langchain_core.language_models import BaseChatModel\n",
    "from langchain_core.messages import HumanMessage, SystemMessage\n",
    "from slugify import slugify\n",
    "\n",
    "\n",
    "def extract_actual_code(raw_code: str) -> Optional[str]:\n",
    "    regex = r\"```(python|typescript|javascript|js|ts)\\\\n(?P<code>.*)\\\\n```(\\\\n)?\"\n",
    "    pattern = re.compile(regex)\n",
    "    match = pattern.search(raw_code)\n",
    "    if match:\n",
    "        return match.group(\"code\")\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "\n",
    "def get_response_output(response) -> str:\n",
    "    if isinstance(response, str):\n",
    "        return response\n",
    "    elif hasattr(response, \"content\"):\n",
    "        return response.content\n",
    "    else:\n",
    "        raise ValueError(\"Unexpected response format\")\n",
    "\n",
    "\n",
    "def solve_puzzle(state: OverallState, model: BaseChatModel) -> Solution:\n",
    "    messages = [\n",
    "        SystemMessage(\n",
    "            content=(\n",
    "                \"You are a helpful assistant tasked with solving programming puzzles. \"\n",
    "                \"You should only return the actual code. \"\n",
    "                \"You should write a function called `solve`, which takes one input (the puzzle input), and returns the solution to the problem in a meaningful type or format. \"\n",
    "                \"This `solve` function will be used to test the code and solve the actual puzzle. \"\n",
    "                \"The code should be directly runnable. \"\n",
    "                \"The code should not use libraries outside of the standard libraries. \"\n",
    "                \"You can create helper functions, if helpful. \"\n",
    "                \"All descriptions must be part of comments within the code itself.\"\n",
    "            )\n",
    "        ),\n",
    "        HumanMessage(\n",
    "            content=(\n",
    "                f\"Solve the following puzzle in the '{state.programming_language}' programming language:\\n\"\n",
    "                \"```\\n\"\n",
    "                f\"{state.puzzle_description}\"\n",
    "                \"```\"\n",
    "            )\n",
    "        ),\n",
    "    ]\n",
    "\n",
    "    raw_code = get_response_output(model.invoke(messages))\n",
    "    code = extract_actual_code(raw_code)\n",
    "\n",
    "    if code:\n",
    "        solution = {\n",
    "            \"code\": code,\n",
    "            \"model_name\": model.model,\n",
    "        }\n",
    "        solutions = [solution]\n",
    "    else:\n",
    "        solutions = []\n",
    "\n",
    "    return {\"solutions\": solutions}\n",
    "\n",
    "\n",
    "def get_solve_puzzle_node(\n",
    "    model: BaseChatModel,\n",
    ") -> Callable[[OverallState], OverallState]:\n",
    "    return partial(solve_puzzle, model=model)\n",
    "\n",
    "\n",
    "def get_solve_puzzle_node_name(name: str) -> str:\n",
    "    return f\"solve_puzzle_using_{slugify(name)}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6edade2b-fde1-4829-821e-348ec7412e25",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import subprocess\n",
    "import sys\n",
    "import tempfile\n",
    "from typing import Callable, Optional\n",
    "\n",
    "\n",
    "def _get_wrapped_code(input_file_name: str, code: str) -> str:\n",
    "    return f\"\"\"\n",
    "{code}\n",
    "\n",
    "output = solve(\"{input_file_name}\")\n",
    "\n",
    "print(\"RESULT: \" + str(output))\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def run_code(code: str, input_data: str) -> Optional[int]:\n",
    "    with tempfile.NamedTemporaryFile(mode=\"w\", suffix=\".txt\") as input_file:\n",
    "        input_file.write(input_data)\n",
    "        input_file.flush()\n",
    "\n",
    "        wrapped_code = _get_wrapped_code(input_file.name, code)\n",
    "\n",
    "        with tempfile.NamedTemporaryFile(mode=\"w\", suffix=\".py\") as code_file:\n",
    "            code_file.write(wrapped_code)\n",
    "            code_file.flush()\n",
    "\n",
    "            completed_process = subprocess.run(\n",
    "                [sys.executable, code_file.name], capture_output=True, text=True\n",
    "            )\n",
    "\n",
    "            if completed_process.returncode == 0 and completed_process.stdout:\n",
    "                regex = r\"RESULT: (?P<output>\\d+)\"\n",
    "                pattern = re.compile(regex, re.MULTILINE)\n",
    "                match = pattern.search(completed_process.stdout)\n",
    "                if match:\n",
    "                    return int(match.group(\"output\"))\n",
    "            return None\n",
    "\n",
    "\n",
    "def solution_passes_test(\n",
    "    solution: Solution, test_input_and_output: TestInputAndOutput\n",
    ") -> bool:\n",
    "    actual_test_output = run_code(solution.code, test_input_and_output.test_input)\n",
    "    return actual_test_output == test_input_and_output.expected_output\n",
    "\n",
    "\n",
    "def test_solutions(state: OverallState) -> OverallState:\n",
    "    tested_solutions = [\n",
    "        solution\n",
    "        for solution in state.solutions\n",
    "        if solution_passes_test(solution, state.test_input_and_output)\n",
    "    ]\n",
    "    return {\"tested_solutions\": tested_solutions}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "60739674-0199-4a15-a437-6c8c626940a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_core.messages import HumanMessage, SystemMessage\n",
    "from langchain_google_genai import ChatGoogleGenerativeAI\n",
    "\n",
    "\n",
    "def get_criterions() -> List[str]:\n",
    "    return [\"efficiency\", \"readability\", \"maintainability\"]\n",
    "\n",
    "\n",
    "def evaluate_solutions(state: OverallState, criterion: str) -> OverallState:\n",
    "    solutions_text = \"\"\n",
    "    for idx, solution in enumerate(state.tested_solutions):\n",
    "        solutions_text += f\"Solution {idx}:\\n\" \"'''\\n\" f\"{solution.code}\" \"'''\\n\" \"\\n\"\n",
    "\n",
    "    messages = [\n",
    "        SystemMessage(\n",
    "            content=(\n",
    "                \"You are a helpful assistant tasked with evaluating solutions to programming puzzles. \"\n",
    "                \"You will get a list of solutions (code). \"\n",
    "                \"You evaluate the solutions according to a given criterion. \"\n",
    "                \"The actual evaluation is a number between 0 (worst) and 10 (best).\"\n",
    "            )\n",
    "        ),\n",
    "        HumanMessage(\n",
    "            content=(\n",
    "                \"Given the following programming puzzle description: \\n\"\n",
    "                \"```\\n\"\n",
    "                f\"{state.puzzle_description}\"\n",
    "                \"```\\n\"\n",
    "                \"\\n\"\n",
    "                f\"Also given the following solutions in the {state.programming_language} programming language:\\n\"\n",
    "                \"```\\n\"\n",
    "                f\"{solutions_text}\"\n",
    "                \"```\\n\"\n",
    "                \"\\n\"\n",
    "                f\"Evaluate the solutions according to the criterion '{criterion}'.\"\n",
    "            )\n",
    "        ),\n",
    "    ]\n",
    "\n",
    "    model = ChatGoogleGenerativeAI(model=\"gemini-1.5-pro\")\n",
    "    model_with_structured_output = model.with_structured_output(SolutionsEvaluations)\n",
    "    solution_evaluations = model_with_structured_output.invoke(messages)\n",
    "    return {\"evaluations\": [solution_evaluations]}\n",
    "\n",
    "\n",
    "def get_evaluate_solutions_node(\n",
    "    criterion: str,\n",
    ") -> Callable[[OverallState], OverallState]:\n",
    "    return partial(evaluate_solutions, criterion=criterion)\n",
    "\n",
    "\n",
    "def get_evaluate_solutions_node_name(criterion: str) -> str:\n",
    "    return f\"evaluate_solutions_regarding_{criterion}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "497b1f33-0e8d-4447-be71-cdf585b427b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "\n",
    "def aggregate_evaluations(state: OverallState) -> OverallState:\n",
    "    overall_scores = defaultdict(int)\n",
    "    for solutions_evaluations in state.evaluations:\n",
    "        for evaluation in solutions_evaluations.solutions_evaluations:\n",
    "            overall_scores[evaluation.solution_idx] += evaluation.score\n",
    "    sorted_overall_scores = sorted(\n",
    "        [\n",
    "            (overall_score, solution_idx)\n",
    "            for solution_idx, overall_score in overall_scores.items()\n",
    "        ],\n",
    "        key=lambda t: t[0],\n",
    "        reverse=True,\n",
    "    )\n",
    "    best_solution_idx = sorted_overall_scores[0][1]\n",
    "    return {\n",
    "        \"best_solution_idx\": best_solution_idx,\n",
    "        \"best_solution\": state.tested_solutions[best_solution_idx],\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "af01ca4d-0017-47ea-9558-cd97f25c6dd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import Image, display\n",
    "from langgraph.graph import END, START, StateGraph\n",
    "from langgraph.graph.graph import CompiledGraph\n",
    "\n",
    "\n",
    "def create_graph() -> CompiledGraph:\n",
    "    workflow = StateGraph(OverallState)\n",
    "\n",
    "    # Nodes\n",
    "    workflow.add_node(\"get_puzzle_url\", get_puzzle_url)\n",
    "    workflow.add_node(\"get_puzzle_description\", get_puzzle_description)\n",
    "    workflow.add_node(\n",
    "        \"get_puzzle_test_input_and_output\", get_puzzle_test_input_and_output\n",
    "    )\n",
    "    for model in get_models():\n",
    "        workflow.add_node(\n",
    "            get_solve_puzzle_node_name(model.model), get_solve_puzzle_node(model)\n",
    "        )\n",
    "    workflow.add_node(\"test_solutions\", test_solutions)\n",
    "\n",
    "    for criterion in get_criterions():\n",
    "        workflow.add_node(\n",
    "            get_evaluate_solutions_node_name(criterion),\n",
    "            get_evaluate_solutions_node(criterion),\n",
    "        )\n",
    "    workflow.add_node(\"aggregate_evaluations\", aggregate_evaluations)\n",
    "\n",
    "    # Edges\n",
    "    workflow.add_edge(START, \"get_puzzle_url\")\n",
    "    workflow.add_edge(\"get_puzzle_url\", \"get_puzzle_description\")\n",
    "    workflow.add_edge(\"get_puzzle_description\", \"get_puzzle_test_input_and_output\")\n",
    "\n",
    "    for model in get_models():\n",
    "        node_name = get_solve_puzzle_node_name(model.model)\n",
    "        workflow.add_edge(\"get_puzzle_test_input_and_output\", node_name)\n",
    "        workflow.add_edge(node_name, \"test_solutions\")\n",
    "\n",
    "    for criterion in get_criterions():\n",
    "        node_name = get_evaluate_solutions_node_name(criterion)\n",
    "        workflow.add_edge(\"test_solutions\", node_name)\n",
    "        workflow.add_edge(node_name, \"aggregate_evaluations\")\n",
    "    workflow.add_edge(\"aggregate_evaluations\", END)\n",
    "\n",
    "    graph = workflow.compile()\n",
    "    return graph\n",
    "\n",
    "\n",
    "graph = create_graph()\n",
    "\n",
    "display(Image(graph.get_graph().draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b9efdfb-c96a-41c3-87cb-b76dc264b4e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "graph.invoke({\"year\": 2024, \"day\": 3, \"programming_language\": \"Python\"})"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}