Added LangGraph version demo.

.gitignore

@@ -1,3 +1,4 @@
 .venv
 .vscode
 __pycache__
+.env

langgraph_meta_prompt.ipynb

@@ -0,0 +1,881 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Annotated, Sequence, Dict, Any\n",
+    "\n",
+    "from typing_extensions import TypedDict\n",
+    "\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "from langgraph.graph import StateGraph, END\n",
+    "from langgraph.graph.message import add_messages\n",
+    "from langchain_core.messages import HumanMessage, SystemMessage, BaseMessage\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.pydantic_v1 import BaseModel\n",
+    "\n",
+    "import operator\n",
+    "import random\n",
+    "\n",
+    "# Can converge correctly\n",
+    "\n",
+    "MODEL_NAME = \"anthropic/claude-3.5-sonnet:beta\"\n",
+    "# MODEL_NAME = \"llama3-70b-8192\"\n",
+    "# MODEL_NAME = \"meta-llama/llama-3-70b-instruct\"\n",
+    "# MODEL_NAME = \"deepseek/deepseek-chat\"\n",
+    "# MODEL_NAME = \"qwen/qwen-2-72b-instruct\"\n",
+    "\n",
+    "# Failed to converge correctly\n",
+    "\n",
+    "# MODEL_NAME = \"llama3-8b-8192\"\n",
+    "# MODEL_NAME = \"mistralai/mixtral-8x22b-instruct\"\n",
+    "# MODEL_NAME = \"anthropic/claude-3-haiku:beta\"\n",
+    "# MODEL_NAME = \"google/gemma-2-9b-it\"\n",
+    "# MODEL_NAME = \"meta-llama/llama-3-8b-instruct\"\n",
+    "# MODEL_NAME = \"microsoft/phi-3-medium-128k-instruct\"\n",
+    "# MODEL_NAME = \"mixtral-8x7b-32768\"\n",
+    "# MODEL_NAME = \"cohere/command-r\"\n",
+    "\n",
+    "llm = ChatOpenAI(model_name=MODEL_NAME, temperature=0.5)\n",
+    "\n",
+    "# EXECUTOR_MODEL = \"microsoft/phi-3-medium-128k-instruct:free\"\n",
+    "# EXECUTOR_MODEL = \"deepseek/deepseek-chat\"\n",
+    "# EXECUTOR_MODEL = \"gemma-7b-it\"\n",
+    "# EXECUTOR_MODEL = \"llama3-8b-8192\"\n",
+    "# EXECUTOR_MODEL = \"llama3-70b-8192\"\n",
+    "# EXECUTOR_MODEL = \"mixtral-8x7b-32768\"\n",
+    "# EXECUTOR_MODEL = \"anthropic/claude-3-haiku:beta\"\n",
+    "EXECUTOR_MODEL = \"meta-llama/llama-3-8b-instruct\"\n",
+    "# EXECUTOR_MODEL = \"google/gemma-2-9b-it\"\n",
+    "\n",
+    "executor_llm = ChatOpenAI(model_name=EXECUTOR_MODEL, temperature=0.01)\n",
+    "\n",
+    "class AgentState(BaseModel):\n",
+    "    # messages: Annotated[Sequence[BaseMessage], operator.add] = []\n",
+    "    acceptance_criteria: str = \"Exactly text match.\"\n",
+    "    user_message: str = \"\"\n",
+    "    expected_output: str = \"\"\n",
+    "    system_message: str = \"\"\n",
+    "    output: str = \"\"\n",
+    "    suggestions: str = \"\"\n",
+    "    accepted: bool = False\n",
+    "    analysis: str = \"\"\n",
+    "    best_output: str = \"\"\n",
+    "    best_system_message: str = \"\"\n",
+    "    best_output_age: int = 0\n",
+    "    max_output_age: int = 0\n",
+    "\n",
+    "def prompt_developer(state: AgentState) -> AgentState:\n",
+    "    # llm = ChatOpenAI(temperature=0.1)\n",
+    "    \n",
+    "    if not state.system_message:\n",
+    "        # Initial system message creation\n",
+    "        initial_prompt = ChatPromptTemplate.from_messages([\n",
+    "            (\"system\", \"\"\"# Expert Prompt Engineer\n",
+    "\n",
+    "You are an expert prompt engineer tasked with creating system messages for AI\n",
+    "assistants.\n",
+    "\n",
+    "## Instructions\n",
+    "\n",
+    "1. Create a system message based on the given user message and expected output.\n",
+    "2. Ensure the system message can handle similar user messages.\n",
+    "3. Output only the system message, without any additional content.\n",
+    "4. Expected Output text should not appear in System Message as an example. But\n",
+    "   it's OK to use some similar text as an example instead.\n",
+    "5. Format the system message well, with no more than 80 characters per line\n",
+    "   (except for raw text).\n",
+    "\n",
+    "## Output\n",
+    "\n",
+    "Provide only the system message, adhering to the above guidelines.\n",
+    "\"\"\"),\n",
+    "            (\"human\", \"User message: {user_message}\\nExpected output: {expected_output}\\nCreate a system message that will guide the AI to produce the expected output.\")\n",
+    "        ])\n",
+    "        response = llm(initial_prompt.format_messages(\n",
+    "            user_message=state.user_message, \n",
+    "            expected_output=state.expected_output\n",
+    "        ))\n",
+    "        state.system_message = response.content\n",
+    "    else:\n",
+    "        # Update system message based on analysis\n",
+    "        update_prompt = ChatPromptTemplate.from_messages([\n",
+    "            (\"system\", \"\"\"# Expert Prompt Engineer\n",
+    "\n",
+    "You are an expert prompt engineer tasked with updating system messages for AI\n",
+    "assistants.\n",
+    "\n",
+    "## Instructions\n",
+    "\n",
+    "1. Update the system message based on the given suggestion, user message, and\n",
+    "   expected output.\n",
+    "2. Ensure the updated system message can handle similar user messages.\n",
+    "3. Output only the updated system message, without any additional content.\n",
+    "4. Expected Output text should not appear in System Message as an example. But\n",
+    "   it's OK to use some similar text as an example instead.\n",
+    "5. Format the system message well, with no more than 80 characters per line\n",
+    "   (except for raw text).\n",
+    "\n",
+    "## Output\n",
+    "\n",
+    "Provide only the updated system message, adhering to the above guidelines.\n",
+    "\"\"\"),\n",
+    "            (\"human\", \"\"\"Current system message: {system_message}\n",
+    "User message: {user_message}\n",
+    "Expected output: {expected_output}\n",
+    "Suggestions: {suggestions}\n",
+    "                \n",
+    "Update the system message according to Suggestions, to improve the output and match the expected output more closely.\n",
+    "\"\"\")\n",
+    "        ])\n",
+    "        response = llm(update_prompt.format_messages(**state.dict()))\n",
+    "        state.system_message = response.content\n",
+    "    print(state.system_message)\n",
+    "\n",
+    "    # state.messages.append(SystemMessage(content=state.system_message))\n",
+    "    return state\n",
+    "\n",
+    "def prompt_executor(state: AgentState) -> AgentState:\n",
+    "    # llm = ChatOpenAI(temperature=0.1)\n",
+    "    messages = [\n",
+    "        SystemMessage(content=state.system_message),\n",
+    "        HumanMessage(content=state.user_message)\n",
+    "        ]\n",
+    "    response = executor_llm(messages)\n",
+    "    state.output = response.content\n",
+    "    # state.messages.append(HumanMessage(content=state.user_message))\n",
+    "    # state.messages.append(response)\n",
+    "\n",
+    "    print(response.content)\n",
+    "\n",
+    "    return state\n",
+    "\n",
+    "def prompt_analyzer(state: AgentState) -> AgentState:\n",
+    "    # Updated to compare output and expected output with LLM and format the response\n",
+    "    comparison_prompt_template = \"\"\"\n",
+    "You are a text comparing program. You compare the following output texts and provide a\n",
+    "detailed analysis according to `Acceptance Criteria`. Then you decide whether `Actual Output`\n",
+    "is acceptable.\n",
+    "\n",
+    "# Expected Output\n",
+    "\n",
+    "```\n",
+    "{expected_output}\n",
+    "```\n",
+    "\n",
+    "#Actual Output\n",
+    "\n",
+    "```\n",
+    "{output}\n",
+    "```\n",
+    "\n",
+    "----\n",
+    "\n",
+    "Provide your analysis in the following format:\n",
+    "\n",
+    "```\n",
+    "- Acceptable Differences: [List acceptable differences succinctly]\n",
+    "- Unacceptable Differences: [List unacceptable differences succinctly]\n",
+    "- Accept: [Yes/No]\n",
+    "```\n",
+    "\n",
+    "* Compare Expected Output and Actual Output with the guidance of Accept Criteria.\n",
+    "* Only set 'Accept' to 'Yes', if Accept Criteria are all met. Otherwise, set 'Accept' to 'No'.\n",
+    "* List only the acceptable differences according to Accept Criteria in 'acceptable Differences' section.\n",
+    "* List only the unacceptable differences according to Accept Criteria in 'Unacceptable Differences' section.\n",
+    "\n",
+    "# Acceptance Criteria\n",
+    "\n",
+    "```\n",
+    "{acceptance_criteria}\n",
+    "```\n",
+    "\"\"\"\n",
+    "\n",
+    "    comparison_prompt = ChatPromptTemplate.from_messages([\n",
+    "            (\"system\", comparison_prompt_template)\n",
+    "        ])\n",
+    "    \n",
+    "    # Format the prompt with the current state\n",
+    "    formatted_prompt = comparison_prompt.format_messages(**state.dict())\n",
+    "    \n",
+    "    # Send the prompt to the LLM\n",
+    "    response = llm(formatted_prompt)\n",
+    "    state.analysis = response.content\n",
+    "\n",
+    "    print(response.content)\n",
+    "    \n",
+    "    try:\n",
+    "        # Parse the LLM response to update the state\n",
+    "        analysis_result = parse_llm_response(response.content)\n",
+    "        \n",
+    "        # Update state.matched based on the LLM's analysis\n",
+    "        state.accepted = analysis_result['Accept'].lower() == 'yes'\n",
+    "    except KeyError:\n",
+    "        # If the LLM response is not in the expected format, set matched to False\n",
+    "        state.accepted = False\n",
+    "            \n",
+    "    return state\n",
+    "\n",
+    "def parse_llm_response(response: str) -> dict:\n",
+    "    \"\"\"\n",
+    "    Parses the LLM response to handle both single-line and multi-line formats for Differences and Suggestions.\n",
+    "    \"\"\"\n",
+    "    lines = response.split('\\n')\n",
+    "    result = {}\n",
+    "\n",
+    "    # Process each line\n",
+    "    for line in lines:\n",
+    "        # skip the spaces before `- `\n",
+    "        line = line.strip()\n",
+    "        if line.startswith('- Accept:'):\n",
+    "            result['Accept'] = line.split(': ')[1].strip()\n",
+    "            break\n",
+    "\n",
+    "    return result\n",
+    "\n",
+    "def output_history_analyzer(state: AgentState) -> AgentState:\n",
+    "    system_message_template = \"\"\"You are a text comparing program. You read the Acceptance Criteria, compare the\n",
+    "compare the exptected output with two different outputs, and decide which one is\n",
+    "more similar to the expected output.\n",
+    "\n",
+    "Output the ID of the output that is more similar to the expected output, with the\n",
+    "following format:\n",
+    "    \n",
+    "```\n",
+    "# Better Output ID: [ID]\n",
+    "```\n",
+    "\n",
+    "If both outputs are equally similar to the expected output, output the following:\n",
+    "\n",
+    "```\n",
+    "# Draw\n",
+    "```\n",
+    "\"\"\"\n",
+    "    human_message_templates = [\n",
+    "        \"\"\"\n",
+    "# Output ID: A\n",
+    "\n",
+    "```\n",
+    "{best_output}\n",
+    "```\n",
+    "\n",
+    "# Output ID: B\n",
+    "\n",
+    "```\n",
+    "{output}\n",
+    "```\n",
+    "\n",
+    "# Acceptance Criteria\n",
+    "\n",
+    "{acceptance_criteria}\n",
+    "\n",
+    "# Expected Output\n",
+    "\n",
+    "```\n",
+    "{expected_output}\n",
+    "```\n",
+    "\"\"\",\n",
+    "        \"\"\"\n",
+    "# Output ID: B\n",
+    "\n",
+    "```\n",
+    "{output}\n",
+    "```\n",
+    "\n",
+    "# Output ID: A\n",
+    "\n",
+    "```\n",
+    "{best_output}\n",
+    "```\n",
+    "\n",
+    "# Acceptance Criteria\n",
+    "\n",
+    "{acceptance_criteria}\n",
+    "             \n",
+    "# Expected Output\n",
+    "\n",
+    "```\n",
+    "{expected_output}\n",
+    "```\n",
+    "\"\"\"\n",
+    "    ]\n",
+    "\n",
+    "    # pick a random human message template\n",
+    "    output_comparison_prompt_template = ChatPromptTemplate.from_messages([\n",
+    "        (\"system\", system_message_template),\n",
+    "        (\"human\", human_message_templates[random.randint(0, 1)])\n",
+    "        ])\n",
+    "\n",
+    "    if (state.best_output is None or state.best_output == \"\") and \\\n",
+    "        (state.best_system_message is None or state.best_system_message == \"\"):\n",
+    "        state.best_output = state.output\n",
+    "        state.best_system_message = state.system_message\n",
+    "        state.best_output_age = 0\n",
+    "\n",
+    "        return state\n",
+    "\n",
+    "    response = llm(output_comparison_prompt_template.format_messages(**state.dict()))\n",
+    "\n",
+    "    print(response.content)\n",
+    "\n",
+    "    result = parse_output_history_analyzer(response.content, 'A')\n",
+    "\n",
+    "    if result == 'A':\n",
+    "        state.best_output_age += 1\n",
+    "        state.output = state.best_output\n",
+    "        state.system_message = state.best_system_message\n",
+    "    else:\n",
+    "        state.best_output = state.output\n",
+    "        state.best_system_message = state.system_message\n",
+    "        state.best_output_age = 0\n",
+    "\n",
+    "    return state\n",
+    "\n",
+    "def parse_output_history_analyzer(response: str, default_result = None) -> dict:\n",
+    "    \"\"\"\n",
+    "    Parses the LLM response to handle both single-line and multi-line formats for Differences and Suggestions.\n",
+    "    \"\"\"\n",
+    "    lines = response.split('\\n')\n",
+    "    result = default_result\n",
+    "\n",
+    "    # Process each line\n",
+    "    for line in lines:\n",
+    "        # skip the spaces before `- `\n",
+    "        line = line.strip()\n",
+    "        if line.startswith('# Better Output ID:'):\n",
+    "            result = line.split(': ')[1].strip()\n",
+    "            break\n",
+    "        elif line.startswith('# Draw'):\n",
+    "            result = default_result\n",
+    "            break\n",
+    "\n",
+    "    return result\n",
+    "\n",
+    "def prompt_suggester(state: AgentState) -> AgentState:\n",
+    "    # Updated to compare output and expected output with LLM and format the response\n",
+    "    suggester_prompt_template = \"\"\"\n",
+    "Read the following inputs and outputs of an LLM prompt, and also analysis about them.\n",
+    "Then suggest how to improve System Prompt.\n",
+    "\n",
+    "System Prompt:\n",
+    "```\n",
+    "{system_message}\n",
+    "```\n",
+    "User Message:\n",
+    "```\n",
+    "{user_message}\n",
+    "```\n",
+    "Expected Output: \n",
+    "```\n",
+    "{expected_output}\n",
+    "```\n",
+    "Actual Output: \n",
+    "```\n",
+    "{output}\n",
+    "```\n",
+    "\n",
+    "Acceptance Criteria:\n",
+    "```\n",
+    "{acceptance_criteria}\n",
+    "```\n",
+    "\n",
+    "Analysis:\n",
+    "```\n",
+    "{analysis}\n",
+    "```\n",
+    "\n",
+    "* The goal is to improve the System Prompt to match the Expected Output better.\n",
+    "* Ignore all `Acceptable Differences` and focus on `Unacceptable Differences`.\n",
+    "* Provide your suggestions in a Markdown list, nothing else.\n",
+    "* Expected Output text should not appear in System Message as an example. But\n",
+    "  it's OK to use some similar text as an example instead.\n",
+    "\"\"\"\n",
+    "\n",
+    "    suggester_prompt = ChatPromptTemplate.from_messages([\n",
+    "            (\"system\", suggester_prompt_template)\n",
+    "        ])\n",
+    "    \n",
+    "    # Format the prompt with the current state\n",
+    "    formatted_prompt = suggester_prompt.format_messages(**state.dict())\n",
+    "    \n",
+    "    # Send the prompt to the LLM\n",
+    "    response = llm(formatted_prompt)\n",
+    "    state.suggestions = response.content\n",
+    "\n",
+    "    print(response.content)\n",
+    "            \n",
+    "    return state\n",
+    "\n",
+    "def should_exit_on_max_age(state: AgentState) -> str:\n",
+    "    if state.max_output_age <=0:\n",
+    "        # always continue if max age is 0\n",
+    "        return \"continue\"\n",
+    "    \n",
+    "    if state.best_output_age >= state.max_output_age:\n",
+    "        return END\n",
+    "    \n",
+    "    return \"continue\"\n",
+    "\n",
+    "def should_exit_on_acceptable_output(state: AgentState) -> str:\n",
+    "    if state.accepted:\n",
+    "        return END\n",
+    "    else:\n",
+    "        return \"continue\"\n",
+    "\n",
+    "\n",
+    "workflow = StateGraph(AgentState)\n",
+    "\n",
+    "workflow.add_node(\"prompt_developer\", prompt_developer)\n",
+    "workflow.add_node(\"prompt_executor\", prompt_executor)\n",
+    "workflow.add_node(\"output_history_analyzer\", output_history_analyzer)\n",
+    "workflow.add_node(\"prompt_analyzer\", prompt_analyzer)\n",
+    "workflow.add_node(\"prompt_suggester\", prompt_suggester)\n",
+    "\n",
+    "workflow.set_entry_point(\"prompt_developer\")\n",
+    "\n",
+    "workflow.add_edge(\"prompt_developer\", \"prompt_executor\")\n",
+    "workflow.add_edge(\"prompt_executor\", \"output_history_analyzer\")\n",
+    "\n",
+    "workflow.add_conditional_edges(\n",
+    "    \"output_history_analyzer\",\n",
+    "    should_exit_on_max_age,\n",
+    "    {\n",
+    "        \"continue\": \"prompt_analyzer\",\n",
+    "        END: END\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "workflow.add_conditional_edges(\n",
+    "    \"prompt_analyzer\",\n",
+    "    should_exit_on_acceptable_output,\n",
+    "    {\n",
+    "        \"continue\": \"prompt_suggester\",\n",
+    "        END: END\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "workflow.add_edge(\"prompt_suggester\", \"prompt_developer\")\n",
+    "\n",
+    "graph = workflow.compile()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image, display\n",
+    "\n",
+    "try:\n",
+    "    display(Image(graph.get_graph().draw_mermaid_png()))\n",
+    "except Exception:\n",
+    "    # This requires some extra dependencies and is optional\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "User Message: (2+8)*3\n",
+      "Expected Output: (2+8)*3\n",
+      "= 10*3\n",
+      "= 30\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/yale/work/meta-prompt/.venv/lib/python3.10/site-packages/langchain_core/_api/deprecation.py:139: LangChainDeprecationWarning: The method `BaseChatModel.__call__` was deprecated in langchain-core 0.1.7 and will be removed in 0.3.0. Use invoke instead.\n",
+      "  warn_deprecated(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "You are a step-by-step math calculator. When given a mathematical\n",
+      "expression:\n",
+      "\n",
+      "1. Display the original expression on the first line.\n",
+      "2. On the next line, show the first step of the calculation, preceded by '='.\n",
+      "3. Continue showing each step on a new line until the final result is reached.\n",
+      "4. Simplify expressions within parentheses before applying operations outside.\n",
+      "5. Show multiplication using the '*' symbol.\n",
+      "6. Do not explain the steps; simply show the calculations.\n",
+      "\n",
+      "Provide the solution using this clear, concise format to help users understand\n",
+      "the problem-solving process.\n",
+      "(2+8)*3\n",
+      "= 2 + 8\n",
+      "= 10\n",
+      "= 10 * 3\n",
+      "= 30\n",
+      "Based on the provided Expected Output, Actual Output, and Acceptance Criteria, here's the analysis:\n",
+      "\n",
+      "```\n",
+      "- Acceptable Differences: \n",
+      "  * Extra line break at the end of the Actual Output\n",
+      "\n",
+      "- Unacceptable Differences: \n",
+      "  * Actual Output shows intermediate steps (2 + 8 = 10) not present in Expected Output\n",
+      "  * Actual Output separates 10 * 3 into a separate step, which is not in Expected Output\n",
+      "\n",
+      "- Accept: No\n",
+      "```\n",
+      "\n",
+      "The Actual Output differs significantly from the Expected Output in terms of content, showing additional steps in the calculation process that are not present in the Expected Output. These differences go beyond the acceptable criteria of extra spaces or line breaks. Therefore, the Actual Output is not acceptable according to the given Acceptance Criteria.\n",
+      "Here are suggestions to improve the System Prompt:\n",
+      "\n",
+      "- Add a specific instruction to simplify expressions within parentheses in a single step, without showing intermediate calculations.\n",
+      "- Include a clear directive to perform multiplication immediately after simplifying parentheses, without separating it into an additional step.\n",
+      "- Provide an example calculation in the prompt that demonstrates the desired output format, such as `(3+2)*4 = 5*4 = 20`.\n",
+      "- Explicitly state that only two lines of calculation should be shown for expressions with a single set of parentheses: one for simplifying the parentheses and one for the final result.\n",
+      "- Remove or modify the instruction about showing each step, as it may encourage unnecessary intermediate steps.\n",
+      "- Add a note that the solution should be as concise as possible, showing only the essential steps.\n",
+      "You are a step-by-step math calculator. When given a mathematical expression:\n",
+      "\n",
+      "1. Display the original expression on the first line.\n",
+      "2. Simplify expressions within parentheses in a single step, without showing\n",
+      "   intermediate calculations.\n",
+      "3. Perform multiplication immediately after simplifying parentheses, without\n",
+      "   separating it into an additional step.\n",
+      "4. Show the final result on the last line.\n",
+      "5. Use the '*' symbol for multiplication.\n",
+      "6. For expressions with a single set of parentheses, show only two lines of\n",
+      "   calculation: one for simplifying the parentheses and one for the final\n",
+      "   result.\n",
+      "7. Provide the solution in the most concise format possible, showing only\n",
+      "   essential steps.\n",
+      "\n",
+      "Do not explain the steps; simply show the calculations. Here's an example of\n",
+      "the desired output format:\n",
+      "\n",
+      "(3+2)*4\n",
+      "= 5*4\n",
+      "= 20\n",
+      "\n",
+      "This clear, concise format will help users understand the problem-solving\n",
+      "process efficiently.\n",
+      "(2+8)*3\n",
+      "= 10*3\n",
+      "= 30\n",
+      "After comparing the two outputs with the expected output based on the given acceptance criteria, I can conclude:\n",
+      "\n",
+      "# Better Output ID: B\n",
+      "\n",
+      "Output B is more similar to the expected output. It matches the expected output exactly, with the only difference being a missing line break at the end, which is acceptable according to the criteria. Output A, while reaching the same final result, includes additional steps that are not present in the expected output.\n",
+      "Here's the analysis based on the provided Expected Output, Actual Output, and Acceptance Criteria:\n",
+      "\n",
+      "```\n",
+      "- Acceptable Differences: \n",
+      "  * Missing line break at the end of the Actual Output.\n",
+      "\n",
+      "- Unacceptable Differences: \n",
+      "  [None]\n",
+      "\n",
+      "- Accept: Yes\n",
+      "```\n",
+      "\n",
+      "The Actual Output matches the Expected Output exactly in terms of content and formatting, with the only difference being a missing line break at the end of the Actual Output. This falls under the acceptable differences as per the Acceptance Criteria, which allows for \"Extra or missing line breaks at the beginning or end of the output.\" Therefore, the Actual Output is acceptable.\n",
+      "Final Result: {'acceptance_criteria': '\\n* Exactly text match.\\n* Acceptable differences:\\n  * Extra or missing spaces.\\n  * Extra or missing line breaks at the beginning or end of the output.\\n', 'user_message': '(2+8)*3', 'expected_output': '(2+8)*3\\n= 10*3\\n= 30\\n', 'system_message': \"You are a step-by-step math calculator. When given a mathematical expression:\\n\\n1. Display the original expression on the first line.\\n2. Simplify expressions within parentheses in a single step, without showing\\n   intermediate calculations.\\n3. Perform multiplication immediately after simplifying parentheses, without\\n   separating it into an additional step.\\n4. Show the final result on the last line.\\n5. Use the '*' symbol for multiplication.\\n6. For expressions with a single set of parentheses, show only two lines of\\n   calculation: one for simplifying the parentheses and one for the final\\n   result.\\n7. Provide the solution in the most concise format possible, showing only\\n   essential steps.\\n\\nDo not explain the steps; simply show the calculations. Here's an example of\\nthe desired output format:\\n\\n(3+2)*4\\n= 5*4\\n= 20\\n\\nThis clear, concise format will help users understand the problem-solving\\nprocess efficiently.\", 'output': '(2+8)*3\\n= 10*3\\n= 30', 'suggestions': 'Here are suggestions to improve the System Prompt:\\n\\n- Add a specific instruction to simplify expressions within parentheses in a single step, without showing intermediate calculations.\\n- Include a clear directive to perform multiplication immediately after simplifying parentheses, without separating it into an additional step.\\n- Provide an example calculation in the prompt that demonstrates the desired output format, such as `(3+2)*4 = 5*4 = 20`.\\n- Explicitly state that only two lines of calculation should be shown for expressions with a single set of parentheses: one for simplifying the parentheses and one for the final result.\\n- Remove or modify the instruction about showing each step, as it may encourage unnecessary intermediate steps.\\n- Add a note that the solution should be as concise as possible, showing only the essential steps.', 'accepted': True, 'analysis': 'Here\\'s the analysis based on the provided Expected Output, Actual Output, and Acceptance Criteria:\\n\\n```\\n- Acceptable Differences: \\n  * Missing line break at the end of the Actual Output.\\n\\n- Unacceptable Differences: \\n  [None]\\n\\n- Accept: Yes\\n```\\n\\nThe Actual Output matches the Expected Output exactly in terms of content and formatting, with the only difference being a missing line break at the end of the Actual Output. This falls under the acceptable differences as per the Acceptance Criteria, which allows for \"Extra or missing line breaks at the beginning or end of the output.\" Therefore, the Actual Output is acceptable.', 'best_output': '(2+8)*3\\n= 10*3\\n= 30', 'best_system_message': \"You are a step-by-step math calculator. When given a mathematical expression:\\n\\n1. Display the original expression on the first line.\\n2. Simplify expressions within parentheses in a single step, without showing\\n   intermediate calculations.\\n3. Perform multiplication immediately after simplifying parentheses, without\\n   separating it into an additional step.\\n4. Show the final result on the last line.\\n5. Use the '*' symbol for multiplication.\\n6. For expressions with a single set of parentheses, show only two lines of\\n   calculation: one for simplifying the parentheses and one for the final\\n   result.\\n7. Provide the solution in the most concise format possible, showing only\\n   essential steps.\\n\\nDo not explain the steps; simply show the calculations. Here's an example of\\nthe desired output format:\\n\\n(3+2)*4\\n= 5*4\\n= 20\\n\\nThis clear, concise format will help users understand the problem-solving\\nprocess efficiently.\", 'best_output_age': 0, 'max_output_age': 3}\n",
+      "System Message:\n",
+      "You are a step-by-step math calculator. When given a mathematical expression:\n",
+      "\n",
+      "1. Display the original expression on the first line.\n",
+      "2. Simplify expressions within parentheses in a single step, without showing\n",
+      "   intermediate calculations.\n",
+      "3. Perform multiplication immediately after simplifying parentheses, without\n",
+      "   separating it into an additional step.\n",
+      "4. Show the final result on the last line.\n",
+      "5. Use the '*' symbol for multiplication.\n",
+      "6. For expressions with a single set of parentheses, show only two lines of\n",
+      "   calculation: one for simplifying the parentheses and one for the final\n",
+      "   result.\n",
+      "7. Provide the solution in the most concise format possible, showing only\n",
+      "   essential steps.\n",
+      "\n",
+      "Do not explain the steps; simply show the calculations. Here's an example of\n",
+      "the desired output format:\n",
+      "\n",
+      "(3+2)*4\n",
+      "= 5*4\n",
+      "= 20\n",
+      "\n",
+      "This clear, concise format will help users understand the problem-solving\n",
+      "process efficiently.\n",
+      "Output:\n",
+      "(2+8)*3\n",
+      "= 10*3\n",
+      "= 30\n"
+     ]
+    }
+   ],
+   "source": [
+    "initial_states = [\n",
+    "    AgentState(\n",
+    "        max_output_age=3,\n",
+    "        user_message=\"(2+8)*3\",\n",
+    "        expected_output=\"\"\"(2+8)*3\n",
+    "= 10*3\n",
+    "= 30\n",
+    "\"\"\",\n",
+    "        acceptance_criteria=\"\"\"\n",
+    "* Exactly text match.\n",
+    "* Acceptable differences:\n",
+    "  * Extra or missing spaces.\n",
+    "  * Extra or missing line breaks at the beginning or end of the output.\n",
+    "\"\"\"),\n",
+    "    AgentState(\n",
+    "        max_output_age=4,\n",
+    "        user_message=\"\"\"Here is the GDP data in billions of US dollars (USD) for these years:\n",
+    "\n",
+    "Germany:\n",
+    "\n",
+    "2015: $3,368.29 billion\n",
+    "2016: $3,467.79 billion\n",
+    "2017: $3,677.83 billion\n",
+    "2018: $3,946.00 billion\n",
+    "2019: $3,845.03 billion\n",
+    "France:\n",
+    "\n",
+    "2015: $2,423.47 billion\n",
+    "2016: $2,465.12 billion\n",
+    "2017: $2,582.49 billion\n",
+    "2018: $2,787.86 billion\n",
+    "2019: $2,715.52 billion\n",
+    "United Kingdom:\n",
+    "\n",
+    "2015: $2,860.58 billion\n",
+    "2016: $2,650.90 billion\n",
+    "2017: $2,622.43 billion\n",
+    "2018: $2,828.87 billion\n",
+    "2019: $2,829.21 billion\n",
+    "Italy:\n",
+    "\n",
+    "2015: $1,815.72 billion\n",
+    "2016: $1,852.50 billion\n",
+    "2017: $1,937.80 billion\n",
+    "2018: $2,073.90 billion\n",
+    "2019: $1,988.14 billion\n",
+    "Spain:\n",
+    "\n",
+    "2015: $1,199.74 billion\n",
+    "2016: $1,235.95 billion\n",
+    "2017: $1,313.13 billion\n",
+    "2018: $1,426.19 billion\n",
+    "2019: $1,430.38 billion\n",
+    "\"\"\",\n",
+    "        expected_output=\"\"\"Year,Germany,France,United Kingdom,Italy,Spain\n",
+    "2016-2015,2.96%,1.71%,-7.35%,2.02%,3.04%\n",
+    "2017-2016,5.08%,4.78%,-1.07%,4.61%,6.23%\n",
+    "2018-2017,7.48%,7.99%,7.89%,7.10%,8.58%\n",
+    "2019-2018,-2.56%,-2.59%,0.01%,-4.11%,0.30%\n",
+    "\"\"\",\n",
+    "        acceptance_criteria=\"\"\"\n",
+    "* Strict text matching of the first row and first column.\n",
+    "* Acceptable differences:\n",
+    "  * Differences in digital/percentage values in the table, even significant ones.\n",
+    "  * Extra or missing spaces.\n",
+    "  * Extra or missing line breaks.\n",
+    "\"\"\"),\n",
+    "    AgentState(\n",
+    "        max_output_age=3,\n",
+    "        user_message=\"\"\"\n",
+    "基因序列：ATGGCCATGGCGCCCAGAACTGAGATCAATAGTACCCGTATTAACGGGTGA\n",
+    "物种：大肠杆菌 (Escherichia coli)\n",
+    "\"\"\",\n",
+    "        expected_output=\"\"\"\n",
+    "{\n",
+    "  \"基因序列分析结果\": {\n",
+    "    \"基本信息\": {\n",
+    "      \"序列长度\": 54,\n",
+    "      \"GC含量\": \"51.85%\"\n",
+    "    },\n",
+    "    \"核苷酸组成\": {\n",
+    "      \"A\": {\"数量\": 12, \"百分比\": \"22.22%\"},\n",
+    "      \"T\": {\"数量\": 11, \"百分比\": \"20.37%\"},\n",
+    "      \"G\": {\"数量\": 16, \"百分比\": \"29.63%\"},\n",
+    "      \"C\": {\"数量\": 15, \"百分比\": \"27.78%\"}\n",
+    "    },\n",
+    "    \"密码子分析\": {\n",
+    "      \"起始密码子\": \"ATG\",\n",
+    "      \"终止密码子\": \"TGA\",\n",
+    "      \"密码子表\": [\n",
+    "        {\"密码子\": \"ATG\", \"氨基酸\": \"甲硫氨酸\", \"位置\": 1},\n",
+    "        {\"密码子\": \"GCC\", \"氨基酸\": \"丙氨酸\", \"位置\": 2},\n",
+    "        {\"密码子\": \"ATG\", \"氨基酸\": \"甲硫氨酸\", \"位置\": 3},\n",
+    "        // ... 其他密码子 ...\n",
+    "        {\"密码子\": \"TGA\", \"氨基酸\": \"终止密码子\", \"位置\": 18}\n",
+    "      ]\n",
+    "    },\n",
+    "    \"潜在功能预测\": {\n",
+    "      \"蛋白质长度\": 17,\n",
+    "      \"可能的功能域\": [\n",
+    "        {\"域名\": \"ABC转运蛋白\", \"起始位置\": 5, \"结束位置\": 15, \"置信度\": \"75%\"},\n",
+    "        {\"域名\": \"膜蛋白\", \"起始位置\": 1, \"结束位置\": 17, \"置信度\": \"60%\"}\n",
+    "      ],\n",
+    "      \"二级结构预测\": {\n",
+    "        \"α螺旋\": [\"2-8\", \"12-16\"],\n",
+    "        \"β折叠\": [\"9-11\"],\n",
+    "        \"无规卷曲\": [\"1\", \"17\"]\n",
+    "      }\n",
+    "    },\n",
+    "    \"同源性分析\": {\n",
+    "      \"最相似序列\": [\n",
+    "        {\n",
+    "          \"基因名\": \"abcT\",\n",
+    "          \"物种\": \"沙门氏菌 (Salmonella enterica)\",\n",
+    "          \"相似度\": \"89%\",\n",
+    "          \"E值\": \"3e-25\"\n",
+    "        },\n",
+    "        {\n",
+    "          \"基因名\": \"yojI\",\n",
+    "          \"物种\": \"大肠杆菌 (Escherichia coli)\",\n",
+    "          \"相似度\": \"95%\",\n",
+    "          \"E值\": \"1e-30\"\n",
+    "        }\n",
+    "      ]\n",
+    "    },\n",
+    "    \"突变分析\": {\n",
+    "      \"SNP位点\": [\n",
+    "        {\"位置\": 27, \"野生型\": \"A\", \"突变型\": \"G\", \"氨基酸变化\": \"谷氨酰胺->精氨酸\"},\n",
+    "        {\"位置\": 42, \"野生型\": \"C\", \"突变型\": \"T\", \"氨基酸变化\": \"无（同义突变）\"}\n",
+    "      ]\n",
+    "    }\n",
+    "  }\n",
+    "}\n",
+    "\"\"\",\n",
+    "        acceptance_criteria=\"\"\"\n",
+    "* Exactly text match.\n",
+    "* Acceptable differences:\n",
+    "  * Extra or missing spaces\n",
+    "  * Extra or missing line breaks at the beginning or end of the output\n",
+    "  * Different sequence length\n",
+    "  * Different GC content\n",
+    "  * Different nucleotide composition\n",
+    "  * Different codon table\n",
+    "  * Different potential function prediction\n",
+    "  * Different secondary structure prediction\n",
+    "  * Different similarity analysis\n",
+    "  * Different mutation analysis\n",
+    "\"\"\"),\n",
+    "    AgentState(\n",
+    "        max_output_age=3,\n",
+    "        user_message=\"\"\"\n",
+    "今天下午3点，在北京国家会议中心，阿里巴巴集团董事局主席马云宣布将投资100亿元人民币用于农村电商发展。这一决定受到了与会代表的热烈欢迎，大家认为这将为中国农村经济带来新的机遇。\n",
+    "\"\"\",\n",
+    "        expected_output=\"\"\"\n",
+    "{\n",
+    "  \"文本分析结果\": {\n",
+    "    \"情感分析\": {\n",
+    "      \"整体情感\": \"积极\",\n",
+    "      \"情感得分\": 0.82,\n",
+    "      \"情感细分\": {\n",
+    "        \"乐观\": 0.75,\n",
+    "        \"兴奋\": 0.60,\n",
+    "        \"期待\": 0.85\n",
+    "      }\n",
+    "    },\n",
+    "    \"实体识别\": [\n",
+    "      {\"实体\": \"北京\", \"类型\": \"地点\", \"起始位置\": 7, \"结束位置\": 9},\n",
+    "      {\"实体\": \"国家会议中心\", \"类型\": \"地点\", \"起始位置\": 9, \"结束位置\": 15},\n",
+    "      {\"实体\": \"阿里巴巴集团\", \"类型\": \"组织\", \"起始位置\": 16, \"结束位置\": 22},\n",
+    "      {\"实体\": \"马云\", \"类型\": \"人物\", \"起始位置\": 26, \"结束位置\": 28},\n",
+    "      {\"实体\": \"100亿元\", \"类型\": \"金额\", \"起始位置\": 32, \"结束位置\": 37},\n",
+    "      {\"实体\": \"人民币\", \"类型\": \"货币\", \"起始位置\": 37, \"结束位置\": 40},\n",
+    "      {\"实体\": \"中国\", \"类型\": \"地点\", \"起始位置\": 71, \"结束位置\": 73}\n",
+    "    ],\n",
+    "    \"关键词提取\": [\n",
+    "      {\"关键词\": \"农村电商\", \"权重\": 0.95},\n",
+    "      {\"关键词\": \"马云\", \"权重\": 0.85},\n",
+    "      {\"关键词\": \"投资\", \"权重\": 0.80},\n",
+    "      {\"关键词\": \"阿里巴巴\", \"权重\": 0.75},\n",
+    "      {\"关键词\": \"经济机遇\", \"权重\": 0.70}\n",
+    "    ]\n",
+    "  }\n",
+    "}\n",
+    "\"\"\",\n",
+    "        acceptance_criteria=\"\"\"\n",
+    "* Exactly text match, except for the numerical values.\n",
+    "* Acceptable differences:\n",
+    "  * Differences in digital values in the table.\n",
+    "  * Extra or missing spaces.\n",
+    "  * Extra or missing line breaks at the beginning or end of the output.\n",
+    "  * Extra or missing 3rd or 4th layer sections or items.\n",
+    "  * Differences in section/item orders.\n",
+    "\"\"\")\n",
+    "]\n",
+    "\n",
+    "selected_states = [initial_states[0]]\n",
+    "\n",
+    "for initial_state in selected_states:\n",
+    "    print(\"User Message:\", initial_state.user_message)\n",
+    "    print(\"Expected Output:\", initial_state.expected_output)\n",
+    "\n",
+    "    try:    \n",
+    "        result = graph.invoke(initial_state, {\"recursion_limit\": 100})\n",
+    "        print(\"Final Result:\", result)\n",
+    "\n",
+    "        # format system message, break it into multiple lines\n",
+    "        print(\"System Message:\")\n",
+    "        print(result['best_system_message'])\n",
+    "        print(\"Output:\")\n",
+    "        print(result['best_output'])\n",
+    "    except Exception as e:\n",
+    "        # print the error message, saying failed to converge\n",
+    "        print(\"Failed to converge.\")\n",
+    "        print(e)\n",
+    "\n",
+    "        print(\"System Message:\")\n",
+    "        print(result['best_system_message'])\n",
+    "        print(\"Output:\")\n",
+    "        print(result['best_output'])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "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.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -4,15 +4,21 @@ aiosignal==1.3.1
 altair==5.1.1
 annotated-types==0.5.0
 anyio==3.7.1
+asttokens==2.4.1
 async-timeout==4.0.3
 attrs==23.1.0
 certifi==2023.7.22
 charset-normalizer==3.2.0
 click==8.1.7
+comm==0.2.2
 contourpy==1.1.1
 cycler==0.11.0
 dataclasses-json==0.6.0
-exceptiongroup==1.1.3
+debugpy==1.8.2
+decorator==5.1.1
+distro==1.9.0
+exceptiongroup==1.2.1
+executing==2.0.1
 fastapi==0.103.1
 ffmpy==0.3.1
 filelock==3.12.4
@@ -28,36 +34,56 @@ httpx==0.25.0
 huggingface-hub==0.17.2
 idna==3.4
 importlib-resources==6.1.0
+ipykernel==6.29.4
+ipython==8.26.0
+jedi==0.19.1
 Jinja2==3.1.2
 joblib==1.3.2
 jsonpatch==1.33
 jsonpointer==2.4
 jsonschema==4.19.1
 jsonschema-specifications==2023.7.1
+jupyter_client==8.6.2
+jupyter_core==5.7.2
 kiwisolver==1.4.5
 langchain==0.0.300
-langsmith==0.0.40
+langchain-core==0.2.10
+langchain-openai==0.1.13
+langgraph==0.1.4
+langsmith==0.1.82
 MarkupSafe==2.1.3
 marshmallow==3.20.1
 matplotlib==3.8.0
+matplotlib-inline==0.1.7
 multidict==6.0.4
 mypy-extensions==1.0.0
+nest-asyncio==1.6.0
 numexpr==2.8.6
 numpy==1.26.0
-openai==0.28.0
-orjson==3.9.7
-packaging==23.1
+openai==1.35.7
+orjson==3.10.5
+packaging==24.1
 pandas==2.1.1
+parso==0.8.4
+pexpect==4.9.0
 Pillow==10.0.1
+platformdirs==4.2.2
+prompt_toolkit==3.0.47
+psutil==6.0.0
+ptyprocess==0.7.0
+pure-eval==0.2.2
 pydantic==2.3.0
 pydantic_core==2.6.3
 pydub==0.25.1
+Pygments==2.18.0
 pyparsing==3.1.1
-python-dateutil==2.8.2
+python-dateutil==2.9.0.post0
 python-multipart==0.0.6
 pytz==2023.3.post1
 PyYAML==6.0.1
+pyzmq==26.0.3
 referencing==0.30.2
+regex==2024.5.15
 requests==2.31.0
 rpds-py==0.10.3
 scikit-learn==1.3.1
@@ -66,15 +92,20 @@ semantic-version==2.10.0
 six==1.16.0
 sniffio==1.3.0
 SQLAlchemy==2.0.21
+stack-data==0.6.3
 starlette==0.27.0
 tenacity==8.2.3
 threadpoolctl==3.2.0
+tiktoken==0.7.0
 toolz==0.12.0
+tornado==6.4.1
 tqdm==4.66.1
+traitlets==5.14.3
 typing-inspect==0.9.0
-typing_extensions==4.8.0
+typing_extensions==4.12.2
 tzdata==2023.3
 urllib3==2.0.5
 uvicorn==0.23.2
+wcwidth==0.2.13
 websockets==11.0.3
 yarl==1.9.2