From f96ff9386b6e69fe3aed18a71d368bc73c9fa952 Mon Sep 17 00:00:00 2001 From: Ankush Gola Date: Wed, 12 Jun 2024 13:25:07 -0700 Subject: [PATCH] update agent --- examples/tutorials/sql-agent.ipynb | 438 ++++++++++++----------------- 1 file changed, 177 insertions(+), 261 deletions(-) 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": "" }, "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": {