diff --git a/examples/tutorials/sql-agent.ipynb b/examples/tutorials/sql-agent.ipynb
index bad9313fc..1415a94ea 100644
--- a/examples/tutorials/sql-agent.ipynb
+++ b/examples/tutorials/sql-agent.ipynb
@@ -12,9 +12,10 @@
     "2. Decide which tables are relevant to the question\n",
     "3. Fetch the DDL for the relevant tables\n",
     "4. Generate a query based on the question and information from the DDL\n",
-    "5. Execute the query and return the results\n",
-    "6. Correct mistakes surfaced by the database engine until the query is successful\n",
-    "7. Formulate a response based on the results\n",
+    "5. Double-check the query for common mistakes using an LLM\n",
+    "6. Execute the query and return the results\n",
+    "7. Correct mistakes surfaced by the database engine until the query is successful\n",
+    "8. Formulate a response based on the results\n",
     "\n",
     "The end-to-end workflow will look something like below:"
    ],
@@ -37,16 +38,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 2,
    "outputs": [],
    "source": [
-    "import os\n"
+    "import os\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = \"sk-...\"\n",
+    "os.environ[\"LANGSMITH_API_KEY\"] = \"lsv2_pt_...\"\n",
+    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\""
    ],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T01:15:37.168492Z",
-     "start_time": "2024-06-12T01:15:37.166763Z"
+     "end_time": "2024-06-12T20:18:08.635369Z",
+     "start_time": "2024-06-12T20:18:08.630616Z"
     }
    },
    "id": "6c05a600f1afb5b6"
@@ -68,16 +73,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "File downloaded and saved as Chinook.db\n"
-     ]
-    }
-   ],
+   "execution_count": 3,
+   "outputs": [],
    "source": [
     "# import requests\n",
     "# \n",
@@ -97,8 +94,8 @@
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T01:15:38.718723Z",
-     "start_time": "2024-06-12T01:15:37.774941Z"
+     "end_time": "2024-06-12T20:18:10.130822Z",
+     "start_time": "2024-06-12T20:18:10.123796Z"
     }
    },
    "id": "64b0bf1b14c2e902"
@@ -115,7 +112,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 4,
    "outputs": [],
    "source": [
     "%%capture --no-stderr --no-display\n",
@@ -124,15 +121,15 @@
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T01:15:40.121309Z",
-     "start_time": "2024-06-12T01:15:39.132858Z"
+     "end_time": "2024-06-12T20:18:12.265718Z",
+     "start_time": "2024-06-12T20:18:11.265328Z"
     }
    },
    "id": "a60191bd3489f278"
   },
   {
    "cell_type": "code",
-   "execution_count": 84,
+   "execution_count": 5,
    "outputs": [
     {
      "name": "stdout",
@@ -146,7 +143,7 @@
      "data": {
       "text/plain": "\"[(1, 'AC/DC'), (2, 'Accept'), (3, 'Aerosmith'), (4, 'Alanis Morissette'), (5, 'Alice In Chains'), (6, 'Antônio Carlos Jobim'), (7, 'Apocalyptica'), (8, 'Audioslave'), (9, 'BackBeat'), (10, 'Billy Cobham')]\""
      },
-     "execution_count": 84,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -162,8 +159,8 @@
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T02:11:46.113986Z",
-     "start_time": "2024-06-12T02:11:46.086716Z"
+     "end_time": "2024-06-12T20:18:12.902435Z",
+     "start_time": "2024-06-12T20:18:12.796315Z"
     }
    },
    "id": "1f1e1f4f86ed54"
@@ -173,7 +170,7 @@
    "source": [
     "## Utility functions\n",
     "\n",
-    "We will define a few utility functions to help us with the agent implementation."
+    "We will define a few utility functions to help us with the agent implementation. Specifically, we will wrap a `ToolNode` with a fallback to handle errors and surface them to the agent."
    ],
    "metadata": {
     "collapsed": false
@@ -182,7 +179,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 6,
    "outputs": [],
    "source": [
     "from typing import Any, Dict, List\n",
@@ -216,8 +213,8 @@
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T01:15:40.827323Z",
-     "start_time": "2024-06-12T01:15:40.821476Z"
+     "end_time": "2024-06-12T20:18:14.197218Z",
+     "start_time": "2024-06-12T20:18:14.194149Z"
     }
    },
    "id": "deae8460e4cf72b1"
@@ -231,8 +228,7 @@
     "\n",
     "1. `list_tables_tool`: Fetch the available tables from the database\n",
     "2. `get_schema_tool`: Fetch the DDL for a table\n",
-    "3. `check_query_tool`: Double-check the query before executing it (using an LLM)\n",
-    "4. `db_query_tool`: Execute the query and fetch the results OR return an error message if the query fails\n",
+    "3. `db_query_tool`: Execute the query and fetch the results OR return an error message if the query fails\n",
     "\n",
     "For the first two tools, we will grab them from the `SQLDatabaseToolkit`, also available in the `langchain_community` package."
    ],
@@ -243,7 +239,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 7,
    "outputs": [
     {
      "name": "stdout",
@@ -277,15 +273,15 @@
     "list_tables_tool = next(tool for tool in tools if tool.name == \"sql_db_list_tables\")\n",
     "get_schema_tool = next(tool for tool in tools if tool.name == \"sql_db_schema\")\n",
     "\n",
-    "print(list_tables_tool(\"\"))\n",
+    "print(list_tables_tool.invoke(\"\"))\n",
     "\n",
-    "print(get_schema_tool(\"Artist\"))"
+    "print(get_schema_tool.invoke(\"Artist\"))"
    ],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T01:15:41.748028Z",
-     "start_time": "2024-06-12T01:15:41.722353Z"
+     "end_time": "2024-06-12T20:18:15.838940Z",
+     "start_time": "2024-06-12T20:18:15.734199Z"
     }
    },
    "id": "452d049a3d2a4406"
@@ -293,7 +289,7 @@
   {
    "cell_type": "markdown",
    "source": [
-    "The second two tools will be defined manually. For the `check_query_tool`, we will use an LLM to rewrite the query if there are mistakes. For the `db_query_tool`, we will execute the query against the database and return the results."
+    "The third will be defined manually. For the `db_query_tool`, we will execute the query against the database and return the results."
    ],
    "metadata": {
     "collapsed": false
@@ -302,49 +298,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 80,
+   "execution_count": 8,
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "There is a typo in the SQL keyword. The correct keyword is `SELECT` instead of `SELET`. Here is the corrected query:\n",
-      "\n",
-      "```sql\n",
-      "SELECT * FROM Artist LIMIT 10;\n",
-      "```\n",
       "[(1, 'AC/DC'), (2, 'Accept'), (3, 'Aerosmith'), (4, 'Alanis Morissette'), (5, 'Alice In Chains'), (6, 'Antônio Carlos Jobim'), (7, 'Apocalyptica'), (8, 'Audioslave'), (9, 'BackBeat'), (10, 'Billy Cobham')]\n"
      ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/ankushgola/Code/langgraph/.venv/lib/python3.11/site-packages/langchain_core/_api/deprecation.py:119: LangChainDeprecationWarning: The method `BaseTool.__call__` was deprecated in langchain-core 0.1.47 and will be removed in 0.3.0. Use invoke instead.\n",
+      "  warn_deprecated(\n"
+     ]
     }
    ],
    "source": [
     "from langchain.agents import tool\n",
     "\n",
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "\n",
-    "query_check_system = \"\"\"You are a SQL expert with a strong attention to detail.\n",
-    "Double check the SQLite query for common mistakes, including:\n",
-    "- Using NOT IN with NULL values\n",
-    "- Using UNION when UNION ALL should have been used\n",
-    "- Using BETWEEN for exclusive ranges\n",
-    "- Data type mismatch in predicates\n",
-    "- Properly quoting identifiers\n",
-    "- Using the correct number of arguments for functions\n",
-    "- Casting to the correct data type\n",
-    "- Using the proper columns for joins\n",
-    "\n",
-    "If there are any of the above mistakes, rewrite the query. If there are no mistakes, just reproduce the original query.\"\"\"\n",
-    "\n",
-    "query_check_prompt = ChatPromptTemplate.from_messages([(\"system\", query_check_system),(\"user\", \"{query}\")])\n",
-    "query_check = query_check_prompt | ChatOpenAI(model=\"gpt-4o\", temperature=0)\n",
-    "\n",
-    "@tool\n",
-    "def check_query_tool(query: str) -> str:\n",
-    "    \"\"\"\n",
-    "    Use this tool to double-check if your query is correct before executing it.\n",
-    "    \"\"\"\n",
-    "    return query_check.invoke({\"query\": query}).content\n",
-    "\n",
     "@tool\n",
     "def db_query_tool(query: str) -> str:\n",
     "    \"\"\"\n",
@@ -357,18 +331,72 @@
     "        return \"Error: Query failed. Please rewrite your query and try again.\"\n",
     "    return result\n",
     "\n",
-    "print(check_query_tool(\"SELET * FROM Artist LIMIT 10;\"))\n",
     "print(db_query_tool(\"SELECT * FROM Artist LIMIT 10;\"))"
    ],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T02:07:49.229576Z",
-     "start_time": "2024-06-12T02:07:47.640050Z"
+     "end_time": "2024-06-12T20:18:17.745278Z",
+     "start_time": "2024-06-12T20:18:17.338936Z"
     }
    },
    "id": "f7eb708ecb4c7cfc"
   },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "While not strictly a tool, we will prompt an LLM to check for common mistakes in the query and later add this as a node in the workflow."
+   ],
+   "metadata": {
+    "collapsed": false
+   },
+   "id": "f1d66db8b8621639"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_XnWquGNTWbJ2uhXO9hTLq2Zg', 'function': {'arguments': '{\\n  \"query\": \"SELECT * FROM Artist LIMIT 10;\"\\n}', 'name': 'db_query_tool'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 20, 'prompt_tokens': 222, 'total_tokens': 242}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'stop', 'logprobs': None}, id='run-aed5d66c-73fe-4fe1-bff5-c0b28e96f851-0', tool_calls=[{'name': 'db_query_tool', 'args': {'query': 'SELECT * FROM Artist LIMIT 10;'}, 'id': 'call_XnWquGNTWbJ2uhXO9hTLq2Zg'}], usage_metadata={'input_tokens': 222, 'output_tokens': 20, 'total_tokens': 242})"
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "\n",
+    "query_check_system = \"\"\"You are a SQL expert with a strong attention to detail.\n",
+    "Double check the SQLite query for common mistakes, including:\n",
+    "- Using NOT IN with NULL values\n",
+    "- Using UNION when UNION ALL should have been used\n",
+    "- Using BETWEEN for exclusive ranges\n",
+    "- Data type mismatch in predicates\n",
+    "- Properly quoting identifiers\n",
+    "- Using the correct number of arguments for functions\n",
+    "- Casting to the correct data type\n",
+    "- Using the proper columns for joins\n",
+    "\n",
+    "If there are any of the above mistakes, rewrite the query. If there are no mistakes, just reproduce the original query.\n",
+    "\n",
+    "You will call the appropriate tool to execute the query after running this check.\"\"\"\n",
+    "\n",
+    "query_check_prompt = ChatPromptTemplate.from_messages([(\"system\", query_check_system),(\"placeholder\", \"{messages}\")])\n",
+    "query_check = query_check_prompt | ChatOpenAI(model=\"gpt-4o\", temperature=0).bind_tools([db_query_tool], tool_choice=\"required\")\n",
+    "\n",
+    "query_check.invoke({\"messages\": [(\"user\", \"SELET * FROM Artist LIMIT 10;\")]})"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-06-12T20:18:19.658322Z",
+     "start_time": "2024-06-12T20:18:18.756256Z"
+    }
+   },
+   "id": "293017e8f05ac2b3"
+  },
   {
    "cell_type": "markdown",
    "source": [
@@ -383,10 +411,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 81,
+   "execution_count": 16,
    "outputs": [],
    "source": [
-    "from typing import Annotated\n",
+    "from typing import Annotated, Literal\n",
     "from typing_extensions import TypedDict\n",
     "\n",
     "from langchain_openai import ChatOpenAI\n",
@@ -395,8 +423,7 @@
     "from langgraph.graph.message import AnyMessage, add_messages\n",
     "from langgraph.prebuilt.tool_node import ToolNode\n",
     "from langchain_core.messages import AIMessage\n",
-    "\n",
-    "from typing import Literal\n",
+    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
     "\n",
     "# Define the state for the agent\n",
     "class State(TypedDict):\n",
@@ -423,6 +450,16 @@
     "        ]\n",
     "    }\n",
     "\n",
+    "def model_check_query(state: State) -> dict[str, list[AIMessage]]:\n",
+    "    \"\"\"\n",
+    "    Use this tool to double-check if your query is correct before executing it.\n",
+    "    \"\"\"\n",
+    "    return {\n",
+    "        \"messages\": [\n",
+    "            query_check.invoke({\"messages\": [state[\"messages\"][-1]]})\n",
+    "        ]\n",
+    "    }\n",
+    "\n",
     "workflow.add_node(\"first_tool_call\", first_tool_call)\n",
     "\n",
     "# Add nodes for the first two tools\n",
@@ -433,10 +470,22 @@
     "model_get_schema = ChatOpenAI(model=\"gpt-4o\", temperature=0).bind_tools([get_schema_tool])\n",
     "workflow.add_node(\"model_get_schema\", lambda state: {\"messages\": [model_get_schema.invoke(state[\"messages\"])],})\n",
     "\n",
+    "# Describe a tool to represent the end state\n",
+    "class SubmitFinalAnswer(BaseModel):\n",
+    "    \"\"\"Submit the final answer to the user based on the query results.\"\"\"\n",
+    "    final_answer: str = Field(..., description=\"The final answer to the user\")\n",
+    "\n",
     "# Add a node for a model to generate a query based on the question and schema\n",
     "query_gen_system = \"\"\"You are a SQL expert with a strong attention to detail.\n",
     "\n",
-    "Given an input question, create a syntactically correct SQLite query to run, then look at the results of the query and return the answer.\n",
+    "Given an input question, output a syntactically correct SQLite query to run, then look at the results of the query and return the answer.\n",
+    "\n",
+    "DO NOT call any tool besides SubmitFinalAnswer to submit the final answer.\n",
+    "\n",
+    "When generating the query:\n",
+    "\n",
+    "Output the SQL query that answers the input question without a tool call.\n",
+    "\n",
     "Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most 5 results.\n",
     "You can order the results by a relevant column to return the most interesting examples in the database.\n",
     "Never query for all the columns from a specific table, only ask for the relevant columns given the question.\n",
@@ -444,28 +493,50 @@
     "If you get an error while executing a query, rewrite the query and try again.\n",
     "\n",
     "If you get an empty result set, you should try to rewrite the query to get a non-empty result set. \n",
-    "NEVER make stuff up if you don't have enough information to answer the query.\n",
-    "If you are unsure about your query, you should check it with the appropriate tool.\n",
+    "NEVER make stuff up if you don't have enough information to answer the query... just say you don't have enough information.\n",
     "\n",
-    "If you have enough information to answer the input question, simply reply with the final answer.\n",
+    "If you have enough information to answer the input question, simply invoke the appropriate tool to submit the final answer to the user.\n",
     "\n",
     "DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.\"\"\"\n",
     "query_gen_prompt = ChatPromptTemplate.from_messages([(\"system\", query_gen_system),(\"placeholder\", \"{messages}\")])\n",
-    "query_gen = query_gen_prompt | ChatOpenAI(model=\"gpt-4o\", temperature=0).bind_tools([db_query_tool, check_query_tool])\n",
-    "workflow.add_node(\"query_gen\", lambda state: {\"messages\": [query_gen.invoke(state)],})\n",
+    "query_gen = query_gen_prompt | ChatOpenAI(model=\"gpt-4o\", temperature=0).bind_tools([SubmitFinalAnswer])\n",
+    "def query_gen_node(state: State):\n",
+    "    message = query_gen.invoke(state)\n",
+    "    \n",
+    "    # Sometimes, the LLM will hallucinate and call the wrong tool. We need to catch this and return an error message.\n",
+    "    tool_messages = []\n",
+    "    if message.tool_calls:\n",
+    "        for tc in message.tool_calls:\n",
+    "            if tc[\"name\"] != \"SubmitFinalAnswer\":\n",
+    "                tool_messages.append(\n",
+    "                    ToolMessage(\n",
+    "                        content=f\"Error: The wrong tool was called: {tc['name']}. Please fix your mistakes. Remember to only call SubmitFinalAnswer to submit the final answer. Generated queries should be outputted WITHOUT a tool call.\",\n",
+    "                        tool_call_id=tc[\"id\"],\n",
+    "                    )\n",
+    "                )\n",
+    "    else:\n",
+    "        tool_messages = []\n",
+    "    return {\"messages\": [message] + tool_messages}\n",
     "\n",
-    "# Add nodes for the last two tools, check_query_tool and db_query_tool\n",
-    "workflow.add_node(\"sql_actions\", create_tool_node_with_fallback([check_query_tool, db_query_tool]))\n",
+    "workflow.add_node(\"query_gen\", query_gen_node)\n",
+    "\n",
+    "# Add a node for the model to check the query before executing it\n",
+    "workflow.add_node(\"correct_query\", model_check_query)\n",
+    "\n",
+    "# Add node for executing the query\n",
+    "workflow.add_node(\"execute_query\", create_tool_node_with_fallback([db_query_tool]))\n",
     "\n",
     "# Define a conditional edge to decide whether to continue or end the workflow\n",
-    "def should_continue(state: State) -> Literal[END, \"sql_actions\"]:\n",
+    "def should_continue(state: State) -> Literal[END, \"correct_query\", \"query_gen\"]:\n",
     "    messages = state[\"messages\"]\n",
     "    last_message = messages[-1]\n",
-    "    # If there is no tool call, then we finish\n",
-    "    if not last_message.tool_calls:\n",
+    "    # If there is a tool call, then we finish\n",
+    "    if getattr(last_message, \"tool_calls\", None):\n",
     "        return END\n",
+    "    if last_message.content.startswith(\"Error:\"):\n",
+    "        return \"query_gen\"\n",
     "    else:\n",
-    "        return \"sql_actions\"\n",
+    "        return \"correct_query\"\n",
     "\n",
     "# Specify the edges between the nodes\n",
     "workflow.set_entry_point(\"first_tool_call\")\n",
@@ -477,7 +548,8 @@
     "    \"query_gen\",\n",
     "    should_continue,\n",
     ")\n",
-    "workflow.add_edge(\"sql_actions\", \"query_gen\")\n",
+    "workflow.add_edge(\"correct_query\", \"execute_query\")\n",
+    "workflow.add_edge(\"execute_query\", \"query_gen\")\n",
     "\n",
     "# Compile the workflow into a runnable\n",
     "app = workflow.compile()"
@@ -485,8 +557,8 @@
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T02:07:50.811535Z",
-     "start_time": "2024-06-12T02:07:50.788513Z"
+     "end_time": "2024-06-12T20:21:09.799829Z",
+     "start_time": "2024-06-12T20:21:09.765928Z"
     }
    },
    "id": "90d04ceea7b6b010"
@@ -503,11 +575,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 82,
+   "execution_count": 17,
    "outputs": [
     {
      "data": {
-      "image/jpeg": "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",
+      "image/jpeg": "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",
       "text/plain": "<IPython.core.display.Image object>"
      },
      "metadata": {},
@@ -529,15 +601,15 @@
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T02:07:52.249655Z",
-     "start_time": "2024-06-12T02:07:51.943751Z"
+     "end_time": "2024-06-12T20:21:11.813905Z",
+     "start_time": "2024-06-12T20:21:11.712945Z"
     }
    },
    "id": "4f200d1813897000"
   },
   {
    "cell_type": "code",
-   "execution_count": 88,
+   "execution_count": 18,
    "outputs": [
     {
      "name": "stdout",
@@ -545,15 +617,13 @@
      "text": [
       "{'first_tool_call': {'messages': [AIMessage(content='', tool_calls=[{'name': 'sql_db_list_tables', 'args': {}, 'id': 'tool_abcd123'}])]}}\n",
       "{'list_tables_tool': {'messages': [ToolMessage(content='Album, Artist, Customer, Employee, Genre, Invoice, InvoiceLine, MediaType, Playlist, PlaylistTrack, Track', name='sql_db_list_tables', tool_call_id='tool_abcd123')]}}\n",
-      "{'model_get_schema': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_18NT4ma6CkCYn1r4evZ2qgAx', 'function': {'arguments': '{\"table_names\":\"Employee, Invoice\"}', 'name': 'sql_db_schema'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 18, 'prompt_tokens': 177, 'total_tokens': 195}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-7f3fc204-b27b-4a40-8921-faaa2d4e45b6-0', tool_calls=[{'name': 'sql_db_schema', 'args': {'table_names': 'Employee, Invoice'}, 'id': 'call_18NT4ma6CkCYn1r4evZ2qgAx'}], usage_metadata={'input_tokens': 177, 'output_tokens': 18, 'total_tokens': 195})]}}\n",
-      "{'get_schema_tool': {'messages': [ToolMessage(content='\\nCREATE TABLE \"Employee\" (\\n\\t\"EmployeeId\" INTEGER NOT NULL, \\n\\t\"LastName\" NVARCHAR(20) NOT NULL, \\n\\t\"FirstName\" NVARCHAR(20) NOT NULL, \\n\\t\"Title\" NVARCHAR(30), \\n\\t\"ReportsTo\" INTEGER, \\n\\t\"BirthDate\" DATETIME, \\n\\t\"HireDate\" DATETIME, \\n\\t\"Address\" NVARCHAR(70), \\n\\t\"City\" NVARCHAR(40), \\n\\t\"State\" NVARCHAR(40), \\n\\t\"Country\" NVARCHAR(40), \\n\\t\"PostalCode\" NVARCHAR(10), \\n\\t\"Phone\" NVARCHAR(24), \\n\\t\"Fax\" NVARCHAR(24), \\n\\t\"Email\" NVARCHAR(60), \\n\\tPRIMARY KEY (\"EmployeeId\"), \\n\\tFOREIGN KEY(\"ReportsTo\") REFERENCES \"Employee\" (\"EmployeeId\")\\n)\\n\\n/*\\n3 rows from Employee table:\\nEmployeeId\\tLastName\\tFirstName\\tTitle\\tReportsTo\\tBirthDate\\tHireDate\\tAddress\\tCity\\tState\\tCountry\\tPostalCode\\tPhone\\tFax\\tEmail\\n1\\tAdams\\tAndrew\\tGeneral Manager\\tNone\\t1962-02-18 00:00:00\\t2002-08-14 00:00:00\\t11120 Jasper Ave NW\\tEdmonton\\tAB\\tCanada\\tT5K 2N1\\t+1 (780) 428-9482\\t+1 (780) 428-3457\\tandrew@chinookcorp.com\\n2\\tEdwards\\tNancy\\tSales Manager\\t1\\t1958-12-08 00:00:00\\t2002-05-01 00:00:00\\t825 8 Ave SW\\tCalgary\\tAB\\tCanada\\tT2P 2T3\\t+1 (403) 262-3443\\t+1 (403) 262-3322\\tnancy@chinookcorp.com\\n3\\tPeacock\\tJane\\tSales Support Agent\\t2\\t1973-08-29 00:00:00\\t2002-04-01 00:00:00\\t1111 6 Ave SW\\tCalgary\\tAB\\tCanada\\tT2P 5M5\\t+1 (403) 262-3443\\t+1 (403) 262-6712\\tjane@chinookcorp.com\\n*/\\n\\n\\nCREATE TABLE \"Invoice\" (\\n\\t\"InvoiceId\" INTEGER NOT NULL, \\n\\t\"CustomerId\" INTEGER NOT NULL, \\n\\t\"InvoiceDate\" DATETIME NOT NULL, \\n\\t\"BillingAddress\" NVARCHAR(70), \\n\\t\"BillingCity\" NVARCHAR(40), \\n\\t\"BillingState\" NVARCHAR(40), \\n\\t\"BillingCountry\" NVARCHAR(40), \\n\\t\"BillingPostalCode\" NVARCHAR(10), \\n\\t\"Total\" NUMERIC(10, 2) NOT NULL, \\n\\tPRIMARY KEY (\"InvoiceId\"), \\n\\tFOREIGN KEY(\"CustomerId\") REFERENCES \"Customer\" (\"CustomerId\")\\n)\\n\\n/*\\n3 rows from Invoice table:\\nInvoiceId\\tCustomerId\\tInvoiceDate\\tBillingAddress\\tBillingCity\\tBillingState\\tBillingCountry\\tBillingPostalCode\\tTotal\\n1\\t2\\t2021-01-01 00:00:00\\tTheodor-Heuss-Straße 34\\tStuttgart\\tNone\\tGermany\\t70174\\t1.98\\n2\\t4\\t2021-01-02 00:00:00\\tUllevålsveien 14\\tOslo\\tNone\\tNorway\\t0171\\t3.96\\n3\\t8\\t2021-01-03 00:00:00\\tGrétrystraat 63\\tBrussels\\tNone\\tBelgium\\t1000\\t5.94\\n*/', name='sql_db_schema', tool_call_id='call_18NT4ma6CkCYn1r4evZ2qgAx')]}}\n",
-      "{'query_gen': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_9XavnPA7E11gx3QcWFe2qx32', 'function': {'arguments': '{\"table_names\":\"Customer\"}', 'name': 'sql_db_schema'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 16, 'prompt_tokens': 1200, 'total_tokens': 1216}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-00ee8782-f824-4656-b1d6-0e93183f2db7-0', tool_calls=[{'name': 'sql_db_schema', 'args': {'table_names': 'Customer'}, 'id': 'call_9XavnPA7E11gx3QcWFe2qx32'}], usage_metadata={'input_tokens': 1200, 'output_tokens': 16, 'total_tokens': 1216})]}}\n",
-      "{'sql_actions': {'messages': [ToolMessage(content=\"Error: KeyError('sql_db_schema')\\n please fix your mistakes.\", tool_call_id='call_9XavnPA7E11gx3QcWFe2qx32')]}}\n",
-      "{'query_gen': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_C4ROOfoerwPv2b8lq9LqQnD2', 'function': {'arguments': '{\"query\":\"SELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales FROM Employee e JOIN Customer c ON e.EmployeeId = c.SupportRepId JOIN Invoice i ON c.CustomerId = i.CustomerId WHERE strftime(\\'%Y\\', i.InvoiceDate) = \\'2009\\' GROUP BY e.EmployeeId ORDER BY TotalSales DESC LIMIT 5;\"}', 'name': 'check_query_tool'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 85, 'prompt_tokens': 1239, 'total_tokens': 1324}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-37006782-d3f3-4a77-873a-19bcd9d39cfd-0', tool_calls=[{'name': 'check_query_tool', 'args': {'query': \"SELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales FROM Employee e JOIN Customer c ON e.EmployeeId = c.SupportRepId JOIN Invoice i ON c.CustomerId = i.CustomerId WHERE strftime('%Y', i.InvoiceDate) = '2009' GROUP BY e.EmployeeId ORDER BY TotalSales DESC LIMIT 5;\"}, 'id': 'call_C4ROOfoerwPv2b8lq9LqQnD2'}], usage_metadata={'input_tokens': 1239, 'output_tokens': 85, 'total_tokens': 1324})]}}\n",
-      "{'sql_actions': {'messages': [ToolMessage(content=\"The provided query looks mostly correct, but let's double-check for common mistakes:\\n\\n1. **Using NOT IN with NULL values**: This query does not use `NOT IN`.\\n2. **Using UNION when UNION ALL should have been used**: This query does not use `UNION`.\\n3. **Using BETWEEN for exclusive ranges**: This query does not use `BETWEEN`.\\n4. **Data type mismatch in predicates**: The `strftime` function returns a string, and the comparison to `'2009'` is correct.\\n5. **Properly quoting identifiers**: Identifiers are not quoted, but they do not contain any special characters or reserved words, so this is acceptable.\\n6. **Using the correct number of arguments for functions**: The `strftime` function is used correctly with the right number of arguments.\\n7. **Casting to the correct data type**: No explicit casting is required here.\\n8. **Using the proper columns for joins**: The joins are correctly using `EmployeeId`, `SupportRepId`, and `CustomerId`.\\n\\nSince there are no mistakes, the original query is correct. Here it is again:\\n\\n```sql\\nSELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales \\nFROM Employee e \\nJOIN Customer c ON e.EmployeeId = c.SupportRepId \\nJOIN Invoice i ON c.CustomerId = i.CustomerId \\nWHERE strftime('%Y', i.InvoiceDate) = '2009' \\nGROUP BY e.EmployeeId \\nORDER BY TotalSales DESC \\nLIMIT 5;\\n```\", name='check_query_tool', tool_call_id='call_C4ROOfoerwPv2b8lq9LqQnD2')]}}\n",
-      "{'query_gen': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_I2wGxopD5yAx5I0ghlx7dM4k', 'function': {'arguments': '{\"query\":\"SELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales FROM Employee e JOIN Customer c ON e.EmployeeId = c.SupportRepId JOIN Invoice i ON c.CustomerId = i.CustomerId WHERE strftime(\\'%Y\\', i.InvoiceDate) = \\'2009\\' GROUP BY e.EmployeeId ORDER BY TotalSales DESC LIMIT 5;\"}', 'name': 'db_query_tool'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 85, 'prompt_tokens': 1648, 'total_tokens': 1733}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-9751c70f-a1e6-454e-86db-f59bb856c0ce-0', tool_calls=[{'name': 'db_query_tool', 'args': {'query': \"SELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales FROM Employee e JOIN Customer c ON e.EmployeeId = c.SupportRepId JOIN Invoice i ON c.CustomerId = i.CustomerId WHERE strftime('%Y', i.InvoiceDate) = '2009' GROUP BY e.EmployeeId ORDER BY TotalSales DESC LIMIT 5;\"}, 'id': 'call_I2wGxopD5yAx5I0ghlx7dM4k'}], usage_metadata={'input_tokens': 1648, 'output_tokens': 85, 'total_tokens': 1733})]}}\n",
-      "{'sql_actions': {'messages': [ToolMessage(content=\"[('Steve', 'Johnson', 164.34), ('Margaret', 'Park', 161.37), ('Jane', 'Peacock', 123.75)]\", name='db_query_tool', tool_call_id='call_I2wGxopD5yAx5I0ghlx7dM4k')]}}\n",
-      "{'query_gen': {'messages': [AIMessage(content='The sales agent who made the most in sales in 2009 is Steve Johnson, with total sales of 164.34.', response_metadata={'token_usage': {'completion_tokens': 27, 'prompt_tokens': 1778, 'total_tokens': 1805}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'stop', 'logprobs': None}, id='run-07c3b283-e542-45df-ac4e-3165de5eda11-0', usage_metadata={'input_tokens': 1778, 'output_tokens': 27, 'total_tokens': 1805})]}}\n"
+      "{'model_get_schema': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_zwAtGmtcszZIu0pMOWjd6kaN', 'function': {'arguments': '{\"table_names\":\"Employee, Invoice\"}', 'name': 'sql_db_schema'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 18, 'prompt_tokens': 177, 'total_tokens': 195}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-488a21dc-549b-4cde-b5e6-f261bfd18e61-0', tool_calls=[{'name': 'sql_db_schema', 'args': {'table_names': 'Employee, Invoice'}, 'id': 'call_zwAtGmtcszZIu0pMOWjd6kaN'}], usage_metadata={'input_tokens': 177, 'output_tokens': 18, 'total_tokens': 195})]}}\n",
+      "{'get_schema_tool': {'messages': [ToolMessage(content='\\nCREATE TABLE \"Employee\" (\\n\\t\"EmployeeId\" INTEGER NOT NULL, \\n\\t\"LastName\" NVARCHAR(20) NOT NULL, \\n\\t\"FirstName\" NVARCHAR(20) NOT NULL, \\n\\t\"Title\" NVARCHAR(30), \\n\\t\"ReportsTo\" INTEGER, \\n\\t\"BirthDate\" DATETIME, \\n\\t\"HireDate\" DATETIME, \\n\\t\"Address\" NVARCHAR(70), \\n\\t\"City\" NVARCHAR(40), \\n\\t\"State\" NVARCHAR(40), \\n\\t\"Country\" NVARCHAR(40), \\n\\t\"PostalCode\" NVARCHAR(10), \\n\\t\"Phone\" NVARCHAR(24), \\n\\t\"Fax\" NVARCHAR(24), \\n\\t\"Email\" NVARCHAR(60), \\n\\tPRIMARY KEY (\"EmployeeId\"), \\n\\tFOREIGN KEY(\"ReportsTo\") REFERENCES \"Employee\" (\"EmployeeId\")\\n)\\n\\n/*\\n3 rows from Employee table:\\nEmployeeId\\tLastName\\tFirstName\\tTitle\\tReportsTo\\tBirthDate\\tHireDate\\tAddress\\tCity\\tState\\tCountry\\tPostalCode\\tPhone\\tFax\\tEmail\\n1\\tAdams\\tAndrew\\tGeneral Manager\\tNone\\t1962-02-18 00:00:00\\t2002-08-14 00:00:00\\t11120 Jasper Ave NW\\tEdmonton\\tAB\\tCanada\\tT5K 2N1\\t+1 (780) 428-9482\\t+1 (780) 428-3457\\tandrew@chinookcorp.com\\n2\\tEdwards\\tNancy\\tSales Manager\\t1\\t1958-12-08 00:00:00\\t2002-05-01 00:00:00\\t825 8 Ave SW\\tCalgary\\tAB\\tCanada\\tT2P 2T3\\t+1 (403) 262-3443\\t+1 (403) 262-3322\\tnancy@chinookcorp.com\\n3\\tPeacock\\tJane\\tSales Support Agent\\t2\\t1973-08-29 00:00:00\\t2002-04-01 00:00:00\\t1111 6 Ave SW\\tCalgary\\tAB\\tCanada\\tT2P 5M5\\t+1 (403) 262-3443\\t+1 (403) 262-6712\\tjane@chinookcorp.com\\n*/\\n\\n\\nCREATE TABLE \"Invoice\" (\\n\\t\"InvoiceId\" INTEGER NOT NULL, \\n\\t\"CustomerId\" INTEGER NOT NULL, \\n\\t\"InvoiceDate\" DATETIME NOT NULL, \\n\\t\"BillingAddress\" NVARCHAR(70), \\n\\t\"BillingCity\" NVARCHAR(40), \\n\\t\"BillingState\" NVARCHAR(40), \\n\\t\"BillingCountry\" NVARCHAR(40), \\n\\t\"BillingPostalCode\" NVARCHAR(10), \\n\\t\"Total\" NUMERIC(10, 2) NOT NULL, \\n\\tPRIMARY KEY (\"InvoiceId\"), \\n\\tFOREIGN KEY(\"CustomerId\") REFERENCES \"Customer\" (\"CustomerId\")\\n)\\n\\n/*\\n3 rows from Invoice table:\\nInvoiceId\\tCustomerId\\tInvoiceDate\\tBillingAddress\\tBillingCity\\tBillingState\\tBillingCountry\\tBillingPostalCode\\tTotal\\n1\\t2\\t2009-01-01 00:00:00\\tTheodor-Heuss-Straße 34\\tStuttgart\\tNone\\tGermany\\t70174\\t1.98\\n2\\t4\\t2009-01-02 00:00:00\\tUllevålsveien 14\\tOslo\\tNone\\tNorway\\t0171\\t3.96\\n3\\t8\\t2009-01-03 00:00:00\\tGrétrystraat 63\\tBrussels\\tNone\\tBelgium\\t1000\\t5.94\\n*/', name='sql_db_schema', tool_call_id='call_zwAtGmtcszZIu0pMOWjd6kaN')]}}\n",
+      "{'query_gen': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_0bJnebJLYtMDXdT8o5YDOR5b', 'function': {'arguments': '{\"query\":\"SELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales\\\\nFROM Employee e\\\\nJOIN Customer c ON e.EmployeeId = c.SupportRepId\\\\nJOIN Invoice i ON c.CustomerId = i.CustomerId\\\\nWHERE strftime(\\'%Y\\', i.InvoiceDate) = \\'2009\\'\\\\nGROUP BY e.EmployeeId\\\\nORDER BY TotalSales DESC\\\\nLIMIT 1;\"}', 'name': 'sql_db_query'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 92, 'prompt_tokens': 1179, 'total_tokens': 1271}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-ac7ef301-ff96-4368-aa32-0ce02bf15a31-0', tool_calls=[{'name': 'sql_db_query', 'args': {'query': \"SELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales\\nFROM Employee e\\nJOIN Customer c ON e.EmployeeId = c.SupportRepId\\nJOIN Invoice i ON c.CustomerId = i.CustomerId\\nWHERE strftime('%Y', i.InvoiceDate) = '2009'\\nGROUP BY e.EmployeeId\\nORDER BY TotalSales DESC\\nLIMIT 1;\"}, 'id': 'call_0bJnebJLYtMDXdT8o5YDOR5b'}], usage_metadata={'input_tokens': 1179, 'output_tokens': 92, 'total_tokens': 1271}), ToolMessage(content='Error: The wrong tool was called: sql_db_query. Please fix your mistakes. Remember to only call SubmitFinalAnswer to submit the final answer. Generated queries should be outputted WITHOUT a tool call.', id='082c6fcb-51da-4ecd-9b30-d4b605ee22a0', tool_call_id='call_0bJnebJLYtMDXdT8o5YDOR5b')]}}\n",
+      "{'query_gen': {'messages': [AIMessage(content=\"```sql\\nSELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales\\nFROM Employee e\\nJOIN Customer c ON e.EmployeeId = c.SupportRepId\\nJOIN Invoice i ON c.CustomerId = i.CustomerId\\nWHERE strftime('%Y', i.InvoiceDate) = '2009'\\nGROUP BY e.EmployeeId\\nORDER BY TotalSales DESC\\nLIMIT 1;\\n```\", response_metadata={'token_usage': {'completion_tokens': 82, 'prompt_tokens': 1321, 'total_tokens': 1403}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'stop', 'logprobs': None}, id='run-68e4bcf7-ab0d-4f49-a9da-4f721cabe3a0-0', usage_metadata={'input_tokens': 1321, 'output_tokens': 82, 'total_tokens': 1403})]}}\n",
+      "{'correct_query': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_gNi6QLLVsHY0wOy4QrSWIiD4', 'function': {'arguments': '{\"query\":\"SELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales\\\\nFROM Employee e\\\\nJOIN Customer c ON e.EmployeeId = c.SupportRepId\\\\nJOIN Invoice i ON c.CustomerId = i.CustomerId\\\\nWHERE strftime(\\'%Y\\', i.InvoiceDate) = \\'2009\\'\\\\nGROUP BY e.EmployeeId\\\\nORDER BY TotalSales DESC\\\\nLIMIT 1;\"}', 'name': 'db_query_tool'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 90, 'prompt_tokens': 294, 'total_tokens': 384}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'stop', 'logprobs': None}, id='run-13bafb17-66c9-4792-a76d-d16d1bb76d70-0', tool_calls=[{'name': 'db_query_tool', 'args': {'query': \"SELECT e.FirstName, e.LastName, SUM(i.Total) as TotalSales\\nFROM Employee e\\nJOIN Customer c ON e.EmployeeId = c.SupportRepId\\nJOIN Invoice i ON c.CustomerId = i.CustomerId\\nWHERE strftime('%Y', i.InvoiceDate) = '2009'\\nGROUP BY e.EmployeeId\\nORDER BY TotalSales DESC\\nLIMIT 1;\"}, 'id': 'call_gNi6QLLVsHY0wOy4QrSWIiD4'}], usage_metadata={'input_tokens': 294, 'output_tokens': 90, 'total_tokens': 384})]}}\n",
+      "{'execute_query': {'messages': [ToolMessage(content=\"[('Steve', 'Johnson', 164.34)]\", name='db_query_tool', tool_call_id='call_gNi6QLLVsHY0wOy4QrSWIiD4')]}}\n",
+      "{'query_gen': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_BPH1QSgVK9xdF2atxi6Fx3HM', 'function': {'arguments': '{\"final_answer\":\"The sales agent who made the most in sales in 2009 is Steve Johnson with total sales of 164.34.\"}', 'name': 'SubmitFinalAnswer'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 41, 'prompt_tokens': 1519, 'total_tokens': 1560}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_319be4768e', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-d3ed4aa6-3d79-4d7d-b69d-d97b64c41425-0', tool_calls=[{'name': 'SubmitFinalAnswer', 'args': {'final_answer': 'The sales agent who made the most in sales in 2009 is Steve Johnson with total sales of 164.34.'}, 'id': 'call_BPH1QSgVK9xdF2atxi6Fx3HM'}], usage_metadata={'input_tokens': 1519, 'output_tokens': 41, 'total_tokens': 1560})]}}\n"
      ]
     }
    ],
@@ -564,165 +634,11 @@
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-06-12T06:38:49.854963Z",
-     "start_time": "2024-06-12T06:38:33.871784Z"
+     "end_time": "2024-06-12T20:21:21.878352Z",
+     "start_time": "2024-06-12T20:21:12.854570Z"
     }
    },
    "id": "956883cced0b8ec"
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 98,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "\"[(1, 'AC/DC'), (2, 'Accept'), (3, 'Aerosmith'), (4, 'Alanis Morissette'), (5, 'Alice In Chains'), (6, 'Antônio Carlos Jobim'), (7, 'Apocalyptica'), (8, 'Audioslave'), (9, 'BackBeat'), (10, 'Billy Cobham')]\""
-     },
-     "execution_count": 98,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "db_query_tool.invoke(\"SELECT * FROM Artist LIMIT 10;\")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-06-12T08:11:44.819375Z",
-     "start_time": "2024-06-12T08:11:44.793151Z"
-    }
-   },
-   "id": "b84949c0175f16d6"
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 108,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2024-06-11 07:37:48.308394+00:00\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "datetime.timezone.utc"
-     },
-     "execution_count": 108,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from datetime import datetime, timezone\n",
-    "\n",
-    "# The given timestamp\n",
-    "timestamp = \"2024-06-11T09:50:30.784939\"\n",
-    "\n",
-    "ts2 = \"2024-06-11T07:37:48.308394+00:00\"\n",
-    "\n",
-    "# Parse the timestamp into a datetime object\n",
-    "dt = datetime.fromisoformat(ts2)\n",
-    "\n",
-    "# Print the resulting datetime object\n",
-    "print(dt)\n",
-    "\n",
-    "dt.tzinfo"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-06-12T08:15:28.909119Z",
-     "start_time": "2024-06-12T08:15:28.906615Z"
-    }
-   },
-   "id": "27b61588dc53ffac"
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 109,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "UTC\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(dt.tzinfo)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-06-12T08:15:32.713935Z",
-     "start_time": "2024-06-12T08:15:32.707748Z"
-    }
-   },
-   "id": "9cdca076562049fc"
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 106,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "datetime.datetime(2024, 6, 11, 9, 50, 30, 784939, tzinfo=datetime.timezone.utc)"
-     },
-     "execution_count": 106,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dt.replace(tzinfo=timezone.utc)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-06-12T08:12:54.353980Z",
-     "start_time": "2024-06-12T08:12:54.334779Z"
-    }
-   },
-   "id": "9a9b294ee0979711"
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 110,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "datetime.datetime(2024, 6, 11, 7, 37, 48, 308394, tzinfo=datetime.timezone.utc)"
-     },
-     "execution_count": 110,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dt"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-06-12T08:15:44.135482Z",
-     "start_time": "2024-06-12T08:15:44.115164Z"
-    }
-   },
-   "id": "33a82da51488b69"
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [],
-   "metadata": {
-    "collapsed": false
-   },
-   "id": "7d8d8fa3df52e11d"
   }
  ],
  "metadata": {