{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import sqlite3" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "connection = sqlite3.connect(\"employee.db\")" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "connection" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "table_creation_query=\"\"\"\n", "CREATE TABLE IF NOT EXISTS employees (\n", " emp_id INTEGER PRIMARY KEY,\n", " first_name TEXT NOT NULL,\n", " last_name TEXT NOT NULL,\n", " email TEXT UNIQUE NOT NULL,\n", " hire_date TEXT NOT NULL,\n", " salary REAL NOT NULL\n", ");\n", "\"\"\"" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "table_creation_query2=\"\"\"\n", "CREATE TABLE IF NOT EXISTS customers (\n", " customer_id INTEGER PRIMARY KEY AUTOINCREMENT,\n", " first_name TEXT NOT NULL,\n", " last_name TEXT NOT NULL,\n", " email TEXT UNIQUE NOT NULL,\n", " phone TEXT\n", ");\n", "\"\"\"" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "table_creation_query3=\"\"\"\n", "CREATE TABLE IF NOT EXISTS orders (\n", " order_id INTEGER PRIMARY KEY AUTOINCREMENT,\n", " customer_id INTEGER NOT NULL,\n", " order_date TEXT NOT NULL,\n", " amount REAL NOT NULL,\n", " FOREIGN KEY (customer_id) REFERENCES customers (customer_id)\n", ");\n", "\n", "\"\"\"" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "cursor=connection.cursor()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.execute(table_creation_query)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.execute(table_creation_query2)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.execute(table_creation_query3)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "insert_query = \"\"\"\n", "INSERT INTO employees (emp_id, first_name, last_name, email, hire_date, salary)\n", "VALUES (?, ?, ?, ?, ?, ?);\n", "\"\"\"" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "insert_query_customers = \"\"\"\n", "INSERT INTO customers (customer_id, first_name, last_name, email, phone)\n", "VALUES (?, ?, ?, ?, ?);\n", "\"\"\"" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "insert_query_orders = \"\"\"\n", "INSERT INTO orders (order_id, customer_id, order_date, amount)\n", "VALUES (?, ?, ?, ?);\n", "\"\"\"" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "employee_data = [\n", " (1, \"Sunny\", \"Savita\", \"sunny.sv@abc.com\", \"2023-06-01\", 50000.00),\n", " (2, \"Arhun\", \"Meheta\", \"arhun.m@gmail.com\", \"2022-04-15\", 60000.00),\n", " (3, \"Alice\", \"Johnson\", \"alice.johnson@jpg.com\", \"2021-09-30\", 55000.00),\n", " (4, \"Bob\", \"Brown\", \"bob.brown@uio.com\", \"2020-01-20\", 45000.00),\n", " ]" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "customers_data = [\n", " (1, \"John\", \"Doe\", \"john.doe@example.com\", \"1234567890\"),\n", " (2, \"Jane\", \"Smith\", \"jane.smith@example.com\", \"9876543210\"),\n", " (3, \"Emily\", \"Davis\", \"emily.davis@example.com\", \"4567891230\"),\n", " (4, \"Michael\", \"Brown\", \"michael.brown@example.com\", \"7894561230\"),\n", "]" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "orders_data = [\n", " (1, 1, \"2023-12-01\", 250.75),\n", " (2, 2, \"2023-11-20\", 150.50),\n", " (3, 3, \"2023-11-25\", 300.00),\n", " (4, 4, \"2023-12-02\", 450.00),\n", "]" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.executemany(insert_query,employee_data)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.executemany(insert_query_customers,customers_data)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.executemany(insert_query_orders,orders_data)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "connection.commit()" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.execute(\"select * from employees;\")" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 'Sunny', 'Savita', 'sunny.sv@abc.com', '2023-06-01', 50000.0)\n", "(2, 'Arhun', 'Meheta', 'arhun.m@gmail.com', '2022-04-15', 60000.0)\n", "(3, 'Alice', 'Johnson', 'alice.johnson@jpg.com', '2021-09-30', 55000.0)\n", "(4, 'Bob', 'Brown', 'bob.brown@uio.com', '2020-01-20', 45000.0)\n" ] } ], "source": [ "for row in cursor.fetchall():\n", " print(row)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.execute(\"select first_name from employees where salary > 50000.0;\")" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[('Arhun',), ('Alice',)]" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.fetchall()" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.execute(\"SELECT name FROM sqlite_master WHERE type = 'table';\")" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[('employees',), ('customers',), ('sqlite_sequence',), ('orders',)]" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cursor.fetchall()" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import os\n", "from dotenv import load_dotenv\n", "load_dotenv()\n", "GROQ_API_KEY=os.getenv(\"GROQ_API_KEY\")\n", "os.environ[\"GROQ_API_KEY\"]= GROQ_API_KEY" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from langchain_groq import ChatGroq\n", "llm=ChatGroq(model=\"llama3-70b-8192\")" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Hello! It's nice to meet you. Is there something I can help you with, or would you like to chat?\"" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "llm.invoke(\"hello\").content" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "from langchain_community.utilities import SQLDatabase\n", "db = SQLDatabase.from_uri(\"sqlite:///employee.db\")" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dialect: sqlite\n", "Usable tables: ['customers', 'employees', 'orders']\n" ] } ], "source": [ "print(\"Dialect:\", db.dialect)\n", "print(\"Usable tables:\", db.get_usable_table_names())" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Query result from Employees table: \n", " [(1, 'Sunny', 'Savita', 'sunny.sv@abc.com', '2023-06-01', 50000.0), (2, 'Arhun', 'Meheta', 'arhun.m@gmail.com', '2022-04-15', 60000.0), (3, 'Alice', 'Johnson', 'alice.johnson@jpg.com', '2021-09-30', 55000.0), (4, 'Bob', 'Brown', 'bob.brown@uio.com', '2020-01-20', 45000.0)]\n" ] } ], "source": [ "query_result = db.run(\"SELECT * FROM employees ;\")\n", "print(\"Query result from Employees table: \\n\", query_result)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "from langchain_community.agent_toolkits import SQLDatabaseToolkit" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "toolkit=SQLDatabaseToolkit(db=db,llm=llm)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "tools=toolkit.get_tools()" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[QuerySQLDatabaseTool(description=\"Input to this tool is a detailed and correct SQL query, output is a result from the database. If the query is not correct, an error message will be returned. If an error is returned, rewrite the query, check the query, and try again. If you encounter an issue with Unknown column 'xxxx' in 'field list', use sql_db_schema to query the correct table fields.\", db=),\n", " InfoSQLDatabaseTool(description='Input to this tool is a comma-separated list of tables, output is the schema and sample rows for those tables. Be sure that the tables actually exist by calling sql_db_list_tables first! Example Input: table1, table2, table3', db=),\n", " ListSQLDatabaseTool(db=),\n", " QuerySQLCheckerTool(description='Use this tool to double check if your query is correct before executing it. Always use this tool before executing a query with sql_db_query!', db=, llm=ChatGroq(client=, async_client=, model_name='llama3-70b-8192', model_kwargs={}, groq_api_key=SecretStr('**********')), llm_chain=LLMChain(verbose=False, prompt=PromptTemplate(input_variables=['dialect', 'query'], input_types={}, partial_variables={}, template='\\n{query}\\nDouble check the {dialect} query above 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\\nIf there are any of the above mistakes, rewrite the query. If there are no mistakes, just reproduce the original query.\\n\\nOutput the final SQL query only.\\n\\nSQL Query: '), llm=ChatGroq(client=, async_client=, model_name='llama3-70b-8192', model_kwargs={}, groq_api_key=SecretStr('**********')), output_parser=StrOutputParser(), llm_kwargs={}))]" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tools" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "sql_db_query\n", "sql_db_schema\n", "sql_db_list_tables\n", "sql_db_query_checker\n" ] } ], "source": [ "for tool in tools:\n", " print(tool.name)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "list_tables_tool = next((tool for tool in tools if tool.name == \"sql_db_list_tables\"), None)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ListSQLDatabaseTool(db=)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list_tables_tool" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "get_schema_tool = next((tool for tool in tools if tool.name == \"sql_db_schema\"), None)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "InfoSQLDatabaseTool(description='Input to this tool is a comma-separated list of tables, output is the schema and sample rows for those tables. Be sure that the tables actually exist by calling sql_db_list_tables first! Example Input: table1, table2, table3', db=)" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "get_schema_tool" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "customers, employees, orders\n" ] } ], "source": [ "print(list_tables_tool.invoke(\"\"))" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "CREATE TABLE employees (\n", "\temp_id INTEGER, \n", "\tfirst_name TEXT NOT NULL, \n", "\tlast_name TEXT NOT NULL, \n", "\temail TEXT NOT NULL, \n", "\thire_date TEXT NOT NULL, \n", "\tsalary REAL NOT NULL, \n", "\tPRIMARY KEY (emp_id), \n", "\tUNIQUE (email)\n", ")\n", "\n", "/*\n", "3 rows from employees table:\n", "emp_id\tfirst_name\tlast_name\temail\thire_date\tsalary\n", "1\tSunny\tSavita\tsunny.sv@abc.com\t2023-06-01\t50000.0\n", "2\tArhun\tMeheta\tarhun.m@gmail.com\t2022-04-15\t60000.0\n", "3\tAlice\tJohnson\talice.johnson@jpg.com\t2021-09-30\t55000.0\n", "*/\n" ] } ], "source": [ "print(get_schema_tool.invoke(\"employees\"))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "from langchain_core.tools import tool\n", "@tool\n", "def db_query_tool(query: str) -> str:\n", " \"\"\"\n", " Execute a SQL query against the database and return the result.\n", " If the query is invalid or returns no result, an error message will be returned.\n", " In case of an error, the user is advised to rewrite the query and try again.\n", " \"\"\"\n", " result = db.run_no_throw(query)\n", " if not result:\n", " return \"Error: Query failed. Please rewrite your query and try again.\"\n", " return result" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[(1, 'Sunny', 'Savita', 'sunny.sv@abc.com', '2023-06-01', 50000.0), (2, 'Arhun', 'Meheta', 'arhun.m@gmail.com', '2022-04-15', 60000.0), (3, 'Alice', 'Johnson', 'alice.johnson@jpg.com', '2021-09-30', 55000.0), (4, 'Bob', 'Brown', 'bob.brown@uio.com', '2020-01-20', 45000.0)]\n" ] } ], "source": [ "print(db_query_tool.invoke(\"SELECT * FROM Employees LIMIT 10;\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "```python\n", "class Database:\n", " def run_no_throw(self, query):\n", " try:\n", " # Assume `self.connection` is a valid database connection\n", " cursor = self.connection.cursor()\n", " cursor.execute(query)\n", " return cursor.fetchall() # Or another method to retrieve results\n", " except Exception as e:\n", " print(f\"Error executing query: {e}\")\n", " return None # Fallback value\n", "```" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "c:\\code\\AiAgents\\Talk2SQL\\backend\\.venv\\Lib\\site-packages\\IPython\\core\\interactiveshell.py:3699: LangChainDeprecationWarning: As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. The langchain_core.pydantic_v1 module was a compatibility shim for pydantic v1, and should no longer be used. Please update the code to import from Pydantic directly.\n", "\n", "For example, replace imports like: `from langchain_core.pydantic_v1 import BaseModel`\n", "with: `from pydantic import BaseModel`\n", "or the v1 compatibility namespace if you are working in a code base that has not been fully upgraded to pydantic 2 yet. \tfrom pydantic.v1 import BaseModel\n", "\n", " exec(code_obj, self.user_global_ns, self.user_ns)\n" ] } ], "source": [ "from typing import Annotated, Literal\n", "from langchain_core.messages import AIMessage\n", "from langchain_core.pydantic_v1 import BaseModel, Field\n", "from typing_extensions import TypedDict\n", "from langgraph.graph import END, StateGraph, START\n", "from langgraph.graph.message import AnyMessage, add_messages\n", "from typing import Any\n", "from langchain_core.messages import ToolMessage\n", "from langchain_core.runnables import RunnableLambda, RunnableWithFallbacks\n", "from langgraph.prebuilt import ToolNode\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "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\")" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "class State(TypedDict):\n", " messages: Annotated[list[AnyMessage], add_messages]" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'v4xkchw7b', 'function': {'arguments': '{\"query\":\"SELECT * FROM Employees LIMIT 5;\"}', 'name': 'db_query_tool'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 73, 'prompt_tokens': 1055, 'total_tokens': 1128, 'completion_time': 0.254647347, 'prompt_time': 0.036018925, 'queue_time': 0.063723685, 'total_time': 0.290666272}, 'model_name': 'llama3-70b-8192', 'system_fingerprint': 'fp_dd4ae1c591', 'service_tier': 'on_demand', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run--54ecb701-d90d-4c17-bcb3-7b50256561f7-0', tool_calls=[{'name': 'db_query_tool', 'args': {'query': 'SELECT * FROM Employees LIMIT 5;'}, 'id': 'v4xkchw7b', 'type': 'tool_call'}], usage_metadata={'input_tokens': 1055, 'output_tokens': 73, 'total_tokens': 1128})" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from langchain_core.prompts import ChatPromptTemplate\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", "\n", "query_check = query_check_prompt | llm.bind_tools([db_query_tool])\n", "\n", "query_check.invoke({\"messages\": [(\"user\", \"SELECT * FROM Employees LIMIT 5;\")]})" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "AIMessage(content='', additional_kwargs={'tool_calls': [{'id': '5pan1gm04', 'function': {'arguments': '{\"query\":\"SELECT * FROM Employees LIMIT 5;\"}', 'name': 'db_query_tool'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 117, 'prompt_tokens': 1055, 'total_tokens': 1172, 'completion_time': 0.495897186, 'prompt_time': 0.041932288, 'queue_time': 0.055952746, 'total_time': 0.537829474}, 'model_name': 'llama3-70b-8192', 'system_fingerprint': 'fp_dd4ae1c591', 'service_tier': 'on_demand', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run--e547766b-efb1-4079-95b7-032c85829922-0', tool_calls=[{'name': 'db_query_tool', 'args': {'query': 'SELECT * FROM Employees LIMIT 5;'}, 'id': '5pan1gm04', 'type': 'tool_call'}], usage_metadata={'input_tokens': 1055, 'output_tokens': 117, 'total_tokens': 1172})" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "query_check.invoke({\"messages\": [(\"user\", \"SELECT + FROM Employees LIMIT 5;\")]})" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# 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, 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", "\n", "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... just say you don't have enough information.\n", "\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. Do not return any sql query except answer.\"\"\"\n", "\n", "\n", "query_gen_prompt = ChatPromptTemplate.from_messages([(\"system\", query_gen_system), (\"placeholder\", \"{messages}\")])\n", "\n", "query_gen = query_gen_prompt | llm.bind_tools([SubmitFinalAnswer])" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "from typing import Annotated, Literal\n", "from langchain_core.messages import AIMessage\n", "from langchain_core.pydantic_v1 import BaseModel, Field\n", "from typing_extensions import TypedDict\n", "from langgraph.graph import END, StateGraph, START\n", "from langgraph.graph.message import AnyMessage, add_messages\n", "from typing import Any\n", "from langchain_core.messages import ToolMessage\n", "from langchain_core.runnables import RunnableLambda, RunnableWithFallbacks\n", "from langgraph.prebuilt import ToolNode\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "def first_tool_call(state:State)->dict[str,list[AIMessage]]:\n", " return{\"messages\": [AIMessage(content=\"\",tool_calls=[{\"name\":\"sql_db_list_tables\",\"args\":{},\"id\":\"tool_abcd123\"}])]}" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "def handle_tool_error(state:State) -> dict:\n", " error = state.get(\"error\") \n", " tool_calls = state[\"messages\"][-1].tool_calls\n", " return {\n", " \"messages\": [\n", " ToolMessage(content=f\"Error: {repr(error)}\\n please fix your mistakes.\",tool_call_id=tc[\"id\"],)\n", " for tc in tool_calls\n", " ]\n", " }\n", "def create_tool_node_with_fallback(tools: list) -> RunnableWithFallbacks[Any, dict]:\n", " return ToolNode(tools).with_fallbacks([RunnableLambda(handle_tool_error)], exception_key=\"error\")" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "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}" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "def should_continue(state: State) -> Literal[END, \"correct_query\", \"query_gen\"]:\n", " messages = state[\"messages\"]\n", " last_message = messages[-1]\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 \"correct_query\"" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "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 {\"messages\": [query_check.invoke({\"messages\": [state[\"messages\"][-1]]})]}" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "workflow = StateGraph(State)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "workflow.add_node(\"first_tool_call\",first_tool_call)\n", "workflow.add_node(\"list_tables_tool\", create_tool_node_with_fallback([list_tables_tool]))\n", "workflow.add_node(\"get_schema_tool\", create_tool_node_with_fallback([get_schema_tool]))\n", "model_get_schema = llm.bind_tools([get_schema_tool])\n", "workflow.add_node(\"model_get_schema\",lambda state: {\"messages\": [model_get_schema.invoke(state[\"messages\"])],},)\n", "workflow.add_node(\"query_gen\", query_gen_node)\n", "workflow.add_node(\"correct_query\", model_check_query)\n", "workflow.add_node(\"execute_query\", create_tool_node_with_fallback([db_query_tool]))\n" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "workflow.add_edge(START, \"first_tool_call\")\n", "workflow.add_edge(\"first_tool_call\", \"list_tables_tool\")\n", "workflow.add_edge(\"list_tables_tool\", \"model_get_schema\")\n", "workflow.add_edge(\"model_get_schema\", \"get_schema_tool\")\n", "workflow.add_edge(\"get_schema_tool\", \"query_gen\")\n", "workflow.add_conditional_edges(\"query_gen\",should_continue,)\n", "workflow.add_edge(\"correct_query\", \"execute_query\")\n", "workflow.add_edge(\"execute_query\", \"query_gen\")" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "app = workflow.compile()" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from IPython.display import Image, display\n", "from langchain_core.runnables.graph import MermaidDrawMethod\n", "\n", "display(\n", " Image(\n", " app.get_graph().draw_mermaid_png(\n", " draw_method=MermaidDrawMethod.API,\n", " )\n", " )\n", ")" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "def is_query_relevant( query: str) -> bool:\n", " \"\"\"Check if the query is relevant to the database using the LLM.\"\"\"\n", " relevance_check_prompt = f\"Is the following query related to the database li? {query}, answer in only one word : yes/no\"\n", " response = llm.invoke(relevance_check_prompt)\n", " # Assuming the LLM returns a simple 'yes' or 'no'\n", " return response.lower" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "query={\"messages\": [(\"user\", \"What is the capital of india?\")]}" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "ename": "AttributeError", "evalue": "'AIMessage' object has no attribute 'lower'", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[39]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m response=\u001b[43mis_query_relevant\u001b[49m\u001b[43m(\u001b[49m\u001b[43mquery\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2\u001b[39m \u001b[38;5;28mprint\u001b[39m(response)\n", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[37]\u001b[39m\u001b[32m, line 6\u001b[39m, in \u001b[36mis_query_relevant\u001b[39m\u001b[34m(query)\u001b[39m\n\u001b[32m 4\u001b[39m response = llm.invoke(relevance_check_prompt)\n\u001b[32m 5\u001b[39m \u001b[38;5;66;03m# Assuming the LLM returns a simple 'yes' or 'no'\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mresponse\u001b[49m\u001b[43m.\u001b[49m\u001b[43mlower\u001b[49m\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\code\\AiAgents\\Talk2SQL\\backend\\.venv\\Lib\\site-packages\\pydantic\\main.py:991\u001b[39m, in \u001b[36mBaseModel.__getattr__\u001b[39m\u001b[34m(self, item)\u001b[39m\n\u001b[32m 988\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28msuper\u001b[39m().\u001b[34m__getattribute__\u001b[39m(item) \u001b[38;5;66;03m# Raises AttributeError if appropriate\u001b[39;00m\n\u001b[32m 989\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 990\u001b[39m \u001b[38;5;66;03m# this is the current error\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m991\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28mself\u001b[39m).\u001b[34m__name__\u001b[39m\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m object has no attribute \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mitem\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m'\u001b[39m)\n", "\u001b[31mAttributeError\u001b[39m: 'AIMessage' object has no attribute 'lower'" ] } ], "source": [ "response=is_query_relevant(query)\n", "print(response)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'response' is not defined", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[40]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mresponse\u001b[49m[\u001b[33m\"\u001b[39m\u001b[33mmessages\u001b[39m\u001b[33m\"\u001b[39m][-\u001b[32m1\u001b[39m].tool_calls[\u001b[32m0\u001b[39m][\u001b[33m\"\u001b[39m\u001b[33margs\u001b[39m\u001b[33m\"\u001b[39m][\u001b[33m\"\u001b[39m\u001b[33mfinal_answer\u001b[39m\u001b[33m\"\u001b[39m]\n", "\u001b[31mNameError\u001b[39m: name 'response' is not defined" ] } ], "source": [ "response[\"messages\"][-1].tool_calls[0][\"args\"][\"final_answer\"]" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [], "source": [ "query={\"messages\": [(\"user\", \"Tell me about all the orders\")]}" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [], "source": [ "response = app.invoke(query)" ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'You have 3 orders in the orders table'" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "response[\"messages\"][-1].tool_calls[0][\"args\"][\"final_answer\"]" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [], "source": [ "query={\"messages\": [(\"user\", \"How many tables are in database?\")]}" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "ename": "KeyboardInterrupt", "evalue": "", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mHTTPStatusError\u001b[0m Traceback (most recent call last)", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\_base_client.py:1040\u001b[0m, in \u001b[0;36mSyncAPIClient._request\u001b[1;34m(self, cast_to, options, retries_taken, stream, stream_cls)\u001b[0m\n\u001b[0;32m 1039\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 1040\u001b[0m \u001b[43mresponse\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1041\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m httpx\u001b[38;5;241m.\u001b[39mHTTPStatusError \u001b[38;5;28;01mas\u001b[39;00m err: \u001b[38;5;66;03m# thrown on 4xx and 5xx status code\u001b[39;00m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\httpx\\_models.py:829\u001b[0m, in \u001b[0;36mResponse.raise_for_status\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 828\u001b[0m message \u001b[38;5;241m=\u001b[39m message\u001b[38;5;241m.\u001b[39mformat(\u001b[38;5;28mself\u001b[39m, error_type\u001b[38;5;241m=\u001b[39merror_type)\n\u001b[1;32m--> 829\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m HTTPStatusError(message, request\u001b[38;5;241m=\u001b[39mrequest, response\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m)\n", "\u001b[1;31mHTTPStatusError\u001b[0m: Client error '429 Too Many Requests' for url 'https://api.groq.com/openai/v1/chat/completions'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429", "\nDuring handling of the above exception, another exception occurred:\n", "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[70], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mapp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[43mquery\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\pregel\\__init__.py:2124\u001b[0m, in \u001b[0;36mPregel.invoke\u001b[1;34m(self, input, config, stream_mode, output_keys, interrupt_before, interrupt_after, debug, **kwargs)\u001b[0m\n\u001b[0;32m 2122\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 2123\u001b[0m chunks \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m-> 2124\u001b[0m \u001b[43m\u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mchunk\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 2125\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2126\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2127\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_mode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_mode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2128\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_keys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_keys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2129\u001b[0m \u001b[43m \u001b[49m\u001b[43minterrupt_before\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterrupt_before\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2130\u001b[0m \u001b[43m \u001b[49m\u001b[43minterrupt_after\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterrupt_after\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2131\u001b[0m \u001b[43m \u001b[49m\u001b[43mdebug\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdebug\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2132\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2133\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[0;32m 2134\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mstream_mode\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mvalues\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\n\u001b[0;32m 2135\u001b[0m \u001b[43m \u001b[49m\u001b[43mlatest\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mchunk\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\pregel\\__init__.py:1779\u001b[0m, in \u001b[0;36mPregel.stream\u001b[1;34m(self, input, config, stream_mode, output_keys, interrupt_before, interrupt_after, debug, subgraphs)\u001b[0m\n\u001b[0;32m 1773\u001b[0m \u001b[38;5;66;03m# Similarly to Bulk Synchronous Parallel / Pregel model\u001b[39;00m\n\u001b[0;32m 1774\u001b[0m \u001b[38;5;66;03m# computation proceeds in steps, while there are channel updates.\u001b[39;00m\n\u001b[0;32m 1775\u001b[0m \u001b[38;5;66;03m# Channel updates from step N are only visible in step N+1\u001b[39;00m\n\u001b[0;32m 1776\u001b[0m \u001b[38;5;66;03m# channels are guaranteed to be immutable for the duration of the step,\u001b[39;00m\n\u001b[0;32m 1777\u001b[0m \u001b[38;5;66;03m# with channel updates applied only at the transition between steps.\u001b[39;00m\n\u001b[0;32m 1778\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m loop\u001b[38;5;241m.\u001b[39mtick(input_keys\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_channels):\n\u001b[1;32m-> 1779\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m_\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrunner\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtick\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1780\u001b[0m \u001b[43m \u001b[49m\u001b[43mloop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtasks\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1781\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep_timeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1782\u001b[0m \u001b[43m \u001b[49m\u001b[43mretry_policy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mretry_policy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1783\u001b[0m \u001b[43m \u001b[49m\u001b[43mget_waiter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mget_waiter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1784\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[0;32m 1785\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# emit output\u001b[39;49;00m\n\u001b[0;32m 1786\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01myield from\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43moutput\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1787\u001b[0m \u001b[38;5;66;03m# emit output\u001b[39;00m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\pregel\\runner.py:230\u001b[0m, in \u001b[0;36mPregelRunner.tick\u001b[1;34m(self, tasks, reraise, timeout, retry_policy, get_waiter)\u001b[0m\n\u001b[0;32m 228\u001b[0m t \u001b[38;5;241m=\u001b[39m tasks[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m 229\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 230\u001b[0m \u001b[43mrun_with_retry\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 231\u001b[0m \u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 232\u001b[0m \u001b[43m \u001b[49m\u001b[43mretry_policy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 233\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfigurable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\n\u001b[0;32m 234\u001b[0m \u001b[43m \u001b[49m\u001b[43mCONFIG_KEY_SEND\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwriter\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 235\u001b[0m \u001b[43m \u001b[49m\u001b[43mCONFIG_KEY_CALL\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcall\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 236\u001b[0m \u001b[43m \u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 237\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 238\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcommit(t, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m 239\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exc:\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\pregel\\retry.py:40\u001b[0m, in \u001b[0;36mrun_with_retry\u001b[1;34m(task, retry_policy, configurable)\u001b[0m\n\u001b[0;32m 38\u001b[0m task\u001b[38;5;241m.\u001b[39mwrites\u001b[38;5;241m.\u001b[39mclear()\n\u001b[0;32m 39\u001b[0m \u001b[38;5;66;03m# run the task\u001b[39;00m\n\u001b[1;32m---> 40\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mproc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minput\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 41\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m ParentCommand \u001b[38;5;28;01mas\u001b[39;00m exc:\n\u001b[0;32m 42\u001b[0m ns: \u001b[38;5;28mstr\u001b[39m \u001b[38;5;241m=\u001b[39m config[CONF][CONFIG_KEY_CHECKPOINT_NS]\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\utils\\runnable.py:546\u001b[0m, in \u001b[0;36mRunnableSeq.invoke\u001b[1;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[0;32m 542\u001b[0m config \u001b[38;5;241m=\u001b[39m patch_config(\n\u001b[0;32m 543\u001b[0m config, callbacks\u001b[38;5;241m=\u001b[39mrun_manager\u001b[38;5;241m.\u001b[39mget_child(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mseq:step:\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;250m \u001b[39m\u001b[38;5;241m+\u001b[39m\u001b[38;5;250m \u001b[39m\u001b[38;5;241m1\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 544\u001b[0m )\n\u001b[0;32m 545\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m i \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m--> 546\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mstep\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 547\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 548\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m step\u001b[38;5;241m.\u001b[39minvoke(\u001b[38;5;28minput\u001b[39m, config)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\utils\\runnable.py:310\u001b[0m, in \u001b[0;36mRunnableCallable.invoke\u001b[1;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[0;32m 308\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 309\u001b[0m context\u001b[38;5;241m.\u001b[39mrun(_set_config_context, config)\n\u001b[1;32m--> 310\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mcontext\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 311\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(ret, Runnable) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrecurse:\n\u001b[0;32m 312\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ret\u001b[38;5;241m.\u001b[39minvoke(\u001b[38;5;28minput\u001b[39m, config)\n", "Cell \u001b[1;32mIn[55], line 2\u001b[0m, in \u001b[0;36mquery_gen_node\u001b[1;34m(state)\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mquery_gen_node\u001b[39m(state: State):\n\u001b[1;32m----> 2\u001b[0m message \u001b[38;5;241m=\u001b[39m \u001b[43mquery_gen\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 4\u001b[0m \u001b[38;5;66;03m# Sometimes, the LLM will hallucinate and call the wrong tool. We need to catch this and return an error message.\u001b[39;00m\n\u001b[0;32m 5\u001b[0m tool_messages \u001b[38;5;241m=\u001b[39m []\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\runnables\\base.py:3024\u001b[0m, in \u001b[0;36mRunnableSequence.invoke\u001b[1;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[0;32m 3022\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m context\u001b[38;5;241m.\u001b[39mrun(step\u001b[38;5;241m.\u001b[39minvoke, \u001b[38;5;28minput\u001b[39m, config, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 3023\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 3024\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mcontext\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3025\u001b[0m \u001b[38;5;66;03m# finish the root run\u001b[39;00m\n\u001b[0;32m 3026\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mBaseException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\runnables\\base.py:5360\u001b[0m, in \u001b[0;36mRunnableBindingBase.invoke\u001b[1;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[0;32m 5354\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21minvoke\u001b[39m(\n\u001b[0;32m 5355\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 5356\u001b[0m \u001b[38;5;28minput\u001b[39m: Input,\n\u001b[0;32m 5357\u001b[0m config: Optional[RunnableConfig] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m 5358\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Optional[Any],\n\u001b[0;32m 5359\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Output:\n\u001b[1;32m-> 5360\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbound\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 5361\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 5362\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_merge_configs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 5363\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 5364\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\language_models\\chat_models.py:284\u001b[0m, in \u001b[0;36mBaseChatModel.invoke\u001b[1;34m(self, input, config, stop, **kwargs)\u001b[0m\n\u001b[0;32m 273\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21minvoke\u001b[39m(\n\u001b[0;32m 274\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 275\u001b[0m \u001b[38;5;28minput\u001b[39m: LanguageModelInput,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 279\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any,\n\u001b[0;32m 280\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m BaseMessage:\n\u001b[0;32m 281\u001b[0m config \u001b[38;5;241m=\u001b[39m ensure_config(config)\n\u001b[0;32m 282\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cast(\n\u001b[0;32m 283\u001b[0m ChatGeneration,\n\u001b[1;32m--> 284\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_prompt\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 285\u001b[0m \u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_convert_input\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 286\u001b[0m \u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 287\u001b[0m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcallbacks\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 288\u001b[0m \u001b[43m \u001b[49m\u001b[43mtags\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtags\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 289\u001b[0m \u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmetadata\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 290\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrun_name\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 291\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpop\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrun_id\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 292\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 293\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mgenerations[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m],\n\u001b[0;32m 294\u001b[0m )\u001b[38;5;241m.\u001b[39mmessage\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\language_models\\chat_models.py:860\u001b[0m, in \u001b[0;36mBaseChatModel.generate_prompt\u001b[1;34m(self, prompts, stop, callbacks, **kwargs)\u001b[0m\n\u001b[0;32m 852\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mgenerate_prompt\u001b[39m(\n\u001b[0;32m 853\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 854\u001b[0m prompts: \u001b[38;5;28mlist\u001b[39m[PromptValue],\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 857\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any,\n\u001b[0;32m 858\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m LLMResult:\n\u001b[0;32m 859\u001b[0m prompt_messages \u001b[38;5;241m=\u001b[39m [p\u001b[38;5;241m.\u001b[39mto_messages() \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m prompts]\n\u001b[1;32m--> 860\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprompt_messages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\language_models\\chat_models.py:690\u001b[0m, in \u001b[0;36mBaseChatModel.generate\u001b[1;34m(self, messages, stop, callbacks, tags, metadata, run_name, run_id, **kwargs)\u001b[0m\n\u001b[0;32m 687\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(messages):\n\u001b[0;32m 688\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 689\u001b[0m results\u001b[38;5;241m.\u001b[39mappend(\n\u001b[1;32m--> 690\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_generate_with_cache\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 691\u001b[0m \u001b[43m \u001b[49m\u001b[43mm\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 692\u001b[0m \u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 693\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_manager\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_managers\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrun_managers\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m 694\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 695\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 696\u001b[0m )\n\u001b[0;32m 697\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mBaseException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 698\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m run_managers:\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\language_models\\chat_models.py:925\u001b[0m, in \u001b[0;36mBaseChatModel._generate_with_cache\u001b[1;34m(self, messages, stop, run_manager, **kwargs)\u001b[0m\n\u001b[0;32m 923\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 924\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m inspect\u001b[38;5;241m.\u001b[39msignature(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_generate)\u001b[38;5;241m.\u001b[39mparameters\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrun_manager\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m--> 925\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_generate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 926\u001b[0m \u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrun_manager\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_manager\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[0;32m 927\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 928\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 929\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_generate(messages, stop\u001b[38;5;241m=\u001b[39mstop, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_groq\\chat_models.py:480\u001b[0m, in \u001b[0;36mChatGroq._generate\u001b[1;34m(self, messages, stop, run_manager, **kwargs)\u001b[0m\n\u001b[0;32m 475\u001b[0m message_dicts, params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_create_message_dicts(messages, stop)\n\u001b[0;32m 476\u001b[0m params \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m 477\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mparams,\n\u001b[0;32m 478\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[0;32m 479\u001b[0m }\n\u001b[1;32m--> 480\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmessage_dicts\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 481\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_create_chat_result(response)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\resources\\chat\\completions.py:316\u001b[0m, in \u001b[0;36mCompletions.create\u001b[1;34m(self, messages, model, frequency_penalty, function_call, functions, logit_bias, logprobs, max_completion_tokens, max_tokens, n, parallel_tool_calls, presence_penalty, response_format, seed, service_tier, stop, stream, temperature, tool_choice, tools, top_logprobs, top_p, user, extra_headers, extra_query, extra_body, timeout)\u001b[0m\n\u001b[0;32m 163\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mcreate\u001b[39m(\n\u001b[0;32m 164\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 165\u001b[0m \u001b[38;5;241m*\u001b[39m,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 194\u001b[0m timeout: \u001b[38;5;28mfloat\u001b[39m \u001b[38;5;241m|\u001b[39m httpx\u001b[38;5;241m.\u001b[39mTimeout \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m|\u001b[39m NotGiven \u001b[38;5;241m=\u001b[39m NOT_GIVEN,\n\u001b[0;32m 195\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ChatCompletion \u001b[38;5;241m|\u001b[39m Stream[ChatCompletionChunk]:\n\u001b[0;32m 196\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 197\u001b[0m \u001b[38;5;124;03m Creates a model response for the given chat conversation.\u001b[39;00m\n\u001b[0;32m 198\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 314\u001b[0m \u001b[38;5;124;03m timeout: Override the client-level default timeout for this request, in seconds\u001b[39;00m\n\u001b[0;32m 315\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m--> 316\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_post\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 317\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/openai/v1/chat/completions\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 318\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmaybe_transform\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 319\u001b[0m \u001b[43m \u001b[49m\u001b[43m{\u001b[49m\n\u001b[0;32m 320\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmessages\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 321\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmodel\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 322\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfrequency_penalty\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfrequency_penalty\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 323\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunction_call\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunction_call\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 324\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunctions\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunctions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 325\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlogit_bias\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogit_bias\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 326\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlogprobs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogprobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 327\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmax_completion_tokens\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_completion_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 328\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmax_tokens\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 329\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mn\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 330\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mparallel_tool_calls\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mparallel_tool_calls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 331\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpresence_penalty\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mpresence_penalty\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 332\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mresponse_format\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mresponse_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 333\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mseed\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mseed\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 334\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mservice_tier\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mservice_tier\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 335\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstop\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 336\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstream\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 337\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtemperature\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtemperature\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 338\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtool_choice\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtool_choice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 339\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtools\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtools\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 340\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtop_logprobs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtop_logprobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 341\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtop_p\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtop_p\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 342\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43muser\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43muser\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 343\u001b[0m \u001b[43m \u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 344\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompletion_create_params\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mCompletionCreateParams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 345\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 346\u001b[0m \u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmake_request_options\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 347\u001b[0m \u001b[43m \u001b[49m\u001b[43mextra_headers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_headers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_query\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_query\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_body\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_body\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\n\u001b[0;32m 348\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 349\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mChatCompletion\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 350\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m 351\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mStream\u001b[49m\u001b[43m[\u001b[49m\u001b[43mChatCompletionChunk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 352\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\_base_client.py:1266\u001b[0m, in \u001b[0;36mSyncAPIClient.post\u001b[1;34m(self, path, cast_to, body, options, files, stream, stream_cls)\u001b[0m\n\u001b[0;32m 1252\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mpost\u001b[39m(\n\u001b[0;32m 1253\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 1254\u001b[0m path: \u001b[38;5;28mstr\u001b[39m,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1261\u001b[0m stream_cls: \u001b[38;5;28mtype\u001b[39m[_StreamT] \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m 1262\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResponseT \u001b[38;5;241m|\u001b[39m _StreamT:\n\u001b[0;32m 1263\u001b[0m opts \u001b[38;5;241m=\u001b[39m FinalRequestOptions\u001b[38;5;241m.\u001b[39mconstruct(\n\u001b[0;32m 1264\u001b[0m method\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpost\u001b[39m\u001b[38;5;124m\"\u001b[39m, url\u001b[38;5;241m=\u001b[39mpath, json_data\u001b[38;5;241m=\u001b[39mbody, files\u001b[38;5;241m=\u001b[39mto_httpx_files(files), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions\n\u001b[0;32m 1265\u001b[0m )\n\u001b[1;32m-> 1266\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cast(ResponseT, \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mopts\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m)\u001b[49m)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\_base_client.py:958\u001b[0m, in \u001b[0;36mSyncAPIClient.request\u001b[1;34m(self, cast_to, options, remaining_retries, stream, stream_cls)\u001b[0m\n\u001b[0;32m 955\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 956\u001b[0m retries_taken \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m--> 958\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 959\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 960\u001b[0m \u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 961\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 962\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 963\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries_taken\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mretries_taken\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 964\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\_base_client.py:1046\u001b[0m, in \u001b[0;36mSyncAPIClient._request\u001b[1;34m(self, cast_to, options, retries_taken, stream, stream_cls)\u001b[0m\n\u001b[0;32m 1044\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m remaining_retries \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_should_retry(err\u001b[38;5;241m.\u001b[39mresponse):\n\u001b[0;32m 1045\u001b[0m err\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mclose()\n\u001b[1;32m-> 1046\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_retry_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1047\u001b[0m \u001b[43m \u001b[49m\u001b[43minput_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1048\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1049\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries_taken\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mretries_taken\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1050\u001b[0m \u001b[43m \u001b[49m\u001b[43mresponse_headers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresponse\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1051\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1052\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1053\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1055\u001b[0m \u001b[38;5;66;03m# If the response is streamed then we need to explicitly read the response\u001b[39;00m\n\u001b[0;32m 1056\u001b[0m \u001b[38;5;66;03m# to completion before attempting to access the response text.\u001b[39;00m\n\u001b[0;32m 1057\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m err\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mis_closed:\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\_base_client.py:1093\u001b[0m, in \u001b[0;36mSyncAPIClient._retry_request\u001b[1;34m(self, options, cast_to, retries_taken, response_headers, stream, stream_cls)\u001b[0m\n\u001b[0;32m 1089\u001b[0m log\u001b[38;5;241m.\u001b[39minfo(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRetrying request to \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m in \u001b[39m\u001b[38;5;132;01m%f\u001b[39;00m\u001b[38;5;124m seconds\u001b[39m\u001b[38;5;124m\"\u001b[39m, options\u001b[38;5;241m.\u001b[39murl, timeout)\n\u001b[0;32m 1091\u001b[0m \u001b[38;5;66;03m# In a synchronous context we are blocking the entire thread. Up to the library user to run the client in a\u001b[39;00m\n\u001b[0;32m 1092\u001b[0m \u001b[38;5;66;03m# different thread if necessary.\u001b[39;00m\n\u001b[1;32m-> 1093\u001b[0m \u001b[43mtime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1095\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_request(\n\u001b[0;32m 1096\u001b[0m options\u001b[38;5;241m=\u001b[39moptions,\n\u001b[0;32m 1097\u001b[0m cast_to\u001b[38;5;241m=\u001b[39mcast_to,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1100\u001b[0m stream_cls\u001b[38;5;241m=\u001b[39mstream_cls,\n\u001b[0;32m 1101\u001b[0m )\n", "\u001b[1;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ "response = app.invoke(query)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'There are 3 tables in the database: customers, employees, orders'" ] }, "execution_count": 92, "metadata": {}, "output_type": "execute_result" } ], "source": [ "response[\"messages\"][-1].tool_calls[0][\"args\"][\"final_answer\"]" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from langchain_community.utilities import SQLDatabase\n", "from langchain_groq import ChatGroq\n", "from langgraph.graph import StateGraph, END, START\n", "from langchain_core.messages import AIMessage, ToolMessage, AnyMessage\n", "from langgraph.graph.message import AnyMessage, add_messages\n", "from langchain_core.tools import tool\n", "from typing import Annotated, Literal, TypedDict, Any\n", "from pydantic import BaseModel, Field\n", "from langchain_core.runnables import RunnableLambda, RunnableWithFallbacks\n", "from langgraph.prebuilt import ToolNode\n", "from langchain_core.prompts import ChatPromptTemplate\n", "from langchain_community.agent_toolkits import SQLDatabaseToolkit\n", "from dotenv import load_dotenv\n", "import os\n", "from IPython.display import display\n", "from PIL import Image\n", "import io\n", "from langgraph.errors import GraphRecursionError\n", "from IPython.display import Image, display\n", "from langchain_core.runnables.graph import MermaidDrawMethod" ] }, { "cell_type": "code", "execution_count": 151, "metadata": {}, "outputs": [], "source": [ "import os\n", "import io\n", "from typing import Annotated, Any, TypedDict\n", "from dotenv import load_dotenv\n", "# from PIL import Image\n", "\n", "# Added for more robust tool call handling\n", "from typing import Optional\n", "\n", "class SQLAgent:\n", " def __init__(self, model=\"llama3-70b-8192\"):\n", " load_dotenv()\n", " # Initialize instance variables\n", " self.db = None\n", " self.toolkit = None\n", " self.tools = None\n", " self.list_tables_tool = None\n", " self.sql_db_query = None\n", " self.get_schema_tool = None\n", " self.app = None\n", "\n", " # Setting up LLM\n", " self.llm = ChatGroq(model=model, api_key=os.getenv(\"GROQ_API_KEY\"))\n", "\n", " # Register the tool method\n", " self.query_to_database = self._create_query_tool()\n", "\n", " def _create_query_tool(self):\n", " \"\"\"Create the query tool bound to this instance\"\"\"\n", " print(\"creating _create_query_tool\")\n", "\n", " @tool\n", " def query_to_database(query: str) -> str:\n", " \"\"\"\n", " Execute a SQL query against the database and return the result.\n", " If the query is invalid or returns no result, an error message will be returned.\n", " In case of an error, the user is advised to rewrite the query and try again.\n", " \"\"\"\n", " if self.db is None:\n", " return \"Error: Database connection not established. Please set up the connection first.\"\n", " result = self.db.run_no_throw(query)\n", " if not result:\n", " return \"Error: Query failed. Please rewrite your query and try again.\"\n", " return result\n", "\n", " return query_to_database\n", "\n", " def setup_database_connection(self, connection_string: str):\n", " \"\"\"Set up database connection and initialize tools\"\"\"\n", " try:\n", " # Initialize database connection\n", " self.db = SQLDatabase.from_uri(connection_string)\n", " print(\"Database connection successful!\")\n", "\n", " try:\n", " # Initialize toolkit and tools\n", " self.toolkit = SQLDatabaseToolkit(db=self.db, llm=self.llm)\n", " self.tools = self.toolkit.get_tools()\n", " for tool in self.tools:\n", " print(f\"Initialized tool: {tool.name}\")\n", "\n", " # Create instances of the tools\n", " self.list_tables_tool = next((tool for tool in self.tools if tool.name == \"sql_db_list_tables\"), None)\n", " self.sql_db_query = next((tool for tool in self.tools if tool.name == \"sql_db_query\"), None)\n", " self.get_schema_tool = next((tool for tool in self.tools if tool.name == \"sql_db_schema\"), None)\n", "\n", " if not all([self.list_tables_tool, self.sql_db_query, self.get_schema_tool]):\n", " raise ValueError(\"Failed to initialize one or more required database tools\")\n", "\n", " # Initialize workflow and compile it into an app\n", " self.initialize_workflow()\n", "\n", " return self.db\n", "\n", " except Exception as e:\n", " print(f\"Error initializing tools and workflow: {str(e)}\")\n", " raise ValueError(f\"Failed to initialize database tools: {str(e)}\")\n", "\n", " except ImportError as e:\n", " print(f\"Database driver import error: {str(e)}\")\n", " raise ValueError(f\"Missing database driver or invalid database type: {str(e)}\")\n", " except ValueError as e:\n", " print(f\"Invalid connection string or configuration: {str(e)}\")\n", " raise\n", " except Exception as e:\n", " print(f\"Unexpected error during database connection: {str(e)}\")\n", " raise ValueError(f\"Failed to establish database connection: {str(e)}\")\n", "\n", " def initialize_workflow(self):\n", " \"\"\"Initialize the workflow graph\"\"\"\n", "\n", " print(\"Initializing Workflow....\")\n", " # Binding tools with LLM\n", " llm_to_get_schema = self.llm.bind_tools([self.get_schema_tool]) if self.get_schema_tool else None\n", " llm_with_tools = self.llm.bind_tools([self.query_to_database])\n", "\n", " class State(TypedDict):\n", " messages: Annotated[list[AnyMessage], add_messages]\n", " intermediate_answers: list[str] # Store intermediate answers\n", "\n", " class SubmitFinalAnswer(BaseModel):\n", " final_answer: str = Field(..., description=\"The final answer to the user\")\n", "\n", " llm_with_final_answer = self.llm.bind_tools([SubmitFinalAnswer])\n", "\n", " def handle_tool_error(state: State):\n", " error = state.get(\"error\")\n", " tool_calls = state[\"messages\"][-1].tool_calls\n", " # Provide a better user-friendly error message to the user.\n", " return {\"messages\": [ToolMessage(content=f\"I encountered an issue with your last action. The error was: {repr(error)}. I am adjusting my approach. Let's try again.\", tool_call_id=tc[\"id\"], )]}\n", "\n", " def create_node_from_tool_with_fallback(tools: list) -> RunnableWithFallbacks[Any, dict]:\n", " return ToolNode(tools).with_fallbacks([RunnableLambda(handle_tool_error)], exception_key=\"error\")\n", "\n", " list_tables = create_node_from_tool_with_fallback([self.list_tables_tool]) if self.list_tables_tool else None\n", " get_schema = create_node_from_tool_with_fallback([self.get_schema_tool]) if self.get_schema_tool else None\n", " query_database = create_node_from_tool_with_fallback([self.query_to_database])\n", "\n", " query_check_system = \"\"\"You are a SQL expert. Carefully review the SQL query for common mistakes, including:\n", "\n", " Issues with NULL handling (e.g., NOT IN with NULLs)\n", " Improper use of UNION instead of UNION ALL\n", " Incorrect use of BETWEEN for exclusive ranges\n", " Data type mismatches or incorrect casting\n", " Quoting identifiers improperly\n", " Incorrect number of arguments in functions\n", " Errors in JOIN conditions\n", "\n", " If you find any mistakes, rewrite the query to fix them. If it's correct, reproduce it as is.\"\"\"\n", " query_check_prompt = ChatPromptTemplate.from_messages([(\"system\", query_check_system), (\"placeholder\", \"{messages}\")])\n", " check_generated_query = query_check_prompt | llm_with_tools\n", "\n", " def check_the_given_query(state: State):\n", " return {\"messages\": [check_generated_query.invoke({\"messages\": [state[\"messages\"][-1]]})]}\n", "\n", " query_gen_system_prompt = \"\"\"You are a SQL expert with a strong attention to detail.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", " 1. DO NOT call any tool besides SubmitFinalAnswer to submit the final answer.\n", "\n", " When generating the query:\n", "\n", " 2. Output the SQL query that answers the input question without a tool call.\n", "\n", " 3. Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most 5 results.\n", "\n", " 4. You can order the results by a relevant column to return the most interesting examples in the database.\n", "\n", " 5. Never query for all the columns from a specific table, only ask for the relevant columns given the question.\n", "\n", " 6. If you get an error while executing a query, rewrite the query and try again.\n", "\n", " 7. If you get an empty result set, you should try to rewrite the query to get a non-empty result set.\n", "\n", " 8. 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", " 9. 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", " 10. DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database. Do not return any sql query except answer.\"\"\"\n", " query_gen_prompt = ChatPromptTemplate.from_messages([(\"system\", query_gen_system_prompt), (\"placeholder\", \"{messages}\")])\n", " query_generator = query_gen_prompt | llm_with_final_answer\n", "\n", " def first_tool_call(state: State) -> dict[str, list[AIMessage]]:\n", " return {\"messages\": [AIMessage(content=\"\", tool_calls=[{\"name\": \"sql_db_list_tables\", \"args\": {}, \"id\": \"tool_abcd123\"}])]}\n", "\n", " def generation_query(state: State):\n", " message = query_generator.invoke(state)\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", " def should_continue(state: State):\n", " messages = state[\"messages\"]\n", " last_message = messages[-1]\n", "\n", " # Check for max iterations to prevent infinite loops\n", " if len(state.get(\"intermediate_answers\", [])) > 5: # Example limit\n", " print(\"Max iterations reached. Terminating.\")\n", " return END\n", "\n", " if getattr(last_message, \"tool_calls\", None):\n", " # Check if the tool call is SubmitFinalAnswer\n", " if len(last_message.tool_calls) > 0 and last_message.tool_calls[0][\"name\"] == \"SubmitFinalAnswer\":\n", " return END # End the flow\n", " else:\n", " # Wrong tool called, route to error handling\n", " return \"query_gen\" # Or a dedicated error node\n", " elif last_message.content.startswith(\"Error:\"):\n", " return \"query_gen\"\n", " else:\n", " # Attempt to determine if the LLM has provided a final answer\n", " # if LLM has answered route to end.\n", " return \"query_gen\" # back to generate query\n", "\n", " def llm_get_schema(state: State):\n", " response = llm_to_get_schema.invoke(state[\"messages\"])\n", " return {\"messages\": [response]}\n", "\n", " def check_relevance(state: State):\n", " \"\"\"Checks if the query is relevant to the database.\"\"\"\n", " query = state[\"messages\"][-1].content # Get the user's query\n", " print(f\"Checking relevance for query: {query}\")\n", "\n", " relevance_check_prompt = (\n", " \"\"\"You are an expert SQL agent. You MUST respond with ONLY \"relevant\" or \"irrelevant\".\n", "\n", " Is the following query related to a database operation (e.g., querying tables, retrieving data, understanding the database schema)? Answer \"relevant\" only if it is a valid SQL query or a question directly related to the database. Otherwise, answer \"irrelevant\".\n", "\n", " Query: {query}\n", "\n", " Answer with only 'relevant' or 'irrelevant'.\"\"\"\n", " ).format(query=query)\n", "\n", " response = self.llm.invoke([{\"role\": \"user\", \"content\": relevance_check_prompt}])\n", " relevance = response.content.strip().lower()\n", " print(f\"LLM relevance response: {relevance}\")\n", " return {\"relevance\": relevance}\n", "\n", " def answer_irrelevant(state: State):\n", " \"\"\"Answers a question that is not relevant to the database.\"\"\"\n", " query = state[\"messages\"][-1].content\n", " non_relevant_prompt = (\n", " \"\"\"You are an expert SQL agent. You can only assist with questions related to databases.\n", " Please respond politely to the following user query, explaining that you can only answer database-related questions.\n", " Query: {query}\"\"\"\n", " ).format(query=query)\n", " response = self.llm.invoke([{\"role\": \"user\", \"content\": non_relevant_prompt}])\n", " return {\"messages\": [AIMessage(content=response.content)]} # Return as AIMessage\n", "\n", "\n", " def route_after_relevance(state: State):\n", " \"\"\"Routes the workflow based on the relevance check.\"\"\"\n", " relevance = state[\"relevance\"]\n", " if relevance == \"relevant\":\n", " return \"relevant_path\"\n", " else:\n", " return \"irrelevant_path\"\n", "\n", " # Create workflow\n", " workflow = StateGraph(State)\n", " workflow.add_node(\"check_relevance\", check_relevance)\n", " workflow.add_node(\"answer_irrelevant\", answer_irrelevant)\n", " workflow.add_node(\"first_tool_call\", first_tool_call)\n", " workflow.add_node(\"list_tables_tool\", list_tables)\n", " workflow.add_node(\"get_schema_tool\", get_schema)\n", " workflow.add_node(\"model_get_schema\", llm_get_schema)\n", " workflow.add_node(\"query_gen\", generation_query)\n", " workflow.add_node(\"correct_query\", check_the_given_query)\n", " workflow.add_node(\"execute_query\", query_database)\n", "\n", " workflow.add_edge(START, \"check_relevance\")\n", "\n", " workflow.add_conditional_edges(\n", " \"check_relevance\",\n", " route_after_relevance,\n", " {\n", " \"relevant_path\": \"first_tool_call\",\n", " \"irrelevant_path\": \"answer_irrelevant\",\n", " },\n", " )\n", "\n", " workflow.add_edge(\"answer_irrelevant\", END) # End after answering irrelevant query\n", " workflow.add_edge(\"first_tool_call\", \"list_tables_tool\")\n", " workflow.add_edge(\"list_tables_tool\", \"model_get_schema\")\n", " workflow.add_edge(\"model_get_schema\", \"get_schema_tool\")\n", " workflow.add_edge(\"get_schema_tool\", \"query_gen\")\n", " workflow.add_conditional_edges(\n", " \"query_gen\", # Source node\n", " should_continue, # Function that determines the destination\n", " {\n", " END: END, # Destination if should_continue returns \"END\"\n", " \"correct_query\": \"correct_query\", # Destination if should_continue returns \"query_gen\"\n", " \"query_gen\": \"query_gen\", # to generate query from scratch\n", " },\n", " )\n", " workflow.add_edge(\"correct_query\", \"execute_query\")\n", "\n", " workflow.add_conditional_edges(\n", " \"execute_query\",\n", " should_continue,\n", " {\n", " END: END,\n", " \"query_gen\": \"query_gen\",\n", " },\n", " )\n", "\n", " # Compile the workflow into an executable app\n", " self.app = workflow.compile()\n", " display(\n", " Image(\n", " self.app.get_graph().draw_mermaid_png(\n", " draw_method=MermaidDrawMethod.API,\n", " )\n", " )\n", " )\n", "\n", " def execute_query(self, query: str):\n", " \"\"\"Execute a query through the workflow\"\"\"\n", " if self.db is None:\n", " raise ValueError(\"Database connection not established.\")\n", " if self.app is None:\n", " raise ValueError(\"Workflow not initialized.\")\n", "\n", " # First, handle simple queries like \"list tables\" directly\n", " query_lower = query.lower()\n", " if any(phrase in query_lower for phrase in [\"list all the tables\", \"show tables\", \"name of tables\",\n", " \"which tables are present\", \"how many tables\"]):\n", " if self.list_tables_tool:\n", " tables = self.list_tables_tool.invoke(\"\")\n", " return f\"The tables in the database are: {tables}\"\n", " else:\n", " return \"Error: Unable to list tables. The list_tables_tool is not initialized.\"\n", "\n", " # No need to check relevance here anymore, it's handled in the graph\n", "\n", " # Invoke the graph\n", " response = self.app.invoke({\"messages\": [HumanMessage(content=query, role=\"user\")]})\n", "\n", " # Extract the final answer from the last message in the chain.\n", " # Note that with the new 'answer_irrelevant' node, the final message\n", " # might be from that node instead of the SQL query execution path.\n", "\n", " if response and response[\"messages\"]:\n", " last_message = response[\"messages\"][-1]\n", " if isinstance(last_message, AIMessage): # Irrelevant query\n", " return last_message.content\n", " elif getattr(last_message, \"tool_calls\", None): # tool-using path\n", " if (\n", " len(last_message.tool_calls) > 0\n", " and \"args\" in last_message.tool_calls[0]\n", " and \"final_answer\" in last_message.tool_calls[0][\"args\"]\n", " ):\n", " print(last_message.tool_calls[0][\"args\"][\"final_answer\"])\n", " return last_message.tool_calls[0][\"args\"][\"final_answer\"]\n", " else:\n", " return \"Error: Could not extract final answer.\"\n", " else:\n", " return \"Error: Unexpected response format.\"\n", " else:\n", " return \"Error: No response received.\"" ] }, { "cell_type": "code", "execution_count": 152, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "creating _create_query_tool\n", "Database connection successful!\n", "Initialized tool: sql_db_query\n", "Initialized tool: sql_db_schema\n", "Initialized tool: sql_db_list_tables\n", "Initialized tool: sql_db_query_checker\n", "Initializing Workflow....\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 152, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Example usage\n", "agent = SQLAgent()\n", "agent.setup_database_connection(\"mysql+pymysql://admin:9522359448@mydatabase.cf8u2cy0a4h6.us-east-1.rds.amazonaws.com:3306/mydb\")" ] }, { "cell_type": "code", "execution_count": 153, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Checking relevance for query: what is the average salary in employees table ?\n", "LLM relevance response: relevant\n", "\n" ] } ], "source": [ "response = agent.execute_query(\"what is the average salary in employees table ?\")\n", "print(response) # Should return the list of tables\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "import os\n", "import io\n", "from typing import Annotated, Any, TypedDict\n", "from dotenv import load_dotenv\n", "from IPython.display import Image, display\n", "from langchain_core.runnables.graph import MermaidDrawMethod\n", "\n", "from IPython.display import display\n", "from PIL import Image\n", "from typing import Optional\n", "\n", "class SQLAgent:\n", " def __init__(self, model=\"llama3-70b-8192\"):\n", " load_dotenv()\n", " # Initialize instance variables\n", " self.db = None\n", " self.toolkit = None\n", " self.tools = None\n", " self.list_tables_tool = None\n", " self.sql_db_query = None\n", " self.get_schema_tool = None\n", " self.app = None\n", "\n", " # Setting up LLM\n", " self.llm = ChatGroq(model=model, api_key=os.getenv(\"GROQ_API_KEY\"))\n", "\n", " # Register the tool method\n", " self.query_to_database = self._create_query_tool()\n", "\n", " def _create_query_tool(self):\n", " \"\"\"Create the query tool bound to this instance\"\"\"\n", " print(\"creating _create_query_tool\")\n", "\n", " @tool\n", " def query_to_database(query: str) -> str:\n", " \"\"\"\n", " Execute a SQL query against the database and return the result.\n", " If the query is invalid or returns no result, an error message will be returned.\n", " In case of an error, the user is advised to rewrite the query and try again.\n", " \"\"\"\n", " if self.db is None:\n", " return \"Error: Database connection not established. Please set up the connection first.\"\n", " result = self.db.run_no_throw(query)\n", " if not result:\n", " return \"Error: Query failed. Please rewrite your query and try again.\"\n", " return result\n", "\n", " return query_to_database\n", "\n", " def setup_database_connection(self, connection_string: str):\n", " \"\"\"Set up database connection and initialize tools\"\"\"\n", " try:\n", " # Initialize database connection\n", " self.db = SQLDatabase.from_uri(connection_string)\n", " print(\"Database connection successful!\")\n", "\n", " try:\n", " # Initialize toolkit and tools\n", " self.toolkit = SQLDatabaseToolkit(db=self.db, llm=self.llm)\n", " self.tools = self.toolkit.get_tools()\n", " for tool in self.tools:\n", " print(f\"Initialized tool: {tool.name}\")\n", "\n", " # Create instances of the tools\n", " self.list_tables_tool = next((tool for tool in self.tools if tool.name == \"sql_db_list_tables\"), None)\n", " self.sql_db_query = next((tool for tool in self.tools if tool.name == \"sql_db_query\"), None)\n", " self.get_schema_tool = next((tool for tool in self.tools if tool.name == \"sql_db_schema\"), None)\n", "\n", " if not all([self.list_tables_tool, self.sql_db_query, self.get_schema_tool]):\n", " raise ValueError(\"Failed to initialize one or more required database tools\")\n", "\n", " # Initialize workflow and compile it into an app\n", " self.initialize_workflow()\n", "\n", " return self.db\n", "\n", " except Exception as e:\n", " print(f\"Error initializing tools and workflow: {str(e)}\")\n", " raise ValueError(f\"Failed to initialize database tools: {str(e)}\")\n", "\n", " except ImportError as e:\n", " print(f\"Database driver import error: {str(e)}\")\n", " raise ValueError(f\"Missing database driver or invalid database type: {str(e)}\")\n", " except ValueError as e:\n", " print(f\"Invalid connection string or configuration: {str(e)}\")\n", " raise\n", " except Exception as e:\n", " print(f\"Unexpected error during database connection: {str(e)}\")\n", " raise ValueError(f\"Failed to establish database connection: {str(e)}\")\n", "\n", " def initialize_workflow(self):\n", " \"\"\"Initialize the workflow graph\"\"\"\n", "\n", " print(\"Initializing Workflow....\")\n", " # Binding tools with LLM\n", " llm_to_get_schema = self.llm.bind_tools([self.get_schema_tool]) if self.get_schema_tool else None\n", " llm_with_tools = self.llm.bind_tools([self.query_to_database])\n", "\n", " class State(TypedDict):\n", " messages: Annotated[list[AnyMessage], add_messages]\n", " intermediate_answers: list[str] # Store intermediate answers\n", "\n", " class SubmitFinalAnswer(BaseModel):\n", " final_answer: str = Field(..., description=\"The final answer to the user\")\n", "\n", " llm_with_final_answer = self.llm.bind_tools([SubmitFinalAnswer])\n", "\n", " def handle_tool_error(state: State):\n", " error = state.get(\"error\")\n", " tool_calls = state[\"messages\"][-1].tool_calls\n", " # Provide a better user-friendly error message to the user.\n", " return {\"messages\": [ToolMessage(content=f\"I encountered an issue with your last action. The error was: {repr(error)}. I am adjusting my approach. Let's try again.\", tool_call_id=tc[\"id\"], )]}\n", "\n", " def create_node_from_tool_with_fallback(tools: list) -> RunnableWithFallbacks[Any, dict]:\n", " return ToolNode(tools).with_fallbacks([RunnableLambda(handle_tool_error)], exception_key=\"error\")\n", "\n", " list_tables = create_node_from_tool_with_fallback([self.list_tables_tool]) if self.list_tables_tool else None\n", " get_schema = create_node_from_tool_with_fallback([self.get_schema_tool]) if self.get_schema_tool else None\n", " query_database = create_node_from_tool_with_fallback([self.query_to_database])\n", "\n", " query_check_system = \"\"\"You are a SQL expert. Carefully review the SQL query for common mistakes, including:\n", "\n", " Issues with NULL handling (e.g., NOT IN with NULLs)\n", " Improper use of UNION instead of UNION ALL\n", " Incorrect use of BETWEEN for exclusive ranges\n", " Data type mismatches or incorrect casting\n", " Quoting identifiers improperly\n", " Incorrect number of arguments in functions\n", " Errors in JOIN conditions\n", "\n", " If you find any mistakes, rewrite the query to fix them. If it's correct, reproduce it as is.\"\"\"\n", " query_check_prompt = ChatPromptTemplate.from_messages([(\"system\", query_check_system), (\"placeholder\", \"{messages}\")])\n", " check_generated_query = query_check_prompt | llm_with_tools\n", "\n", " def check_the_given_query(state: State):\n", " return {\"messages\": [check_generated_query.invoke({\"messages\": [state[\"messages\"][-1]]})]}\n", "\n", " query_gen_system_prompt = \"\"\"You are a SQL expert with a strong attention to detail.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", " 1. DO NOT call any tool besides SubmitFinalAnswer to submit the final answer.\n", "\n", " When generating the query:\n", "\n", " 2. Output the SQL query that answers the input question without a tool call.\n", "\n", " 3. Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most 5 results.\n", "\n", " 4. You can order the results by a relevant column to return the most interesting examples in the database.\n", "\n", " 5. Never query for all the columns from a specific table, only ask for the relevant columns given the question.\n", "\n", " 6. If you get an error while executing a query, rewrite the query and try again.\n", "\n", " 7. If you get an empty result set, you should try to rewrite the query to get a non-empty result set.\n", "\n", " 8. 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", " 9. 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", " 10. DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database. Do not return any sql query except answer.\"\"\"\n", " query_gen_prompt = ChatPromptTemplate.from_messages([(\"system\", query_gen_system_prompt), (\"placeholder\", \"{messages}\")])\n", " query_generator = query_gen_prompt | llm_with_final_answer\n", "\n", " def first_tool_call(state: State) -> dict[str, list[AIMessage]]:\n", " return {\"messages\": [AIMessage(content=\"\", tool_calls=[{\"name\": \"sql_db_list_tables\", \"args\": {}, \"id\": \"tool_abcd123\"}])]}\n", "\n", " def generation_query(state: State):\n", " message = query_generator.invoke(state)\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", " def should_continue(state: State):\n", " messages = state[\"messages\"]\n", " last_message = messages[-1]\n", "\n", " # Check for max iterations to prevent infinite loops\n", " if len(state.get(\"intermediate_answers\", [])) > 5: # Example limit\n", " print(\"Max iterations reached. Terminating.\")\n", " return END\n", "\n", " if getattr(last_message, \"tool_calls\", None):\n", " # Check if the tool call is SubmitFinalAnswer\n", " if len(last_message.tool_calls) > 0 and last_message.tool_calls[0][\"name\"] == \"SubmitFinalAnswer\":\n", " return END # End the flow\n", " else:\n", " # Wrong tool called, route to error handling\n", " return \"query_gen\" # Or a dedicated error node\n", " elif last_message.content.startswith(\"Error:\"):\n", " return \"query_gen\"\n", " else:\n", " # Attempt to determine if the LLM has provided a final answer\n", " # if LLM has answered route to end.\n", " return \"query_gen\" #back to generate query\n", "\n", " def llm_get_schema(state: State):\n", " response = llm_to_get_schema.invoke(state[\"messages\"])\n", " return {\"messages\": [response]}\n", "\n", " # Create workflow\n", " workflow = StateGraph(State)\n", " workflow.add_node(\"first_tool_call\", first_tool_call)\n", " workflow.add_node(\"list_tables_tool\", list_tables)\n", " workflow.add_node(\"get_schema_tool\", get_schema)\n", " workflow.add_node(\"model_get_schema\", llm_get_schema)\n", " workflow.add_node(\"query_gen\", generation_query)\n", " workflow.add_node(\"correct_query\", check_the_given_query)\n", " workflow.add_node(\"execute_query\", query_database)\n", "\n", " workflow.add_edge(START, \"first_tool_call\")\n", " workflow.add_edge(\"first_tool_call\", \"list_tables_tool\")\n", " workflow.add_edge(\"list_tables_tool\", \"model_get_schema\")\n", " workflow.add_edge(\"model_get_schema\", \"get_schema_tool\")\n", " workflow.add_edge(\"get_schema_tool\", \"query_gen\")\n", " workflow.add_conditional_edges(\n", " \"query_gen\", # Source node\n", " should_continue, # Function that determines the destination\n", " {\n", " END: END, # Destination if should_continue returns \"END\"\n", " \"correct_query\": \"correct_query\", # Destination if should_continue returns \"query_gen\"\n", " \"query_gen\": \"query_gen\", # to generate query from scratch\n", " },\n", " )\n", " workflow.add_edge(\"correct_query\", \"execute_query\")\n", "\n", " workflow.add_conditional_edges(\n", " \"execute_query\",\n", " should_continue,\n", " {\n", " END: END,\n", " \"query_gen\": \"query_gen\",\n", " },\n", " )\n", "\n", " # Compile the workflow into an executable app\n", " self.app = workflow.compile()\n", "\n", " # Compile the workflow into an executable app\n", " # self.app = workflow.compile()\n", " # Display the workflow graph\n", " # display(\n", " # Image(\n", " # self.app.get_graph().draw_mermaid_png(\n", " # draw_method=MermaidDrawMethod.API,\n", " # )\n", " # )\n", " # )\n", "\n", " # image_path = \"workflow_graph.png\"\n", " # self.app.get_graph().draw_mermaid_png().save(image_path)\n", "\n", " # Generate the graph image as bytes\n", " image_bytes = self.app.get_graph().draw_mermaid_png()\n", "\n", " # Convert bytes to an Image object\n", " image = Image.open(io.BytesIO(image_bytes))\n", "\n", " # Save the image to a file\n", " image_path = \"workflow_graph.png\"\n", " image.save(image_path)\n", "\n", "\n", " def save_workflow_graph(self, image_path=\"workflow_graph.png\"):\n", " \"\"\"Save the workflow graph as an image\"\"\"\n", " if self.app is None:\n", " raise ValueError(\"Workflow not initialized. Please set up the connection first.\")\n", "\n", " # Generate the graph image as bytes\n", " image_bytes = self.app.get_graph().draw_mermaid_png()\n", "\n", " # Convert bytes to an Image object\n", " image = Image.open(io.BytesIO(image_bytes))\n", "\n", " # Save the image to a file\n", " image.save(image_path)\n", " print(f\"Workflow graph saved to {image_path}\")\n", "\n", " def is_query_relevant(self, query: str) -> bool:\n", " \"\"\"Check if the query is relevant to the database using the LLM.\"\"\"\n", "\n", " # Retrieve the schema of the relevant tables\n", " if self.list_tables_tool:\n", " relevant_tables = self.list_tables_tool.invoke(\"\")\n", " # print(relevant_tables)\n", " table_list = relevant_tables.split(\", \")\n", " print(table_list)\n", " # print(agent.get_schema_tool.invoke(table_list[0]))\n", " schema = \"\"\n", " for table in table_list:\n", " schema += self.get_schema_tool.invoke(table)\n", "\n", " print(schema)\n", "\n", " # if self.get_schema_tool:\n", " # schema_response = self.get_schema_tool.invoke({})\n", " # table_schema = schema_response.content # Assuming this returns the schema as a string\n", "\n", " relevance_check_prompt = (\n", " \"\"\"You are an expert SQL agent which takes user query in Natural language and find out it have releavnce with the given schema or not. Please determine if the following query is related to a database.Here is the schema of the tables present in database:\\n{schema}\\n\\n. If the query related to given schema respond with 'yes'. Here is the query: {query}. Answer with only 'yes' or 'no'.\"\"\"\n", " ).format(schema=relevant_tables, query=query)\n", "\n", " response = self.llm.invoke([{\"role\": \"user\", \"content\": relevance_check_prompt}])\n", "\n", " # Assuming the LLM returns a simple 'yes' or 'no'\n", " return response.content == \"yes\"\n", "\n", " def execute_query(self, query: str):\n", " \"\"\"Execute a query through the workflow\"\"\"\n", " if self.db is None:\n", " raise ValueError(\"Database connection not established.\")\n", " if self.app is None:\n", " raise ValueError(\"Workflow not initialized.\")\n", "\n", " # First, handle simple queries like \"list tables\" directly\n", " query_lower = query.lower()\n", " if any(phrase in query_lower for phrase in [\"list all the tables\", \"show tables\", \"name of tables\",\n", " \"which tables are present\", \"how many tables\"]):\n", " if self.list_tables_tool:\n", " tables = self.list_tables_tool.invoke(\"\")\n", " return f\"The tables in the database are: {tables}\"\n", " else:\n", " return \"Error: Unable to list tables. The list_tables_tool is not initialized.\"\n", "\n", " #Now check relevance, stop the flow if not relevant\n", " if not self.is_query_relevant(query):\n", " print(\"Not relevant to the database.\")\n", " non_relevant_prompt = (\n", " \"\"\"You are an expert SQL agent created by Kshitij Kumrawat. You can only assist with questions related to databases so repond the user with the following example resonse and Do not answer any questions that are not related to databases.: \n", " Please ask a question that pertains to database operations, such as querying tables, retrieving data, or understanding the database schema. \"\"\"\n", " )\n", " response = self.llm.invoke([{\"role\": \"user\", \"content\": non_relevant_prompt}])\n", " return response.content\n", "\n", " # If relevant, proceed with the SQL workflow\n", " response = self.app.invoke({\"messages\": [HumanMessage(content=query, role=\"user\")]})\n", "\n", " # More robust final answer extraction\n", " if (\n", " response\n", " and response[\"messages\"]\n", " and response[\"messages\"][-1].tool_calls\n", " and len(response[\"messages\"][-1].tool_calls) > 0\n", " and \"args\" in response[\"messages\"][-1].tool_calls[0]\n", " and \"final_answer\" in response[\"messages\"][-1].tool_calls[0][\"args\"]\n", " ):\n", " return response[\"messages\"][-1].tool_calls[0][\"args\"][\"final_answer\"]\n", " else:\n", " return \"Error: Could not extract final answer.\"" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "creating _create_query_tool\n", "Database connection successful!\n", "Initialized tool: sql_db_query\n", "Initialized tool: sql_db_schema\n", "Initialized tool: sql_db_list_tables\n", "Initialized tool: sql_db_query_checker\n", "Initializing Workflow....\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Example usage\n", "agent = SQLAgent()\n", "agent.setup_database_connection(\"mysql+pymysql://admin:9522359448@mydatabase.cf8u2cy0a4h6.us-east-1.rds.amazonaws.com:3306/mydb\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "ename": "AttributeError", "evalue": "type object 'Image' has no attribute 'open'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[6], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43magent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave_workflow_graph\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", "Cell \u001b[1;32mIn[4], line 276\u001b[0m, in \u001b[0;36mSQLAgent.save_workflow_graph\u001b[1;34m(self, image_path)\u001b[0m\n\u001b[0;32m 273\u001b[0m image_bytes \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mapp\u001b[38;5;241m.\u001b[39mget_graph()\u001b[38;5;241m.\u001b[39mdraw_mermaid_png()\n\u001b[0;32m 275\u001b[0m \u001b[38;5;66;03m# Convert bytes to an Image object\u001b[39;00m\n\u001b[1;32m--> 276\u001b[0m image \u001b[38;5;241m=\u001b[39m \u001b[43mImage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen\u001b[49m(io\u001b[38;5;241m.\u001b[39mBytesIO(image_bytes))\n\u001b[0;32m 278\u001b[0m \u001b[38;5;66;03m# Save the image to a file\u001b[39;00m\n\u001b[0;32m 279\u001b[0m image\u001b[38;5;241m.\u001b[39msave(image_path)\n", "\u001b[1;31mAttributeError\u001b[0m: type object 'Image' has no attribute 'open'" ] } ], "source": [ "agent.save_workflow_graph(\"workflow_graph.png\")" ] }, { "cell_type": "code", "execution_count": 160, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['customers', 'employees', 'orders']\n", "\n", "CREATE TABLE customers (\n", "\tcustomer_id BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\tphone VARCHAR(50), \n", "\tPRIMARY KEY (customer_id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from customers table:\n", "customer_id\tfirst_name\tlast_name\temail\tphone\n", "1\tJohn\tDoe\tjohn.doe@example.com\t1234567890\n", "2\tJane\tSmith\tjane.smith@example.com\t9876543210\n", "3\tEmily\tDavis\temily.davis@example.com\t4567891230\n", "*/\n", "CREATE TABLE employees (\n", "\tid BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\thire_date DATE NOT NULL, \n", "\tsalary DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from employees table:\n", "id\tfirst_name\tlast_name\temail\thire_date\tsalary\n", "1\tJohn\tDoe\tjohnD@abc.com\t2020-01-01\t50000.00\n", "2\tJane\tDoe\tJaneDabc.com\t2020-05-01\t60000.00\n", "3\tTom\tSmith\ttoms@abc.com\t2020-03-01\t70000.00\n", "*/\n", "CREATE TABLE orders (\n", "\torder_id BIGINT NOT NULL, \n", "\torder_date DATE NOT NULL, \n", "\tcustomer_id BIGINT NOT NULL, \n", "\tamount DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (order_id), \n", "\tCONSTRAINT orders_ibfk_1 FOREIGN KEY(customer_id) REFERENCES customers (customer_id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from orders table:\n", "order_id\torder_date\tcustomer_id\tamount\n", "1\t2020-01-01\t1\t1000.00\n", "2\t2020-02-01\t2\t2000.00\n", "3\t2020-03-01\t3\t3000.00\n", "*/\n", "Not relevant to the database.\n", "Please ask a question that pertains to database operations, such as querying tables, retrieving data, or understanding the database schema. I'm here to help with all your database-related queries!\n" ] } ], "source": [ "response = agent.execute_query(\"Hi\")\n", "print(response) # Should return the list of tables\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class SQLAgent:# orginal\n", " def __init__(self, model=\"llama3-70b-8192\"):\n", " load_dotenv()\n", " # Initialize instance variables\n", " self.db = None\n", " self.toolkit = None\n", " self.tools = None\n", " self.list_tables_tool = None\n", " self.sql_db_query = None\n", " self.get_schema_tool = None\n", " self.app = None\n", " \n", " # Setting up LLM\n", " self.llm = ChatGroq(model=model, api_key=os.getenv(\"GROQ_API_KEY\"))\n", " \n", " # Register the tool method\n", " self.query_to_database = self._create_query_tool()\n", "\n", " def _create_query_tool(self):\n", " \"\"\"Create the query tool bound to this instance\"\"\"\n", " print(\"creating _create_query_tool\")\n", " @tool\n", " def query_to_database(query: str) -> str:\n", " \"\"\"\n", " Execute a SQL query against the database and return the result.\n", " If the query is invalid or returns no result, an error message will be returned.\n", " In case of an error, the user is advised to rewrite the query and try again.\n", " \"\"\"\n", " if self.db is None:\n", " return \"Error: Database connection not established. Please set up the connection first.\"\n", " result = self.db.run_no_throw(query)\n", " if not result:\n", " return \"Error: Query failed. Please rewrite your query and try again.\"\n", " return result\n", " \n", " return query_to_database\n", "\n", " def setup_database_connection(self, connection_string: str):\n", " \"\"\"Set up database connection and initialize tools\"\"\"\n", " try:\n", " # Initialize database connection\n", " self.db = SQLDatabase.from_uri(connection_string)\n", " print(\"Database connection successful!\")\n", "\n", " try:\n", " # Initialize toolkit and tools\n", " self.toolkit = SQLDatabaseToolkit(db=self.db, llm=self.llm)\n", " self.tools = self.toolkit.get_tools()\n", " for tool in self.tools:\n", " print(f\"Initialized tool: {tool.name}\")\n", "\n", " # Create instances of the tools\n", " self.list_tables_tool = next((tool for tool in self.tools if tool.name == \"sql_db_list_tables\"), None)\n", " self.sql_db_query = next((tool for tool in self.tools if tool.name == \"sql_db_query\"), None)\n", " self.get_schema_tool = next((tool for tool in self.tools if tool.name == \"sql_db_schema\"), None)\n", "\n", " if not all([self.list_tables_tool, self.sql_db_query, self.get_schema_tool]):\n", " raise ValueError(\"Failed to initialize one or more required database tools\")\n", "\n", " # Initialize workflow and compile it into an app\n", " self.initialize_workflow()\n", " \n", " return self.db\n", "\n", " except Exception as e:\n", " print(f\"Error initializing tools and workflow: {str(e)}\")\n", " raise ValueError(f\"Failed to initialize database tools: {str(e)}\")\n", "\n", " except ImportError as e:\n", " print(f\"Database driver import error: {str(e)}\")\n", " raise ValueError(f\"Missing database driver or invalid database type: {str(e)}\")\n", " except ValueError as e:\n", " print(f\"Invalid connection string or configuration: {str(e)}\")\n", " raise\n", " except Exception as e:\n", " print(f\"Unexpected error during database connection: {str(e)}\")\n", " raise ValueError(f\"Failed to establish database connection: {str(e)}\")\n", "\n", " def initialize_workflow(self):\n", " \"\"\"Initialize the workflow graph\"\"\"\n", " \n", " print(\"Intializing Workflow....\")\n", " # Binding tools with LLM\n", " llm_to_get_schema = self.llm.bind_tools([self.get_schema_tool]) if self.get_schema_tool else None\n", " llm_with_tools = self.llm.bind_tools([self.query_to_database])\n", "\n", " class State(TypedDict):\n", " messages: Annotated[list[AnyMessage], add_messages]\n", "\n", " class SubmitFinalAnswer(BaseModel):\n", " final_answer: str = Field(..., description=\"The final answer to the user\")\n", "\n", " llm_with_final_answer = self.llm.bind_tools([SubmitFinalAnswer])\n", "\n", " def handle_tool_error(state: State):\n", " error = state.get(\"error\")\n", " tool_calls = state[\"messages\"][-1].tool_calls\n", " return {\"messages\": [ToolMessage(content=f\"Error: {repr(error)}\\n please fix your mistakes.\", tool_call_id=tc[\"id\"],) for tc in tool_calls]}\n", "\n", " def create_node_from_tool_with_fallback(tools: list) -> RunnableWithFallbacks[Any, dict]:\n", " return ToolNode(tools).with_fallbacks([RunnableLambda(handle_tool_error)], exception_key=\"error\")\n", "\n", " list_tables = create_node_from_tool_with_fallback([self.list_tables_tool]) if self.list_tables_tool else None\n", " get_schema = create_node_from_tool_with_fallback([self.get_schema_tool]) if self.get_schema_tool else None\n", " query_database = create_node_from_tool_with_fallback([self.query_to_database])\n", "\n", " query_check_system = \"\"\"You are a SQL expert. Carefully review the SQL query for common mistakes, including:\n", "\n", " Issues with NULL handling (e.g., NOT IN with NULLs)\n", " Improper use of UNION instead of UNION ALL\n", " Incorrect use of BETWEEN for exclusive ranges\n", " Data type mismatches or incorrect casting\n", " Quoting identifiers improperly\n", " Incorrect number of arguments in functions\n", " Errors in JOIN conditions\n", "\n", " If you find any mistakes, rewrite the query to fix them. If it's correct, reproduce it as is.\"\"\"\n", " query_check_prompt = ChatPromptTemplate.from_messages([(\"system\", query_check_system), (\"placeholder\", \"{messages}\")])\n", " check_generated_query = query_check_prompt | llm_with_tools\n", " \n", " def check_the_given_query(state: State):\n", " return {\"messages\": [check_generated_query.invoke({\"messages\": [state[\"messages\"][-1]]})]}\n", "\n", " query_gen_system_prompt = \"\"\"You are a SQL expert with a strong attention to detail.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", " 1. DO NOT call any tool besides SubmitFinalAnswer to submit the final answer.\n", "\n", " When generating the query:\n", "\n", " 2. Output the SQL query that answers the input question without a tool call.\n", "\n", " 3. Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most 5 results.\n", "\n", " 4. You can order the results by a relevant column to return the most interesting examples in the database.\n", "\n", " 5. Never query for all the columns from a specific table, only ask for the relevant columns given the question.\n", "\n", " 6. If you get an error while executing a query, rewrite the query and try again.\n", "\n", " 7. If you get an empty result set, you should try to rewrite the query to get a non-empty result set.\n", "\n", " 8. 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", " 9. 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", " 10. DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database. Do not return any sql query except answer.\"\"\"\n", " query_gen_prompt = ChatPromptTemplate.from_messages([(\"system\", query_gen_system_prompt), (\"placeholder\", \"{messages}\")])\n", " query_generator = query_gen_prompt | llm_with_final_answer\n", "\n", " def first_tool_call(state: State) -> dict[str, list[AIMessage]]:\n", " return {\"messages\": [AIMessage(content=\"\", tool_calls=[{\"name\": \"sql_db_list_tables\", \"args\": {}, \"id\": \"tool_abcd123\"}])]}\n", "\n", " def generation_query(state: State):\n", " message = query_generator.invoke(state)\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", " def should_continue(state: State):\n", " messages = state[\"messages\"]\n", " last_message = messages[-1]\n", " if getattr(last_message, \"tool_calls\", None):\n", " return END\n", " elif last_message.content.startswith(\"Error:\"):\n", " return \"query_gen\"\n", " else:\n", " return \"correct_query\"\n", "\n", " def llm_get_schema(state: State):\n", " response = llm_to_get_schema.invoke(state[\"messages\"])\n", " return {\"messages\": [response]}\n", "\n", " # Create workflow\n", " workflow = StateGraph(State)\n", " workflow.add_node(\"first_tool_call\", first_tool_call)\n", " workflow.add_node(\"list_tables_tool\", list_tables)\n", " workflow.add_node(\"get_schema_tool\", get_schema)\n", " workflow.add_node(\"model_get_schema\", llm_get_schema)\n", " workflow.add_node(\"query_gen\", generation_query)\n", " workflow.add_node(\"correct_query\", check_the_given_query)\n", " workflow.add_node(\"execute_query\", query_database)\n", "\n", " workflow.add_edge(START, \"first_tool_call\")\n", " workflow.add_edge(\"first_tool_call\", \"list_tables_tool\")\n", " workflow.add_edge(\"list_tables_tool\", \"model_get_schema\")\n", " workflow.add_edge(\"model_get_schema\", \"get_schema_tool\")\n", " workflow.add_edge(\"get_schema_tool\", \"query_gen\")\n", " workflow.add_conditional_edges(\"query_gen\", should_continue, {END: END, \"correct_query\": \"correct_query\"})\n", " workflow.add_edge(\"correct_query\", \"execute_query\")\n", " workflow.add_edge(\"execute_query\", \"query_gen\")\n", "\n", " # Compile the workflow into an executable app\n", " self.app = workflow.compile()\n", " \n", " def save_workflow_graph(self, image_path=\"workflow_graph.png\"):\n", " \"\"\"Save the workflow graph as an image\"\"\"\n", " if self.app is None:\n", " raise ValueError(\"Workflow not initialized. Please set up the connection first.\")\n", " \n", " # Generate the graph image as bytes\n", " image_bytes = self.app.get_graph().draw_mermaid_png()\n", "\n", " # Convert bytes to an Image object\n", " image = Image.open(io.BytesIO(image_bytes))\n", "\n", " # Save the image to a file\n", " image.save(image_path)\n", " print(f\"Workflow graph saved to {image_path}\")\n", " \n", " def is_query_relevant(self, query: str) -> bool:\n", " \"\"\"Check if the query is relevant to the database using the LLM.\"\"\"\n", " \n", " # Retrieve the schema of the relevant tables\n", " if self.list_tables_tool:\n", " relevant_tables = self.list_tables_tool.invoke(\"\")\n", " # print(relevant_tables)\n", " table_list= relevant_tables.split(\", \")\n", " print(table_list)\n", " # print(agent.get_schema_tool.invoke(table_list[0]))\n", " schema = \"\"\n", " for table in table_list:\n", " schema+= self.get_schema_tool.invoke(table)\n", "\n", " print(schema)\n", " \n", " # if self.get_schema_tool:\n", " # schema_response = self.get_schema_tool.invoke({})\n", " # table_schema = schema_response.content # Assuming this returns the schema as a string\n", "\n", " relevance_check_prompt = (\n", " \"\"\"You are an expert SQL agent which takes user query in Natural language and find out it have releavnce with the given schema or not. Please determine if the following query is related to a database.Here is the schema of the tables present in database:\\n{schema}\\n\\n. If the query related to given schema respond with 'yes'. Here is the query: {query}. Answer with only 'yes' or 'no'.\"\"\"\n", " ).format(schema=relevant_tables, query=query)\n", " \n", " response = self.llm.invoke([{\"role\": \"user\", \"content\": relevance_check_prompt}])\n", " \n", " # Assuming the LLM returns a simple 'yes' or 'no'\n", " return response.content == \"yes\"\n", "\n", " \n", " def execute_query(self, query: str):\n", " \"\"\"Execute a query through the workflow\"\"\"\n", " if self.db is None:\n", " raise ValueError(\"Database connection not established. Please set up the connection first.\")\n", " if self.app is None:\n", " raise ValueError(\"Workflow not initialized. Please set up the connection first.\")\n", " \n", " # Check if the query is relevant to the database\n", " if not self.is_query_relevant(query):\n", " print(\"Not relevent to database.\")\n", " # If not relevant, let the LLM answer the question directly\n", " non_relevant_prompt = (\n", " \"\"\"You are an expert SQL agent created by Kshitij Kumrawat. You can only assist with questions related to databases so repond the user with the following example resonse and Do not answer any questions that are not related to databases.: \n", " Please ask a question that pertains to database operations, such as querying tables, retrieving data, or understanding the database schema. \"\"\"\n", " )\n", " \n", " # Invoke the LLM with the non-relevant prompt\n", " response = self.llm.invoke([{\"role\": \"user\", \"content\": non_relevant_prompt}])\n", " # print(response.content)\n", " return response.content\n", " \n", " # If relevant, proceed with the SQL workflow\n", " response = self.app.invoke({\"messages\": [(\"user\", query)]})\n", " return response[\"messages\"][-1].tool_calls[0][\"args\"][\"final_answer\"]" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [], "source": [ "from IPython.display import Image, display\n", "from langchain_core.runnables.graph import MermaidDrawMethod\n", "\n", "# display(\n", "# Image(\n", "# app.get_graph().draw_mermaid_png(\n", "# draw_method=MermaidDrawMethod.API,\n", "# )\n", "# )\n", "# )" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "creating _create_query_tool\n", "Database connection successful!\n", "Initialized tool: sql_db_query\n", "Initialized tool: sql_db_schema\n", "Initialized tool: sql_db_list_tables\n", "Initialized tool: sql_db_query_checker\n", "Initializing Workflow....\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAALoCAIAAACvfoYhAAAAAXNSR0IArs4c6QAAIABJREFUeJzs3XdAU9ffBvCTSQIkEAhDtoADEQQLVq1bcCAOHGgVZ63aOmod1Vq11tZZbd27TtTWPXCgghMFt3XvhchMIITs8f6RvsgPEUGBG7zP569wc++534TwcO7IOQyj0UgAAOiNSXUBAADUQxQCACAKAQAQhQAAiEIAAIIoBAAghBA21QUAlCzjubpApiuQ6fRao1ppoLqcMuHymVwe00rItrJhO7hyqS4HygFRCObl4VX5k5vyJ7cKvOpZGQ1GSxu2yJHLZFFdVpllPFcVyHQWfNbL+4qa9a18Aq09/SypLgrej4FbrMFM3L4gOx+X7eVn5eVv5V3fisVhUF3RR1HK9U9uFaQ/VaY/VzftbF/T34rqiqA0iEKgXs5rTfzm9BpevCadxTzLT+38tSRdcz4uh8VmtO/vXI26t3SDKASKPbiaf/m4NPJrF6Hdp3y6JvOleteilz3Huju6W1BdC5QAUQhUenFPcfeSrH1/Z6oLqSI7/njZfoCzjZhDdSFQHKIQKHP9dO7rJ6qOg+mSgyY7/njZJFLsXptPdSHwPz618zJQXaQ+VD67XUC3HCSERI9zP7YlXSnXU10I/A9EIVBAJTdcOynt9q0r1YVQI+ZHzxPbMqmuAv4HohAocHZfVu2GAqqroIyFJdO+BvdKgpTqQuANRCFUtZzXmqxX6joh9I1CQkjTzvYX4nKorgLeQBRCVbuVlNc8yqFq9iWXy+/du0fV5qVr1cvxakJuJTUO5YUohCpl0BtvJ+dV2fXTPn367N+/n6rNS+dWi38nJa+SGofyQhRClXpys8C7vnWV7U6j0XzYhqabzD5487KwdeAQQqSZ2srbBZQdohCqVNoTZa3KuWCycePGiIiIZs2affXVVxcvXiSEREZGSiSSnTt3hoSEREZGmqJt+fLlXbp0+fzzzzt16rRixQq9/r+bWubNm9euXbszZ85ERUWFhIRcunTp7c0rXN1Q4cv7ispoGcrrU/6qE5ih9GequiHCCm/24sWLy5Yt69ChQ9OmTc+fP69QKAgh8+fPHzVq1GeffdavXz8ul0sIYbFYKSkpLVq0cHNzu3///vr164VCYUxMjKkRuVy+YsWKyZMnK5XK0NDQtzevcHxrVuYLVWW0DOWFKIQqVSDTWdlU/JgEaWlphJDo6OjAwMCIiAjTwnr16rHZbLFYHBQUZFrCYrE2bdrEYPw35k1qampiYmJhFGo0mqlTp9avX/9dm1c4Kxu2XKarpMahXBCFUKUKZHpLYcV/6po1ayYUCqdNmzZx4sRmzZqVsqZEIlm7dm1ycrJMJiOECARvjtZ5PF5hDlYNKyFLIcPXTswCzhVCFTISCz6LUQnjEIrF4vXr13t6eo4dO/arr77KzCz5uxw5OTn9+vW7ePHiN998s3TpUj8/v8JzhYQQS8uqHmOVxWKw2dV7WMZPBqIQqhCDMJlEkV8p/SAvL68lS5asXLny0aNHM2bMKFxedMCR3bt3SySSFStWtG/f3t/f39n5/d+ArtTxSuR5Oo4F/gbNAn4NUKWshCxF5ZwdM934Ehoa2rx588L7ovl8fnZ2duE6ubm5IpGoMAFzc3NLT7pim1e4ApnOUojRXM0CzhVClarhbamUV/ycTbdv3540aVJ0dLSlpeX58+fr1atnWh4cHHz06NGNGzcKhcLAwMCQkJAdO3asXLmyQYMGiYmJSUlJBoMhNzfX1ta2xGaLbe7r61uxZWvVRrELRnI1C6yihxIAlU0h0724p6hZv4In+sjLy3vw4MGxY8cuXrzYsGHDKVOmWFtbE0ICAwPv379/+PDhe/fu+fv7t2nTxmAw7Ny5MyEhwd3dfdq0adeuXVMoFCEhIUlJSU+fPu3fv3/RZottXrNmzYot+/TurIBmtlY26JFQD0O3QpVSFehj5zwf+ps31YVQTyHT/73gxZCZFRyv8GHw7wiqFM+K5VnXKvOlupQpPubNm3fkyJG3l/v5+d29e7fETTZs2FDhXbZizp07N3Xq1BKfcnNzS01NfXv5pk2bPD0939Vg6kNlvc9tKrRG+HDoFUJVe/lAeSVB0u2bd47bmpuba/q6SDEMxjs/ro6Ojmx25f5fV6lUEomkxKfeVVjpVa2f/rTPBA9cNjETiEKgwL6Vrz5ra0fn+T2un87Nl+iaR4mpLgT+g5tpgAJfdHG4d1FGdRVUenZb0TQSOWhGEIVAAQdXrosP/+QOms7vsWtx6ucd7ViYAdScIAqBGv5NhEwWI+VwyWffPmHxmzPqhghq1ORRXQj8D5wrBCpdO5mrVRsbdRBRXUgVObYlo26o0KMufU+Smi30CoFKwa1t9XpD/OZ0qgupdFqN8e8FL93r8JGD5gm9QqDew6vy03uyQtuJGrQo+Qtw1d2FQzmpD5Wtejo4uOFrdmYKUQhmQacxno/LfnRD3qCFbU1/KzvnShk1uoqlP1OlPlImH8pp0sn+szC6nASophCFYEYKZPqbZ3Of3CrQaY0+gdZMFrESsgV2HL2u4kdwqAwMwsiXahX5egaD3E6W2Yg5tYKtg1rYEoxJaPYQhWCO8rK16U9V+bk6Rb6OyWTk51bwuF5Pnz61tLR0cnKq2GathWwGk1gKWQIRx60Wn2+Nb5JUG/gOMpgjGzHHRlyJ993NmbPB0adWx54NKm8XUL3gCjIAAKIQAABRCPRka2vL4+H7HvAGohDoKDc3V6XCXOzwBqIQ6IjL5bJYuLwLbyAKgY40Gk3RGZABEIVAR5aWlhwOBsmCNxCFQEcKhUKr1VJdBZgRRCHQkUgkwhVkKApRCHQklUpxBRmKQhQCACAKgZZ4PF5lTxYK1QuiEOhIpVLpdBU82g1Ua4hCoCM+n49brKEoRCHQkVKpxC3WUBSiEAAAUQi0JBQKudxPYfoUqCiIQqAjmUym0WiorgLMCKIQAABRCLRka2vL52NqdngDUQh0lJubq1Qqqa4CzAiiEAAAUQi0hJFpoBhEIdARRqaBYhCFAACIQqAlTP4JxSAKgY4w+ScUgygEAEAUAi1hHmQoBlEIdIR5kKEYRCHQkUAgwGUTKApRCHSUn5+PyyZQFKIQAABRCLTE5/M5HA7VVYAZQRQCHSmVSq1WS3UVYEYQhUBHIpEI4xVCUYhCoCOpVIrxCqEoRCHQEQbpgmIQhUBHGKQLikEUAh1ZWVlh8k8oimE0GqmuAaCKdO3a1WAwGI1GuVzO4XB4PJ7RaGQwGAcPHqS6NKAYm+oCAKqOvb39jRs3GAxG0YXh4eHUVQTmAgfIQCMxMTEikajoEmdn5wEDBlBXEZgLRCHQSJs2bTw9PYsuadCggZ+fH3UVgblAFAK9fPnll5aWlqbHzs7O/fv3p7oiMAuIQqCXsLAwHx8f0+MGDRrUrVuX6orALCAKgXZMHUMnJ6eBAwdSXQuYC1xBho+iKtBnpWrUquo0IrS3U9P6NcMcHR2ZSpdHN+RUl1MOlgK2g6sFx4JRhnWhfHBfIXwgvc54LDYj9aHCo46VRoNPUVXQqQ3Zr1S+Qdatox2pruVTgyiED6FRGnYtTW3U3tHJC9/krWr3L+elPSroMtyF6kI+KYhC+BCbf3se1s9FYIfRT6nx9KY89UF+xJAaVBfy6cBlEyi3W0ky70ABcpBCNQOsGUzmq8cYZ6zCIAqh3DJfqiwFuOBGMS6Pmf1KTXUVnw5EIZSbRmUQoktINVsHC4WsOl24N3OIQig3lcKg1+MUM8V0WoNOi99ChUEUAgAgCgEAEIUAAIhCAACCKAQAIIhCAACCKAQAIIhCAACCKAQAIIhCAACCKAQAIIhCqDqnTp8YMKhHRGTzDRtXEUIOH9nfrXtYRkZ6uRq5c/eWWl2m4Vj0ev3Nm9c/tNj/LF4yr3vPdh/ZyNvy8nJbtw3Zf2BXpe4FygVRCFXh6dPHv836KTAgeMbP88PDIgghXK6FlZU1k1mOT+DR+IMjRw1Sqco0SN/vC3/9Y9HsjygZ6AWjzkFVuHI1hcVijft+SmH2hbXtENa2Q4krG41GBqOEmYzK2B800ZRnZQBEIVS68RO+uXrtEiGkbXijFs3b/DJj/tz5M+Lj4wghx+OT2Wz24iXzTp9JmDBu6opVf7569XLB7yscHZz+XDTn7r1bAoGw8efNxn43+djxQ4sWzyWEdOseRgiZ9MPPHdp3ftce586fcfLUcUJI67YhhJBtWw/UcHbR6XQbNq6KPxaXl5fr6Vlz0MDhzb5oZVr/zt1bq1Yvun//Do/Hb9qkxTfffC8UCMv1Gm/evL5p85o7d28SQho0+GzwoBG1a9W9efP6lth1N29dJ4TUreM/YsTYOrX9PvrthEqBKIRKN3jQCKHQ5lzSqZ+nz7W3dyCEdI/qYzAYjh8/XLhOQYH8rw0rxn43WaVSNgwO/e77r1+8eDby2/EKRcG165eZTObnjb6I7hWzY2fsnFmLrKys3dw8StljTN8hWZkZr1+/+nHyTEKIvZ2YELJg4W8nEo7E9Bvi5eVzIuHItOkTFv+5NjAw+NmzJ+MnjPDy8vlh4s95udING1dlZqYvXLCy7C/w0uXkH6d85+Nda8TwsQaD4cKFM3qdjhCSnp6m1qj7xwxlMpn79++c/OOY7VsP8niYGMscIQqh0tWv3yDlYhKDwSjshdWuVdfL07voOhqNZsK4qX5+9U0/pqen1a5VN7JTFCEkulcMIUQksnNxcSOE+PnVt7GxLX2Pbm4eNja2EmlOQECQacmLF8/ij8UN6D900MDhhJCWLdrGDIjauGn1HwtXxW79i8lkzp+3TGAtIIQIBMLZc6ffuHG1QYOGZXyBy5YvcHZ2WbpkPZfLJYR069rLtDwsrGN4eITpcZ069caNH3Hz1vXQkMblefOgiuCyCZgFHo9XmIOEkPCwiEuXk5csnS+VSiqk/Rv/XiWENGvW2vQjg8EIDWl8/8EdQsj1G1eCg0NNOUgICQ1tQggxPVUWr9PTXrx41rFDF1MOFsVgMM6eOzn6u6+6dGszb/4MQohUklMhLwcqHKIQzAKfb1n0x6FfjRz57bjEk8f6xnTZu2/Hx7dfUCAnhIhs7QqXCIU2CoWioKCgoEBuayMqXC4QCAkh2dlZZWw5VyohhDg6OL391OYt66b/PLFO7Xqzfv1jxPCxhBCD0fDxrwUqA6IQzBGDwejZo+/WLfu/aNpyydL5Re8QLPvM3UXXFIsdCSEyWV7hEokkh81m83g8sdix6HJTP9T6/zuJ72VlZU0IkUiLd/fUavW27Rs6RXQbNXJ8QEBQPb+AMjYIlEAUgjky3TdjZWU1aNAIQsiDh/cIIXwev+z9NR6PL5HkGAz/9cL8/OozGIzklHOmHzUaTXLKOX//QBaL5e8feP3GFZVKZXrqzJkEQojpJCOHw1UqFTqdrpQdubt7Ojg4xh+LK1zNaDQaDAaVSqlWq2v//yXjPFkuIcRUD5vNIYTk58tMT5VlL1DZcNkEzNGMmZOsraxDPmtsCi/TPSj+9RuwWKxlKxZ0bN9FrVF36dyjlBYaBDY8cvTAH3/ODqgfJBAImzZt0b5d5MZNq/V6vYuL26FDeyWSnCk//mq63JyYGD/px9GdI3tkZqZv2rwmOCgkqMFnhJBavnVUKtWMmZO+GfG9q4tbiTtiMBjDvh4za/bUkaMGtW/fmclkHjt+KKprdHh4hLe37569f9vZ2RfI5Zs2r2EymU+ePDJFvKuL246dsTY2tp0juxfuZeyYyWKxQ2W9p1Aq1owZM6iuAaqZe5fyHdx4gvJMhXzt2qXbt//tHzO0cMnNW9evXr04oP9QJpOZkpL0/PnT3tH9C59NS0tNTjmXkHhUqVIO+3p0s2atCCFCgdDBwenUqeMXLpzNz5e1bx9Zyh69vX3z8/MSEo/e+PeqjY3tZw0bhYY0KSiQHzm6PzEx3srSasL4qaYrJEKhTUD94EuXLxyM233/wd3WrdpNnDDdwsKCEFKzpo9Kpbx06YJfHX8PD69S9uXrW/vGjSvHTxx+8OCuq6t7s2atHRwcGwQ2TElJ2rd/x8vU519/Pdrd3fPgwd29evZjsVh+9QLu3bv95MnDiI5dC/fyWcPPnZycy/iWZqWq9DqDp59lGdaF92OU/cwLgMm+FWl+jW1dfPBHSKU7F3I1Sl3zKDHVhXwicIAM1dWYsUOfPn309vKmTVv+OOmXit2XXC7/sl/JndDhw74z3f8I1RqiEKqr6VPnaHXat5ebrq5ULEtLyzWrt5X4lFBgU+G7g6qHKITqqiqvMDCZzBrOLlW2O6h6uJkGAABRCACAKAQAQBQCABBEIQAAQRQCABBEIQAAQRQCABBEIQAAQRQCABB88Q4+hMCezSAlzFMMVYnFYVqyWFRX8elArxDKzdKalfVKRXUVdJfxTCEUl2PISCgdohDKzcvPKj9HQ3UVdKfI13nWtaK6ik8HohDKrYY3T+zKPX8gk+pC6Ctha9pnbURcPk5TVBiMYg0f6Pqp3LQnqho+lmIXHouNv8mqoFIYpOnqW+elraMdPepU/LCMdIYohA/38r7y/hWZqsAgSa9mx8sqlYrFYnI4xSdxN3MCO7adMzeopa0NzhJWNEQh0NGcOXNq1arVs2dPqgsBc4FzhQAAiEIAAEQh0JNIJOLxeFRXAWYEUQh0JJVKVSrcJQ5vIAqBjoRCoYWFBdVVgBlBFAIdyWQytVpNdRVgRhCFQEc2NjY4VwhFIQqBjvLy8nCuEIpCFAIdCYVCLreafdUEKhWiEOhIJpNpNNXsy4JQqRCFAACIQqAloVCIyyZQFKIQ6Egmk+GyCRSFKAQAQBQCLbHZbAYDw83CG4hCoCOdToeROqEoRCHQkYWFBZuNmW/hDUQh0JFardbpdFRXAWYEUQgAgCgEWrKyssIX76AoRCHQUUFBAb54B0UhCgEAEIVASxivEIpBFAIdYbxCKAZRCACAKARawuSfUAyiEOgIk39CMYhCAABEIdAS5kGGYhCFQEeYBxmKQRQCHWFkGigGUQh0hJFpoBhEIQAAohBoydbWFvcVQlGIQqCj3Nxc3FcIRSEKgY5EIhGfz6e6CjAjiEKgI6lUqlQqqa4CzAiiEOjI1tYWt1hDUYhCoKPc3FzcYg1FIQqBjnCuEIphYGJsoI+wsDAWi2U0GhUKBYfD4XK5RqORx+MdOHCA6tKAYvjuEdCInZ3dkydPTI9NN9MYDIbmzZtTXRdQDwfIQCO9evUqNuenk5NTTEwMdRWBuUAUAo1ERUV5enoW/mg0GmvVqhUaGkppUWAWEIVAI2w2u3v37oUdQwcHB3QJwQRRCPTSo0cPDw8P0+O6des2atSI6orALCAKgV6YTGbPnj25XK69vX3fvn2pLgfMBa4gQ7nl5+gM1fkerLCWXXb/fcTd3b2Od3Betpbqcj4cm8u0ErKoruITgfsKoRwS/8l6eC3fxYcvea2huhYg1iJ2bqbGr5GwaWd7qmup9hCFUCY6jXHtT0/afOni4GbBscB5FXOhlOtT7xc8u50fNdKVgV/LR0AUQpms+fFJj++8uHz8tZmjF3cK7l3O7THalepCqjFEIbxf8mEJX8D1DrSmuhB4pxunJGIXTt1QAdWFVFf4Jw/v9/KBQiDCFTazxhewXz/BCIwfDlEI78dmM20dMLqfWbNzttBocIT34RCF8H5ZaSoDwZ+ZWTPojXJJNb4xiHKIQgAARCEAAKIQAABRCABAEIUAAARRCABAEIUAAARRCABAEIUAAARRCABAEIUAAARRCJXi1OkTrduGvHjxzPSjTqeLGRC1ctWiUjZJT3/9Oj2tjO3fuXtLrVa/d7WHj+63bhty4cLZt5/Ky8tt3TZk/4FdZdxj2ZWxtlIUe/egaiAKodIxGAyBQMjj8d61wqu01L4xXe7fv1OW1o7GHxw5apBKZY4DUplzbVA6DEIHlY7FYq1cvqmUFfQ6XdmHEP7IPlelMufaoHSIQqhcr9PT+vbrQgiJ6TfkqyHfqlSqRUvmnj9/hhASGBg86tsJRmIcOLgnIeSXmZN/IaR9+8jJP8x4V2tH4w8uWjyXENKtexghZNIPP3do3zkzM+OvDStSUpIKCuTu7p59vxwc1rZD4SaJp46tWrM4PT3N17fO8K/HBAYGv6vOFSv+uHI1hcu1qF2r7pAh39atU48Qkpx8bs26pWlpqc7OLl069+we1btctZkOmVetXnT//h0ej9+0SYtvvvleKBCazhts2Lgq/lhcXl6up2fNQQOHN/ui1Ue/3/CBcIAMlUtka/frzAVs9n//dLdt3xAfH9ezR9/hw8bIZHl8Pt/eTvzTlN8IIYMHjViyaF1M3yGltPZ5oy+ie8UQQubMWrRk0brPG31BCNHpdffu3e7apec3w8cKhTazZk+9e+924SbPnj7u2aPvoIHDMzJej5/4zZ07N99uNicne/SYIbL8vFEjJwwfNkar1X43dujTp48VCsWMmZO4HO74cVObNmmRk5NV3tqePXsyfsIIrVb7w8SfB/b/+ty5k7/8Msm0/oKFv/2zY0tkp6ifpvzm7OwybfqEf/+99qFvM3ws9AqhcvF4vGZftGIwGKYfX6en8fn8vl8OYrPZnSK6mRbWrlWXEOLh4RUQEFR6ayKRnYuLGyHEz6++jY2taaFLDdeN63eadtGxY9eoHmFJSaf86vqbnh0y+JsmTZoTQsLDIgYN6bnur+V/LFxVrNktsetEtnYLf19piuzwsIiYAd3iDu/tHtVHrVY3b94mPKzje19pibXFbv2LyWTOn7dMYC0ghAgEwtlzp9+4cVUksos/Fjeg/9BBA4cTQlq2aBszIGrjptVv1wZVA1EIVSqsbceEhKOTJo8e+e14b2/fimr20eMHGzetNl140ev1EknO2+uIxQ7Nvmh9IuGITqcr9lRKSlJmVkZEZPPCJVqtNiszw6WGq79/YOzWv3g8fufI7lwut7yFXb9xJTg41JSDhJDQ0CaEkPsP7vD5loSQZs1am5YzGIzQkMbHTxwub/tQURCFUKU+b9R0zuzFq1Yv+urrPp0iuo39bnLhsfMHu3rt0qTJo4ODQn6Y+LOVpdX0GRMNRkOJazo4OOr1epVKVWy5RJrTpEnzYUNHF11oZWXNYDDmzl6y7q9lq1Yv2rkr9sdJMxs0aFiu2goK5LY2osIfBQIhISQ7O8vOzt509qDwKaHQRqFQFBQUlKt9qCiIQqhqnzdqGhrSePee7StW/unkVKN/zFcf0EjRK85btqxzcXGbPWuRKVX5PP67tpJKJTwez8rKSibLK7pcIBDm5eV6eHi9vYm1tfXY7yZHR/efNn381Gnj/vn7sKWlZdlrE4sdi+5LKpUQQqytBWKxIyFEJssTix1MT0kkOWw2u5RbjqBS4bIJVDwuh2v6O3/7KY1GQwhhMpm9evYTix0ePrxHCLGw4BFCcrJLuyhRyJR02UVWzpPl+vrUNuWgRqNRKBUGQwm9QpVKlZxyLigohMFgsNkcQkh+vsz0VMOGjW7dunH/wd3ClZXK/+4NNN0f41LDtXtUH3mBPL3U+8Dfrs3fP/D6jSuF/dAzZxIIIQEBQX5+9RkMRnLKucK3JTnlnL9/IIvFKuXdg8qDXiFUvJrevkwm88/Fc0aNnBAcFFL0qT17/046fzo8LCInJys7O6tOnXqEEEdHJ5carjt2xfL4fJksr3tUHwuLd8416l+/AYvFWrZiQcf2XdQadZfOPYKCQuLjDx4+sl8osNm5e2t+vuzZ08eFXbN165dLpDkKRcHR+IMyWZ7pMoWVlZWri9uOnbE2NradI7sPHDAsOfncxB9GRveKEYnsLl48rzfof5u5UKvVDhzco1XL8JpePvv377S2sjZdGCl7bTF9hyQmxk/6cXTnyB6ZmembNq8JDgoJavAZg8Fo3y5y46bVer3excXt0KG9EknOlB9/Lf3dg8rDmjHjnfdwAZhcSZD6NbZlsxllXF9gLajh7HL12iUmgxka0pgQsiX2r/r+DRoGh0qkOTeuXzmRcOTZ8ycdO3YZNHA4k8lkMBj16gVevHQ+8WT86/S0Zl+0tv7/6wxvEwqEDg5Op04dv3DhbH6+rH37SP96DZ4/f7Jn79/Xb1xu1TK8e7feiSfja9Wqa2FhcePfqy2at9mz9+8LF866uLhNmTyznl99Uzt+9QLu3bv95MnDiI5dhQLhF01bPn/x9PjxQ5cuX7Cysu4U0c3Ly7tAUZCa+uJc0smz5xLt7R0m/zDD1bW0KHy7NqHQJqB+8KXLFw7G7b7/4G7rVu0mTphuCvrQkCYFBfIjR/cnJsZbWVpNGD/VdFHl7XevLArydOlPFfUaC8u4PhTDKPtd/kBba6Y86f6dlwUPp1PMV+YL1fXE7B7flZbUUAocIIPZSU4+N2vO1BKfWrZkg6dnzSqv6A1zrg0+BqIQzE5QUMia1dtKfMpB7Fjl5fwPc64NPgaiEMwOj8er4exCdRUlM+fa4GPg7A8AAKIQAABRCACAKAQAIIhCAACCKAQAIIhCAACCKAQAIIhCAACCKAQAIIhCKBNHdz6TlHWELqAEg8UQijlUV1GNIQrh/fRavSQDk52btZxXKq4F/pw/HN47eD/PulayHC3VVUBplHKdq+87J3WB90IUwvuFtBPdPJuTnYqOoZm6m5KXn6PxDbKmupBqDKNYQ5kYDWTzb8+CWtvb17CwcSj3dMBQSXJeq189UsglmvYDnKiupXpDFEI5JB+WPLqRbyVkZ74oPpVw9WIwGBkMwmBU72tBtg5cIyF+ocIGLW2orqXaQxRCuem0xGio3h+bhQsX+vj4dOvWjepCPgqbw2DgFFcFwSjWUG5sDiHV/N4aI0PLYOk5FtX7VUAFwv8UAABEIdCSQCDg8XhUVwFmBFEIdJSfn69SVe8rP1CxEIVARyKRiM/HDcnwBqIQ6EgqlSqVSqqrADOCKAQ6Qq8QikEUAh2hVwjFIAqBjrhcLpOJDz+8gU8D0JFGozGKdFaUAAAgAElEQVQYDFRXAWYEUQgAgCgEWrKzs8Mt1lAUohDoSCKR4BZrKApRCACAKARasra2trCwoLoKMCOIQqAjuVyuVmN+AngDUQgAgCgEWsIt1lAMPg1AR7jFGopBFAIdMRiM6j7HE1QsRCHQkdFoxARnUBSiEAAAUQi0ZGFhgcsmUBQ+DUBHarUal02gKEQhAACiEGhJKBRyuVyqqwAzgigEOpLJZBqNhuoqwIwgCgEAEIVAS5jxDopBFAIdYcY7KAZRCACAKARawsg0UAw+DUBHGJkGikEUAh2JRCLMeAdFIQqBjqRSKWa8g6IQhUBH1tbW+LYJFIUoBDqSy+X4tgkUhSgEOrK0tORwOFRXAWYEUQh0pFAotFot1VWAGUEUAh3hCjIUgygEOsIVZCiGgclugD66d+/+4sUL0zRPpnnvjEZjvXr1tmzZQnVpQDH0CoFGwsLCTA8KJ/+0srKKiYmhui6gHqIQaKRPnz4eHh5Fl9SsWbN9+/bUVQTmAlEINGJnZ9euXbvCHy0tLb/88ktKKwJzgSgEeomOjnZzczM99vb27tChA9UVgVlAFAK92NnZmeKPz+ejSwiFEIVAO3369HF1dcVZQigKN9MAyc3SXjkhTXui1GmNGqWe6nKqgl6vZzAYNBm9VeRkodcZ3GpbftHZnsliUF2OmUIU0l3Gc3X8lvSQdmKhPdfKhk3wcfj0MIksW5Mv0Z3Z/Xrg9JpWQhbVBZkjRCGtPbujSDkqifjKjepCoIrsWPA0epy7QMSmuhCzQ4sDBCiR0UCunJB2HIwcpJHw/m7n9mdTXYU5QhTSV8YLlV5nZOAjQCciJ87zOwVaDY4Fi8PfAX1Js7Q1fCyprgKqWs0AQfYrNdVVmB1EIX1pVXq1ghbXi6EouVRr0KNXWByiEAAAUQgAgCgEAEAUAgAQRCEAAEEUAgAQRCEAAEEUAgAQRCEAAEEUAgAQRCEAAEEUAgAQRCFQ7LfZUwcM6lH6OqdOn2jdNuTFi2eVUYBcLn/w8F7Ftrlr97bWbUMUCkXFNguVClEItDZ0WJ8jR/ZTXQVQD1EInyaj0fgqLfW9q2k0miopB8wdpjiAcujctdXokRMTTsZfu3bJ2loQ1rZjYGDwho2rUlNf1PTy+f77KXVq+5nWPHbs0NbtG9LSUu3txZ0iovr1HVw4vVziyWObNq/JyHjt5eltMBgKG1epVOv+Wp6QeFSjUbu7eUZH92/Tul25yrtz99byFQufPHlobyf2qunz6NH9zRv3cLncd7Xcp2+kVCrZt3/nvv07nZyc/94WV0rjycnn1qxbmpaW6uzs0qVzz+5RvU01b4ldd/LksazsTCenGu3CO/XrO9i0/tmzidv+3piVlRFQP2jC+GkODo6m5deuX167btnjxw9EIrvgoNChX420txeX/b29efP6lth1N29dJ4TUreM/YsTYwvccPgZ6hVA+C/+c1bRJi8WL1gUGBO/ctXXR4rlDh4ycO2eJUqX85ZdJOp2OEBIfHzdn3s+1atWdNnV2q5bh6zes3Lptg2nzEwlHf/1tir2dePSoiaGhTR4/eWhabjAYfpr6/YULZ/r1Hfz92Cm+vnV+/W3K4fIcumZkpE+Y+A2bzf7px9+Cg0OTkk536dyTy+WW0vKMn+cLBMLmzVovWbRuxs/zS2lcoVDMmDmJy+GOHze1aZMWOTlZphlEp/w0dsfO2ObN2/wwYXrLFm1fpj5nsf6bT27zlrXdo/oMGjj89p1/58ydblp45erFHyaN8vL0njB+WnTPmH//vTpuwgiVSlX29zY9PU2tUfePGTpwwLD09LTJP44p3Bw+BnqFUD4dO3Tp2qUnIWT48O9On0no13dIkybNCSH9vhw8Z97PaWmp7u6e69YvDwgImjrlN0JIi+Zt8vNlf/+zqUf3L1ks1rLlCwIDg3+fv9wUGa9evXz0+AEh5MzZxH9vXtu+9aBY7EAICWvbQalU7N6zPaJj1zIWdvzEYaVS+fO0uXZ29l980fLGv1eTU871/XJQKS3XrVOPzWbb24sDAoJKb1yaK1Gr1c2btwkP61i48PSZhGvXL0+cMK3EIhcuWOXsXIMQotPp1q5blpeXa2Nju3TZ750ju48Z/YNpnZCQxgMH97x0+ULzZq3L8t56eHiFhXUMD48wbV6nTr1x40fcvHU9NKRxmX+BUDJEIZSPhQXP9IDL4RJCuFyu6UcHRydCSF5eLoPByM7O6h3dv3CT0NAmh4/sT331QibLy8vL7dmjb2HXifn/D5KTz+l0ur4xXQq30uv1VlbWZS8sKyvDysrKzs6eEMJgMFxc3DIyXldIy4QQlxqu/v6BsVv/4vH4nSO7m171xUvnLSws2reLLHETodDG9MC7pi8hJDMrQ6lUPn/+9NWrl3GH9hZdMzMzw/Tgve+t6aWdPXdyx87Y58+fWlpaEkKkkpxyvRYoEaIQKpi8QE4IsbW1K1wiEAgJIdlZmbl5UkKIs7PL21tJpTn29uI/FqwqupDFLsfn09XVvaCg4MmTR97evlqt9tGj+0FBIRXSsimA5s5esu6vZatWL9q5K/bHSTMbNGgoleSI7R0KY/2d2zKZpvyVSnMIIQMHDGvRvE3RFezsxGWvZPOWdRs2rurR/cthQ0fnSLJ/mTnZYDSUYTt4D0QhVDBHhzddGBOpVFIYiISQ3Fzp21sJBMLcXKmTUw0LC4sP22/7dpE7d22dMnVsu/BO129c0el0gwYMK0vLRmOZ5jyytrYe+93k6Oj+06aPnzpt3D9/H7a2Fkik5eiRWVsLCCFqtcrDw6vsWxWlVqu3bd/QKaLbqJHji3Yn4ePhsglUMHt7sbNTjYsXkwqXnD59gsfj+frW8fGpzWQyTyQceXurhg0b6fX6Awd3FS5RKpWmB6ajRZksr/T92tjYjho5wcKC9/Tp45DPGq9dvc3NzaP0lgkhfB4/J6dMU6Sr1WrTkXL3qD7yAnl6elpwcKhSqUxIjC9cx3Rl413c3DycnJyPHD1QWIBOp9NqtWXZu4lKpVSr1bX//5JxnizXdMWp7C3Au6BXCBVv0MDhc+fP+H3Br6GhTa5evXgu6dTAAcP4fD6fz+/Yocuhw/s0anWjRk1zcrJTUs6JRPaEkPCwiINxe1atXvw6Pa12rbqPHj04l3Ry4/pdPB6vprcvk8n8c/GcUSMnBAeFvGund+/dnv/7L2NG/cDmcJhM5uvXr+zs7FksViktE0ICAoITEo9u275RIBD61wv09vYtsXGtVjtwcI9WLcNrevns37/T2sraxcXN1dV93/4dc+f9fO/ebV+f2k+ePrpyNWXNqq3vqpDBYIz8dvz0nyeOHD2oS+eeBr0+/lhceHhEzx59y/jG2tjYenv77tn7t52dfYFcvmnzGiaT+eTJozJuDqVAFELFa98+UqVW7dy19djxQ2J7h2Ffj+7Te4DpqdGjJnK53BMJRy9fSa5fP8jHp7ZEkkMI4XA4v89bvnbd0sTE+Li4PW5uHl0692Sz2YSQGs4ukyb+vDl2XXLyuVKi0NmpRo0arvN+/6XwgLeWb50li//i8XjvapkQMnzYGIkke0vsOlsb0bffjntXFCpVyuCg0BMJRwoK5DVr+s6etciUpAsXrFq7dunxE4fjDu1xdnZp3apd6R3D5s1az5m1aMPGVctXLLSysg4MCA4MbFiu93baT7PnzZ8x89cf3dw8vvnm+8ePH+zevX34sDEcDqdc7UAxjDKeKIFPz79nczNTtZ9HOFBdSIXR6/Wmixh6vf7suZO/zJy8cMHKhsGhVNdlXo5tetU4ws7Vl091IeYFvUKoTsaMHfr0aQnHg02btuz35eDvvv+6SePmvj611Rr1mTMJPB7PzdWj7I0nJ5+bNWdqiU8tW7LB07PmRxQO5g69Qvqqjr3C7Owsra6E6wx8Hl+v12//e1Ny8tmMzHRra0FA/aB+/YaU60tpKpVKmisp8SkHsSO7nPffmC30CkuEKKSv6hiF8PEQhSXCzTQAAIhCAABEIQAAohAAgCAKAQAIohAAgCAKAQAIohAAgCAKAQAIopDW2GymBR8fANqxssUYNiXAXwJ9WYvY2a/UVFcBVe3VowJbRy7VVZgdRCF92Tlzmfj904xaabB3trASvmc+FhrCnwJ9WduyXX35KYezqC4Eqs7pna+DWtlSXYU5wsg0dHfpmFSSrgtpb8/l4f/ip0xVYDiz63VwK1vvQCuqazFHiEIgN5Pybp2XqRV6WwcLjVpPdTlVwWAwMP5/Ws5PnrUtJ+2xwsHNIqiFrWc9S6rLMVOIQiCEEKOByHN1+bk6QmjxeYiNjXVzc2vVqhXVhVQFBmHaOrL51jg/WJpPZGBe+EgMJhHYsQV2dPk86DnZXKHIxRvDl8J/aHGAAABQOkQh0JGFhcUnM1cJVAhEIdCRWq0ufcJioBtEIdCRjY2NaU53ABNEIdBRXl6eSqWiugowI4hCoCOhUMjl4nu48AaiEOhIJpNpNBqqqwAzgigEAEAUAi1xuVwmPb51B2WETwPQkUajMRgMVFcBZgRRCHQkFAotLCyorgLMCKIQ6Egmk6nVGMEb3kAUAgAgCoGWRCIRn49haeANRCHQkVQqVSqVVFcBZgRRCACAKARawhVkKAZRCHSEK8hQDKIQAABRCLTE5/M5HA7VVYAZQRQCHSmVSq1WS3UVYEYQhQAAiEKgJTabzWJhXmB4A1EIdKTT6fR6PdVVgBlBFAIdYfJPKAZRCHSEyT+hGEQhAACiEGgJ8yBDMYhCoCPMgwzFIAoBABCFQEsCgQBTwkNRiEKgo/z8fEwJD0UhCoGOBAIBLptAUYhCoKP8/HxcNoGiEIVARwwGg+oSwLwgCoGOjEYj1SWAeUEUAh0xGAx0DKEoRCHQkdFoRMcQikIUAh3hvkIoBlEIdIT7CqEYBg4TgD4iIiIyMjIYjDcfewaD4erqun//fqpLA4qhVwg00qJFC9MDxv9jsVi9e/emui6gHqIQaOTLL790d3cvusTd3b1nz57UVQTmAlEINOLp6dmkSZPCo2MWixUVFYXrJ4AoBNrp3bu3q6ur6bGLiwuOjsEEUQj04uXlZeoYslis6OhoTPYEJohCoJ1+/fq5u7u7ubn16tWL6lrAXOBmGijN1cTcjOcqlcKg0xiorqUiZWVlcjhcW1tbqgupSFa2bDaH4VKTX/8LIdW1VD+IQiiZTKLbOvd5gxZ2QnuOlQ0HnxPzx2QxcjM1CpnuyU1Z7/EeHC6+ZF0OiEIoQV629uim9HYD3dgc/DlVP3lZmpP/vO7/kyfVhVQnOFcIJUjYntmyVw3kYDVl48ANaeeQsD2T6kKqE0QhFJeVqlYpDVY2uLRajbnVtrx7SYZDvrJDFEJxkgyNi48l1VXAx/Kqb5X5Uk11FdUGohCKUyv0n9j1YnpSyz+16/6VClEIAIAoBABAFAIAIAoBAAiiEACAIAoBAAiiEACAIAoBAAiiEACAIAoBAAiiEACAIAoBAAiiECij1+tv3rxe4c127tpq5apFFd7sB5PL5Q8e3vvIRgZ/FT3z1x8rqCIoGaIQqPH7wl//WDSb6ioq3dBhfY4c2U91FfB+iEKoeKmpL967jkZNi6H0NBoN1SVAmWCkYqgAOTnZS5f9fuVKCpvD+eyzz8+cSVi9MrZmTR9CyP4Du3bsjM3OznR2dmnbpkPv6P4WFhZz5884eeo4IaR12xBCyLatB2o4u7yr8Zcvn/+5aM7de7cEAmHjz5uN/W4yk8kkhBw+sn/P3r9fvHhmbS1o2qTFV0O+FYnsCCFyef6sOdOSkk7ZCG379BnYtUtPUzsqlWrdX8sTEo9qNGp3N8/o6P5tWrcjhOzave3M2cR24Z02bV6Tl5fr41P7qyHfnjhxJCnpFJvDaRfeadjXo1kslkaj2bxlbWJifGZWhr29uF14p0EDh7NYrFLelj59I6VSyb79O/ft3+nk5Pz3tjjTe7Vy1Z8pF5N0Ol1A/aARw8d6e/ua1r9z99aq1Yvu37/D4/GbNmnxzTffCwWYu66KIArhY+n1+ik/jZVIc777brJEkr123bLgoBBTDm7ctGbnrtjuUX08Pb1fvnz2z47Nqa9eTJk8M6bvkKzMjNevX/04eSYhxN5OXEr7vy/89cWLZyO/Ha9QFFy7ftmUgxs3rd60eW2rlmG9evST5kouXbrA5nBM6x85eqB9u8jvx05JPBm/aPHcml4+gYHBBoPhp6nfp6en9es72NbW7vr1y7/+NkWlUkZ07EoIuXnzOpvFnjF9XkZm+sI/fpv4w8jOkd0XLFiZnHxu46bVHh5enSK6sVisK1dSmjRt4VLD7dGj+7Fb1wsEwuheMaVUPuPn+T9MGhXU4LNePftxuFxTHI+bMEImyxv29RieBW/7P5vGTRixZfNegbXg2bMn4yeM8PLy+WHiz3m50g0bV2Vmpi9csLKCf1vwDohC+FgPHt578PDez9PntmoZRgh58eLZkaMHNBqNTJa3ddv6qT/NatmirWlNe3uHPxfNGTVygpubh42NrUSaExAQ9N7209PTateqG9kpihBiip6srMzYrevDwyOmTJ5pWqdP7wGF67cL7zTph58JIc2btY7u3fHU6eOBgcFnzib+e/Pa9q0HxWIHQkhY2w5KpWL3nu2mKCSETJ82x9ZW5O8fePHS+eTkc9+P/ZHBYNSp7XfsWNzVqxdNUbhi+SYG47+pr9Jep545m1h6FNatU4/NZtvbiwtf5vETh1+8eLZwwcqGwaGEkICA4L4xXfbs+XvggK9jt/7FZDLnz1smsBYQQgQC4ey502/cuNqgQcMP/c1AOSAK4WPl5GQRQlxc3Ew/url5GAwGpVJx5UqKTqebNXvqrNlTTU+ZZprNzsos13FfeFjEtu0blyyd3z9mqOkQ+MrVFL1e37VzzxLXt7H5b6J3Ho/n4uKWmZVBCElOPqfT6frGdClcTa/XW1lZF/7I5Vr894DD5XA4hZEndnDMy8s1PZZKJZu3rL10OTk/X0YIMWVWudy4ccXaytqUg4QQZ+caHh5e9x/cIYRcv3ElODi0sM3Q0CaEkPsP7iAKqwaiED6Ws5OL6Rizdq26hJC7d2+JxQ42NrY5kmxCyOxZixwdnIquXxiaZTT0q5EikV3s1vVHjh4Y9vWYqG7REkkOIcThf5stEZPF0uv1hBCpNMfeXvzHglVFn2Wx3//5ZzD+mytcIskZNqIfn285ZPA3Li5u69eveJn6vFwvhBAiL5Db2IqKLhEKbXKyswghBQVyW5s3TwkEQkJIdnZWeXcBHwZRCB/L17d2aEjjNWuXZGS8zs2TJp0/PfWnWYV/zIQQDw+vEjc0lm1uSgaD0bNH344duv65aPaSpfN9fWpbWwsIIRJpjqPj+9PQRCAQ5uZKnZxqWFhYlPmV/Y8DB3dLpZLlSzc6OTkTQhwdncsYhUVfpoPY8c6dm0WflUhynBydCSFisaNMlle4XCqVEEKsy9/xhA+Dm2mgAoweNdHNzeNl6nNbG9GypRtMJw2Dg0MZDMbeff8UrqZUKgsf83h8iSTHYHj/lGxqtZoQYmVlNWjQCNOpyeCgEELI4cP7CtfR6XSlN9KwYSO9Xn/g4K4SiykLmSzX1lZkykFCSJ4styxRzufxc3KyC3/09w/Mz5fdvXvL9OPjxw9fvXppOpPo7x94/cYVlUpleurMmQRCiOkpLodrOiSHyoNeIXwsnU737aiBvXrGuLq6MxiM/HyZXC63trZ2c3XvHtVn957tU6Z+3+yLVjk52fv275gze7HpOLpBYMMjRw/88efsgPpBAoGwadMW72p/xsxJ1lbWIZ81Tk45RwipU9vP3d0zslPUwbg9MlleaGiTvLzcgwd3//HH6lLuyAkPizgYt2fV6sWv09Nq16r76NGDc0knN67fxePxyvgyg4JC9u7bsX7DSn//BmfPJqakJBkMhry83MJTkyUKCAhOSDy6bftGgUDoXy8wrG3Hrds2zJg5qX/MUCaTuWXLOltbUdcuvQghMX2HJCbGT/pxdOfIHpmZ6Zs2rwkOCglq8BkhxNe3zuEj+5ev+GPY16M5/3+hHCoWohA+FpvNDvms8ZbYdYVdM4G1YMniv7y8vEd+O87R0Wnv3n8uXbpgby9u3qy1g9jRtE54eMT9B3eOHT90Iflsh/adS4lCv7r144/FnTmbKBY7jh/3U/36DQgh34/90dnZJS5uT9L50w5ix9DQJmxWaR9mDofz+7zla9ctTUyMj4vb4+bm0aVzT3YZzhUWatG8zYD+Q/fu27Fv344mTVssX7Zxztzpe/f9M2jg8FK2Gj5sjESSvSV2na2N6Ntvx3l7+/4+b/mKlX+sXPWnwWAIDAge+e1407UgNzeP+XOXrVm3dP7vv/D5luFhESOGjzVdvRn61cj8fNnRowcGDhiGKKwkjDKerwH6+Pdsbmaq9vMIh7JvotfrTTcbG43GtNevhn7dJ7pXzOBBIyqzTHiPY5teNY6wc/XlU11I9YBeIXwsjUbzzcgBjo7ODQIbcjjcmzevqVQqH5/a5WpkzNihT58+ent506Ytf5z0S8UVW/Gqb+VQFHqFUFx5e4VarXbP3r8TE+OfPX/C5XJr1vTtHtXHdOWk7LKzs7Q67dvL+Ty+7f/efWJuzLZy9ArLBb1C+FgcDqd3dP/e0f0/phHTl0Cqo+pbORSFm2kAABCFAACIQgAARCEAAEEUAgAQRCEAAEEUAgAQRCEAAEEUAgAQRCGUgMlisNj4YFR7HAsWIQyqq6g28ImH4iwF7HwJZu+t9qQZKoGotLlJoShEIRRnX8NCrXr/4NJgznQaI5fHshZhcMOyQhRCcTZitp0T597FvDKsC2bqUny2fxMhE3/fZYa3CkrQto9jVqry3kXMp1EtpRzOshGzA5vbUF1IdYLxCuGdTv6TmfVKw+UzBXYWei0Omc0dz4qVlapksRluvvyQcLMe5NEMIQqhNLIcnSRdXSDTGwyf1OckPj7e0dExODiY6kIqEpvNFIjYdjW4lgJcLSk3DN0KpRHas4X2n+CHJO7MY0tnZsAXOISE/+BcIQAAohAAAFEI9MTlcpm40wSKwKcB6IjFYiEKoSh8GoCOlEqlTqejugowI4hCoCMcIEMx+DQAHWk0GoMBN43DG4hCAABEIdCSUCi0sLCgugowI4hCoCOZTKZWq6muAswIohDoiM/nczgYyw/eQBQCHSmVSq1WS3UVYEYQhQAAiEKgJZFIxOfzqa4CzAiiEOhIKpUqlUqqqwAzgigEAEAUAi2JRCIej0d1FWBGEIVAR1KpVKVSUV0FmBFEIQAAohBoydbWFgfIUBSiEOgoNzcXB8hQFKIQAABRCLQkEAi4XC7VVYAZQRQCHeXn52s0GqqrADOCKAQAQBQCLWFuEygGnwagI8xtAsUgCoGO+Hw+m82mugowI4hCoCPMgwzFIAoBABCFQEsYmQaKQRQCHWFkGigGUQh0ZGFhgcsmUBSiEOhIrVbjsgkUhSgEAEAUAi1ZWlriABmKQhQCHSkUChwgQ1GIQqAjS0tLDodDdRVgRhCFQEcajUav11NdBZgRRCHQkU6nw3AMUBTDaDRSXQNAFQkPD8/JyWEwGAwGw2g0Go1GBoPh5OR0+PBhqksDiqFXCDQSGhpqykFCCIPBYDKZTCazS5cuVNcF1EMUAo306dPH0dGx6BJ3d/cePXpQVxGYC0Qh0EhgYKCfn1/hSSEGgxEeHu7g4EB1XUA9RCHQy6BBg8Risemxu7t7r169qK4IzAKiEOglMDCwfv36pgsmYWFhhbEINIcoBNoxdQzd3d179+5NdS1gLnAzDVQ6ndr4+JY8L1urkJnLXc2nT5+2sbEJCgqiupD/WApZ4hoW3oFWVBdCX4hCqFwv7yvO7MsWOVo4e/ENBnzYSqbTGDNfKiWv1VEjXW3E+EYgBRCFUIlSHykvH89t27cG1YVUD4p8fdLe9LZfOiINqx7OFUJlUebrj21ORw6WnaWA1ay7855lr6guhI4QhVBZbpzNrRNqS3UV1QzfmuXgxnt0XU51IbSDKITKIs3U2rtgVrlyE7vxstPUVFdBO4hCqCwFUh3XgkF1FdUP14KpyDeXS+30gSgEAEAUAgAgCgEAEIUAAARRCABAEIUAAARRCABAEIUAAARRCABAEIUAAARRCABAEIUAAARRCABAEIUAAARRCHRRIRNX5OXlyvJlFVEOmB021QUAvKFSqf5av+LkqWNKpaJhcCN7e7FMljd92pzLV1Im/jBy+dIN9eoFmNbs2KlZVLfew74eTQh5nZ62YsUfV66mcLkWtWvVHTLk27p16hFCBn8VXdPLx8vLZ8/ev9VqVe/oAdu2b9i546iN0MbUyKw50+7c/ndr7P5SSoqPj9u6fUNmZnpNLx8Gk+nsVGP6tDmmUtf9tTwh8ahGo3Z384yO7t+mdTtCyNTp493dPNlsdtyhvTqttnHjZt+NmWxtbV0l7x98OPQKwVwYDIafpn6/e8/25s1ajx0z2cmpxsG4Pe/dKicne/SYIbL8vFEjJwwfNkar1X43dujTp49Nz166dOHe/duzf/vz15kLO0d21+v1J08eMz2l1WqTk8+2adO+lMbPJZ2aO39Gg8CGU6fM4nC5d+/e6tmjb2GpFy6c6dd38Pdjp/j61vn1tymHj/wXqTt2xqanp82etWjUyAmnTp+I3fpXRbw9ULnQKwRzkZx87uq1S8OHjenTewAhJDw84srVlPdutSV2ncjWbuHvK9lsNiEkPCwiZkC3uMN7R4+cQAhhsdnTfprN5/NNK4eGNok/Ftetay9CyOXLyXK5vG2bDqU0vn//Ti8v7/HjfiKE1K3r36t3x+SUc/XqBZw5m/jvzWvbtx4Uix0IIWFtOyiVit17tkd07EoIcXPzmPLjrwwGw6+u/5lziZcuXxgx/LuKe5+gUiAKwVxcuXaRENI5ske5tkpJScrMyvaMd8cAACAASURBVIiIbF64RKvVZmVmmB77+dUvzEFCSIf2nX+ZOfnFi2ceHl6nzpzw8anl5eVdSuOZWRlubh6mx2KxA4/Hy8+XmVJbp9P1jelSuKZer7ey+u8omGfBYzD+m8nAyanGrVs3yvWKgBKIQjAX+fkya2trKyurcm0lkeY0adJ82NDRRRcWphKfxy+6/IumLYVCm/hjcYMGDj+fdLpv38GlN+7i4nb//h2NRsPlcp88eaRSqXx96xBCpNIce3vxHwtWFV2ZxS7hr4nD5hgMmKikGkAUgrkQ2zvI5XKlUlm0H2dS2Ml6m0AgzMvL9fDwKssuOBxOWFjHY8cP1fMLkBfI27Qu7UQhIeTL3gPHTRgxbsKIzxo2On78cN069dq3izTtNDdX6uRUw8LComwvDswdLpuAuahd248QcvjwvrefEtnaEUKyc7JMP+bkZGu1WtPjhg0b3bp14/6Du4UrK5XKUvbSoX3n7OysFav+DAgIcnJyLr2k+vUb9Oj+pcFgSEtL7d17wKI/15rOSDZs2Eiv1x84uKuMOwXzh14hmIsWzdt4eXmvWPXnq9epdWr5PX32+NWrlzW9fAghHh5eTk7OsbF/iWztFErFX38tNxgMpq0GDhiWnHxu4g8jo3vFiER2Fy+e1xv0v81c+K691PKt4+Hh9eLFs+heMe8taeeurdeuXYqO7s9gMNhsdmrqCx+fWqaLMwfj9qxavfh1elrtWnUfPXpwLunkxvW7eDzM+1xdIQrBXDCZzLmzlyxbvuDo0QPHjx1qEPSZjY2t6Sk2mz3j5/mLl8ybOGmkq6v74IEjZs2ZanrK1cVt2ZL1K1cv2rptPYPBqFWrblS33qXvqJ5fQFpaaquWYe8tqU7tejt3bZ01e2rhks6R3cd9P4XD4fw+b/nadUsTE+Pj4va4uXl06dyTXdK5QqguGBVyFz7A23b9mdowXOzg/uEdJdM90qZbmivQtOkTdHrdnFmLyrKyXq9nsViEEI1Gs3rtkn37dsQfOV+pqffwqiw3U9Wmt2Pl7QLehv9jQCPHTxw5kXDk0qULCxesLFw4ZuzQp08fvb1y06YtPwtutG798tat2tWo4SqV5pw9m+jl5Y3e3ycJv1SgkSNH9mt12nlzlwYHhRQunD51jlanfXtlPo+fkZkeUD/oRMIRmSzP3l78RdOWMf2+qtqSoYrgABkqy8cfINMTDpApgZtpAAAQhQAAiEIAAEQhAABBFAIAEEQhVCK1Wk11CQBlhfsKoSJJJBI7O7uXL19GRUUNj9hAdTnVmFarTU9PT09Pz8zMzMzMfPLkycuXL3Nzc/ftK2G4Cvh4iEKoAAaDwWg0Dhw4kBASGxsrEokuX768689Uquuqri5evLhmb6xOp1OpVAqFQiaTme7/dXFxobq0TxaiED7K8uXLDx48uG/fPjab/dNPP/n5+RFCMKvRRxKJ7FJTUlUqVeESBoNhNBoPHjxIaV2fMpwrhHJLTk4eO3bsrVu3CCF16tSJjY3l8XhsNtuUg/DxatXybdu2LZfLLbqQzWYXFBRQV9QnjjVjxgyqa4BqICMjIzY2Vi6Xe3l5JScnN2rUKCQkhBDi7e1taWlZ4ibP7imE9hZCe06VF1u9pT9Tci0YMV9HFBQUPH78WKPRmJbz+fytW7deuXJFo9G4urpiAO2KhSiE0pw6derevXu+vr5HjhzRaDRt27bl8Xj16tXz8PB477Y5r9UFMr2TZ/HR+aF0d5NzPerw7Zy5n3/+OSHk3r17arXaaDQmJycPHjxYJBKlpKTMmjUrJSVFrVa7uLhgvNgKgeEYoLisrKyUlJTIyMi7d++uW7du0KBBAQEBH9COMl+//fcXvcbXrIQaP1lKuf7QmpeDf3kzVcvy5cv//vtvvV5//vz5omtevHjxxIkTCQkJvr6+bdu2DQsLs7Ozo6LkTwSiEP7z4MGD2rVrq1Sqbt26dejQYezYsR/fZuoj5eVjuW371aiIAj99Srn+7J70sC8dbcT/c1Zh8eLFx48fj4uLK3Gry5cvJyQknDhxwtPTs3Pnzl988YVYLK6qkj8diEK6k8vl1tbWvXr1cnZ2Xrp0qcFgYDIr8mLai/uKpP3Zto4WTp58owEftpJptSQ7VZn1UtV9tGuxHCy7a9euXbp0ac+ePa6urmFhYWFhYQ4ODhVd6ScLUUhHOp2OzWavXbt2zZo1e/bscXd3l0qlIpGoknanURmf3JLLcrQK2UfNCHzo0KFOnTpVXF0VQ6vVJicnN2/evAzrvpOlkGXnzPVtUDE3IV2/fv3EiRMnTpxwcXFp27Ztu3btkInvhSikl6SkpA0bNgwaNKhZs2Y3b9709/ev2D5g5YmLi/v888/N8086OTlZLBb7+vpSXUhxN27cSEhIePjwoVarbd++fbt27WxsbKguykwhCj99Mpls48aNdnZ2MTExR48edXZ2DgoKorqo8nn27Jmzs7M5XyqVy+X37t0z3WBkhq5fv3706NFjx475+fmZMtGc30xKIAo/WUlJSXfu3Pn666+vXr168+bNrl272traUl3Uh2jTps3x48dN086ZM4lE8sMPP6xbt47qQkqTnJwcHx9/7Nixpk2btmvXLjw8nOqKzAWi8JNiMBgSExNbtWqlUqmmTJnSpUuXsLD3z/Zrzv79919PT8/qclh39erVunXrvuuec7Ny5syZw4cPnz59ulOnThEREQ0bNqS6IoohCj8FCoVCr9cLBILIyEh/f/85c+ZUlzOApdu5c2fXrl2Lff/MzGVnZ1+9erVdu3ZUF1ImGo3m8OHDhw4dev36tSkTPT09qS6KGojCakyr1XI4nN9///3AgQO7d+92dPyk5khr3br1/v37hUIh1YWU261btxYsWLBx40aqCymH169fHzp06PDhw0KhsGfPnh06dKDbdM+Iwmrp7NmzmzZtGjlyZHBw8O3bt/39/amuqILp9XrzPzlYumr6Em7dupWUlLR+/fqOHTt27949MDCQ6oqqCKKw2pDL5QcPHqxZs2bjxo337dvn5eVV7S4El9GhQ4eaNWtWXc4Pvkt6evr169c7dOhAdSEf6ODBg3v27FEoFFFRUVFRUZ/86A+fwhmlT5tEIrlz5w4hZPPmza9evapTpw4hpFu3bp9qDo4ZM0YsFlf3HCSEODs729raTp06lepCPlDnzp03bNgwa9as1NTU1q1bT58+/dq1a1QXVYnQKzRTKpWKx+MdP358/vz5v/76a+PGjamuCGjt0KFDe/futbS0bNOmTbdu3agup+IhCs1OZmbmzJkz3dzcJk/+v/buM6Cp6+8D+MmCQEgYAUE2ggqKCAiKE2Q4caAICi7qbtX6d9U6Wuuquw5ErbhXxQWKVlEZ4mAKKAUUFJU9EkgCJCGD50V8qFW29+aEcD6v5Cac8w2Jv9xzxznrSktLDQwMYCeSk5cvX9bV1Slf0U9JSamqqlKOK/jy8/MvXLjw4MGDgICAwMBAOp0OOxFmUClUFDExMRkZGStWrMjLy6uoqBg8eDDsRHKVkpISGhp67Ngx2EFwceLECSqVOmvWLNhBsFFbW3vp0qWLFy+6ubkFBgb27NkTdiIMoFIIWVpaWu/evaVS6ebNm319fZVvn6gtpFJpYWFhW6aDRRTK7du3L168qKWlFRgY+I0TUkCHSiEcPB6PTqevX7++vLw8JCSkc11FjLnMzEwLCwsajQY7CL6uXbs2ePBgIyMj2EEwlpycfPHixYqKinnz5rm7u8OO00GoFMrbu3fvtm3bNmXKFG9v78rKSjTL5vHjxwkEwsKFC2EHkYcxY8ZcvnwZv/nQIHr79u2xY8cKCgoWL17s5uYGO067oVIoJ2lpaW/fvvX19U1JSaFQKP3794edSCHweLzs7OyBAwfCDoJgIzc39/jx48XFxYsWLXJ1dYUdpx1QKcSX7JqYnJycvXv3fv/99+imd6SoqCgvL69zlYn2ev369fHjx8vLyxctWtRZjiGiUoij/fv3R0dHR0ZGCoVCpb9YvwNOnz4tFAoXL14MO4i8HTx4UFtbe/bs2bCD4CsnJ+fYsWMMBiMgIMDa2hp2nFagUoi98PBwKysrW1vb2NjYznjQRD44HM6vv/564MAB2EHgKCws1NXV7Qrzp75+/Xrr1q3W1tYbNmwgEAiw4zQLlULMyMbCGzdupFKpK1eu7BST1iGwdLXrh27evLl9+/Z169b5+vrCztI0VAoxwOfzd+3a1bNnz8DAQNnEWbATKbry8vLU1NSxY8fCDgLTjRs3srOzN2zYADuI/OzcuTMjI2P9+vUdW1kbV6TNmzfDztCJ5eTk6Orq/vPPPxoaGrKvu844L5P8rVq1atiwYcp3hV272NjYVFdXa2hodMY5GTtm2LBhdnZ2u3fvTk9Pd3V1VajxMtor7LjNmzfn5eVduHABdpBOhsfjFRYW2tjYwA6CQBMZGXnq1KlffvlFcSZYQqWw3dhsdmlpaZ8+fZ4/f97V7hRGMBcWFsZkMj08PGAHkTexWLx48WIXF5f58+fDzgLQfIXtlpeX5+/vL7tFBNXBDigsLFSaWQkw4e3t3TUPUpHJ5NDQULFYvGjRIthZACqF7ZCYmCg7FPjgwQMlW0VEnsLDw5VytrsOU1dXj4uL67KDs8WLFy9YsMDJySk5ORluEjRAbpPg4GDZNIKwgyBKSCKRlJWVGRoawg4Ck2ywPHfuXFgB0F5hK96/fw8AGDBgAKqD304gEHA4HNgpFA6JRNq5c+fTp09hB4Hp2LFjqqqqENc/QKWwJefOnYuKikKHBbGyZ8+ejIwM2CkU0YIFCwoKCmCngGzGjBlDhw5dunQplN5RKWwJj8frIpNHyUdhYeGIESNgp1BE/fr1mz59OuwU8I0dO9bX13ffvn3y7xodK2xaRkaGhYVF17n2FYEuJSXFzMxMT08PdhD4oqOj//rrrz///FOenaK9wiYsWrRIJBKhOoitzMxM2YFXpEnZ2dkXL16EnUIhuLu7+/v7r127Vp6dolL4pYqKioMHDzo5OcEOomy2bt0qFothp1BcXl5eOjo6sFMoCg8Pj+HDhx8/flxuPaJS+B9v3rzhcrldYeokORMIBK6urlZWVrCDKC4DAwOln8GwXSZMmFBQUHDv3j35dIeOFf7r/fv3q1atun79OuwgSBcVFhY2atQoLS0t2EEUyKRJk44cOWJsbIx3R2iv8F+pqalHjx6FnUI5ZWRkvHz5EnYKRRcfH5+VlQU7hWIJCQlZuXKlHDpCpfBfU6dORXfU4eTMmTPV1dWwUyi6SZMmoRl/v2BkZDR27Njg4GC8O0Kl8JOrV6/K7jJG8NCrVy+0xFWrPD09FWfSKsURFBT07t27N2/e4NoLKoWfXL582cDAAHYKpbVkyRINDQ3YKRRdenp6XFwc7BSKaPbs2bt27cK1C1QKgWzqtD179piZmcEOopwqKysjIyNhp+gEcnNznz9/DjuFIrK3t9fS0oqNjcWvC1QKgWzqNEtLS9gplFZycnJCQgLsFJ1A79690QC5OStXrrxz5w5+7Xfpi2lmzJjx+vVr2QILBMK/f4rU1FTY0ZRKenq67IsddhAFNXbs2PLyctm/0eewBatWrZowYQJOC+p26b3CefPm0el0AoHQWA0JBIKFhQXsXMrG3t4e1cEWeHl5Ef6f7HMomxcOdi6FExgYiN+9iV26FHp6epqbm3++hUgkoqlTMHf16tWPHz/CTqG4pk6d2qNHj8+3aGpqoolqvubo6Kivr4/TqeQuXQoBAP7+/jQarfFHExMTPz8/qImU0JUrV6RSKewUisvMzGzQoEGfH6rq0aOHu7s71FAKytraGqcjhl29FI4bN67xxDGBQBg5ciS6pAZz06dP7+JLHrfKz8+v8d4yLS2tmTNnwk6koMaPH49KIV4CAgJkO4ampqbTpk2DHUcJ+fr6UigU2CkUmomJyZAhQ2Q7hqampjidGVAC2trarq6ueJxQQqUQjBkzxsTEhEAguLm56evrw46jbLhc7tmzZ2Gn6ARmzJhhZGREo9ECAwNhZ1Fo5ubm8fHxmDdLbvUZXJaosri+jqfMM81NGrn0oeShUy+fzGdKuwgRiUyka5OZBqpqdLl+/xUWFj58+HDOnDny7LSyuJ5dWl8vkMiz02+mObx/wMePH/XVnDrX55BCIWrqUbqZUIkkeXQ3ePDgDRs2rFixAttmW7mu8N7ZUnZpPU2LoqbRetFEFJmaOqnsI59EIZhZqzu6y28aqIKCgoyMDG9vb/l0x2WJH14u59eIDS1ponp0rkYe1DRIxXl1FBWC3QhNq/7yuL1yyZIlW7du1dXVxbDNlgrcjeAiK3vG0MnoNIJSeX6r/MWjakcPOVVDExMTExMT+fTFZYvvni4Z6d9dnYG+ueXK3k0HAHD/bJEqlWTSWw3v7mg0WmZmJrZHVJsdK0WGlvRy0rLoR8ewM0QRDJ7YraxA+E8CVz7dvXr1SraAqhxc2PF+7HfGqA7CMnqO0ZOIyvICId4d9evXD/PpL5suhWUfhBIJMLOhNfko0tk5j9bLfMqRzy2XGRkZ8pmONOVBlaOnLpFEkENfSHOcR+u9eFSFdy92dnYVFRXYttn09yerREhVl8shUAQGVXViTbWYXyNRp+P+LsttwayyjwJzW7RIIWSaepTCPD7evZiYmCQlJWHbZtOlsI4n1tBCF4IpM61uqjVVIjmUQmtra7y7kKkXSGloaAwblUYiUQhiUQOZguPuua6urlAo5PF4dDpmR/CaHiBLJUAq6boz1nQFIqEEAHmMJSMjIzH/Am9SvUDahWdZUiCCGokcPliDBg3C9sZ2dIk1gq8XL16UlJTAToEoGwKBgO3nCg0oEHxNmTIF2+u/EES2bDQqhUhnYmtrCzsCooTMzMwa57vFBBogI/g6e/YsWtsXwRyVSi0oKMCwQVQKEXylpKSgFZARzGlqanI4WN6pjQbICL6CgoLQGgkI5nR0dBgMLC8jRaUQwRdaCR7Bg4qKCrYz+6MBMoKvEydO5Ofnw06BKBt1dXU+H8vbWlApRPCVkJCA7TEdBAEAqKmpYXvgBZVCBF/z58//YllBBPl2FApFtr42VtCxQgRfgwcPhh0BUUIUCkUkEmHYIGZ7hRMmuR09dgCr1r6wbcfG2XOnAgA4nOqRHk4Rt651uKkvWhCLxTNn+7ScvKam5k1uThvbLy0tKSktbsszm/uLfftrVCinT58uKiqCnULRtf1jg8hQKJT+/ftj2GBXHyATCAQ6nUGlUlt4zvyF0//+O6ItrRUVFwbMnPj6Nbqi+F8xMTHousKWoY9Nx6Smpra8Hkm7dPUBMolEOnqklfXY6uvr29iaRCzG8L1RDgEBAd27d4edAhcNDQ0EAqHlLW2hOB+bjuWHhUAgYBgYy1JYU8Pb/vump09jNRla06fPmTTRV1ZHzp0/ER19v7yijMnUHeU1fu6cRSQSCQCw8ZdVJsZmZDI58s5NsUjk4jLsx+XrNDQ+LRMTHRN19tyfZWUl5mY9pNJm1+spKS0OCdmf+iJRRUW1V0/r77773rp3nzYGLiktDgicCACYGfjdvO++BwBcunwmPCKMx+NaWfWeO2fRAMeB0wO8q6rY4RFXwyOu6usb/HUpsoXW5gT5AgB+27LuNwBGj/Zet3ZzeXnZydMhiYlPa2trTEzMAmYEeXqMafyVd+9yl/04Lzc3R09P32/azAneU9r1GhMSnvwZeri4uNDAwHDiBN8pPv5tfOHyNGbMmDY8Cw6BQHD+QmhMTFRFZbm+fvdRXuMDA4JIJBKLVXn02B+JSU/FYnE/W/vFi1b06GEFADh4aFfc40erV24MOfZHUVHB3j0hPB73ty3rtv6298rV8zk5/8yYPue7oCUCgSD05JFH0ffq64UmxmZ+frPcR46S9VhWVhp66khy8vO6ulpLy15+02ZaW/f9+mPTcuyIW9eu37hcVlbSo0fPkW5ef105d+NalFgs9hrtsmD+0oAZc2VP+3nDCg6nOiT4jOyVNhkpNu7h5/mn+Qbevn193LjJSxZ/Wk+uqLhw5qzJ+/YedXRwxvndaDcHBwcMW8OyFP5979boUd7/W7E+Oub+gYM7Lcwt7ewcSCRSamri4CEjDLsb5+W9vnDxFJ3O8Js2U/YrYVcvuI8ctWP7gY8f8vfu38Zk6i1e9CMA4OGje9t3bHSwd/KbNrO0tPjS5TNGRk0sFcRiVS5b/p2RkcnSH1YTCISoqDs/rph/LOS8hYVlWwJra+ls3bL3ty3rZD+mvkg6ERrs4TFmkPOQpORn/Lo6AMDmX3ev/Wmpff8B03wDKSoqLbTG1NHdsH7b9h0bg+YudrB30tbWAQCIJeKcnH8mTfTVZGg9fhK9fcdGIyMTG+u+sl/Je/vG32+Wh/uYqAd39v+xQyDgT/P9cg3c5l6jvn73zVt+MjfrsWrlxvz8PBYL4/nNsRIWFubm5tatWzfYQb4kkUjWb1jxKjN9is90K8te7z+8Kyj8QCKRBALBytWLuVzOwgXLqarUy1fOrly9+Py5m3QNOgCgtrbm5OmQFT+uEwj4jg7OcY8fAQAOHt41/7sfvgtaYmxkKpVKN2z8X2lpcWBAkJaWTnp6ytZt6wUC/rixk1isyh+WzZVIJNP9Z2tr6bx8lVZZWc7Ucf36Y9OCs+dOnDl7fNCgoTOmz6murrpw8RSZ3Mr/4hYiyZ7wef66utpH0fcWLlgm21+Ji3uoqqrax6Yfdn94zLx8+VIqlRKJ2Bzlw7IUjvIa/9PaXwEAw4eN9PMfGxv3QFYKQ46cbdyJLS4pfBwf3VgKjY1N1/+8lUAg2Fj3ffwkOjnl+eJFPwqFwuAje+3sHPbsPiJ7P4qKCvLeNnFl+fkLodpaOvv2HJV9Grw8x82cPTny7s1lP6xuS2AqlTpsqFtjttLSYgCAzyS/vn3tvLzGyTZa9+5DJpOZTN1+/exbbk1FRaVXT2sAgKmpeeOTDbsbnTl1VdbF2LGTfKZ6Pn0a21gKR3mNn+4/GwAwwXvKsh/nnTl73Hv8lzuGzb3GKT7ThULh8OHuXp5j2/JiYbl9+7atra0ClsK4x4/S0lPWrN7UWBFkHjy8+/Hj+8b9oH79HAJmTrxx4685sxfIRjmrV260sfnPdDs+k/1Hj/60umls3MOXr9IuX7ytq6sHAPD0GMPn112/cXnc2Ennzp+orq46FXrF1NQcAND4K19/bJrD4VRfvHTKxWXY79s/nXArLy+VleMWPI6Pbi7S1/lHj54QcetackqCy6ChslI42GV4ywfTIVLQY4Wamp/Wk6RSqYaGxuUVZbIfq6rY586fSE5J4PG4AADZt+unZ6pSGyuRvn73zMwMAMCrzHQOp9p3aoCsDgIAiKSm551PTHxaXlE2znt44xaRSFRRXtax/C6DhtHpjB2/b1q2dI2Ly7CONfK1vLdvzpw9LjsoLpFI2GzW188hkUiTJvju3L359eusL3Zpm3uNht2N+va1u3DxJJWqNsF7ikqLe6wQTZo0SU9PD3aKJiQlP1NVVR096ssFmjMyUjVoGo3jQQOD7qam5q/ffDqnQaVSv6iDAABHx4GN/05IeCIWiwNmTmzcIpFIaDQNAEBi0lNHB2dZHeyYV5npIpFoovfUdv1WC5G+zm9j3dfcvEdUVKTLoKHFJUVvcnNmzZrf4cC46tu3L4at4XXahEgiSSQSAACbzVq4OFBNTf27oCWGhsanToUUFH5o8lcoZIpUKpF90QEADAwMW+2FXcUaPHj4wvnLPt/4+XvcLkymbvChU0eO7v95wwpb2/6/bPxdT+9b92VepCX/tG6Zg73T2jW/0tRpv2xeI21o+rgnU1dPNv76Yntzr5FAIOzccSj0ZPCx4weuXrvw809b+vdXxLt9fX19YUdoWhWbpcvUI331LVtTW6Oppf35FgZDk1X56fiDmpr6102pf7axqorFZOru33vs8yeQyGTZPsEAx0HfkpnL5QAAdNv5sWwhkoz6f1/U2DETT54K4dXw4uIeatA0Bg0c+i2Z8ZOVlaWge4VNunX7elUV+8jhM/r6BgCAbt0MmiuFjbQ0tQEA1dWtLyFIpzM4nOpv+Zr9gqmp+a7fD71IS/7l19W7dm/euydEtr3Df/Hz50MNDY13bD8gG96qUZtdLVv2enV0mF9sb+E1amhorPhxnZ/frE2/rNq4aeWVv+6qqzfxHxWuu3fvDho0iMn88nVBp6FBZ1c1sYeup9stK+vV51vYbJZ+N4M2NkunM6qrq/T1u6uqqraxx7ZjMvUAAKzKip5Wvb94qIUTqS1EapKX57g/TxyOiYmKi3s4YoQHhaKgK75he74b9+sKudxqLS1tWR0EAHC41a2WFUvLXkQi8eGjv79+iEymAABkA23Zjn1mZsbrN9mNT2j1Du0vWviC7LoZRwdnF5fhjZdVq1HVWKzKlpuVUVWlyj6pjVs43Gory16yOlhfX1/Hr2vubHhc3EM6nWFp2avtr1EoFMoOR07xmV5TW1OqkNfoXr58uaysg4cscOXg4Mzn8x9F32/cIhaLAQB9+9rxeNzs7EzZxrdvc4uKClo9itfI0XGgRCK5dfvfK+Qb3y9HB+cXL5I+v5Ra1uPXH5vmWPboSSaT79wN//ohEolEpzMq///sWUNDg2x01XKkJmlr67i4DLsSdv71m2wPD8W9AABbuO8V2ts73QwPO3X6aN++/ePjoxMTn0qlUg6nuvHA4tf09Q3Gjpl45254vVA4cOAQFqsyMfGJtjYTAECj0YwMjcOuXtDU1JrgPWXO7IUJCU/WrP3Bb9pMbW2dpKRnEqlk25Z9LeT5ooXPH8rO+ee3LT9NnuSnpqaelPSs8aKcfv0cHkXfu3T5DJ3O6NvHTnZdRZO6ddM37G4Udu0CVU2Ny+VM8Zlub+90//7tu39HMOiaV69f5PG47/PfNn6b3Y+K1NFhUqlqiUlPnz+PX75sm72euwAAIABJREFUrYqKioqKSlteo0gkmhM01c3Vy8LcMiLiqgZNw9DQuENvEb68vLx0dFo5KwqFl+e48Iiwnbt+zcn5x8qy17v8vNQXiX8eu+jpMfbipdObt/w0a+Z8IpF4/nyolpb2pInT2t7s7cgbx44fLCkt7tXTOi/vzZOnMWdOXaNSqbNmzn/2/PHSZUFTfKbr6DBTUhLU1NRXr9r49cemud03XV298eMmR9y69vOGFcOGutXU8OKfxDQ+OtB58IOoO44OzjrazLCrFz5+fN+zp3XLkZp7FR7uY7Zs/ZnJ1LXvP6D9f1r56Ux7hSOGu8+eNT884ur27RtEYtGR4DOmpuY3w6+0/FvLlq7xmeyX+iIp5Oj+f7JeWlr2anxow4btxsam96MiAQBGhsbBh0717Wt38dKpIyH7qjlVnh6tn079vIXPqVBUzEwtLl06HRoabGfnsHrVJtn2RQuXO9g7nb8QeunS6aLiluYQJxAIGzfuUFenBR/Ze+/+7aoq9ndzlzg7DT4cvOdQ8O4BjoM2/7KLxa5MS08BAKioqAbMmBv14M6RkH1FRQVrVm/ymezX9tfIF/Ad7J0fPvr7wKGdZAplx/YDinmab/bs2QYGbR1dypOqquq+vcdGj/J+8PDugUM7k5KfjRjuIRaLyWTynl1Hevfqc/TYH4eD95iamh/840Sr17g0olAoe3Yd8R7vEx19f/8fO16kJU2c4CsbFpiamh8+eMrKsteFiyePHv2jtKzE3t6pyY9NC+1/v2Tl1CkzcnL+ORy8Jzbu4efffz98v8re3mnnrl9/27quZ0/rAQMGtRqpObKrZ0a6jcLqUhU8YHtdOqHJ5pLusYUCYD9SEb/MEUzcOVHg7tetm2mbDh59i9jYWHt7ey2tZgcBWLmyr2Dg2G66Rri/IoUiu+r7xrUobJt9+zZ3/sIZR0POtf2GhUYXtr1duKMHCc8l4WUmTJgQHh7+9YmvjlHOG++Wr5ifn5/39fYhQ1x//um3b2k5IeHJ9t83NvlQ8KHTZmZo5vovhYaGbty4UQ6lUGnA/YyVlZVG3Lp69+8IB3unDtRBeSotLcVwgKycpfCXjb+LxE1M4NPCCdw2srd3+vP4pSYf0tNVuKuIFcGwYcNQHWwXuJ+xjwXvox7c8fAYMy/oe7z7+kYNDQ0Yjt+VsxTKrqrHA5VK7d6GCx6RRosXL4YdoZNp12fsx+U//bj8Jwx7d3ZyuRZ2D8MGcSKVSrGdOUJxj4kiyuHp06e1tbWwUyDKRiqVYnWUUAaVQgRfe/bsYbNbOiWKIB0gkUiwPbuNSiGCr6FDhzZOvIYgWMH2QKHSHitEFMeaNWtgR0CUkFgsbuN9hG2E9goRfMXHx2O7HA+CyOZnQqdNkM5kw4YNbV8RAUHaqL6+HtuJ6VApRPA1YsQIxbwjEOnURCIRtqUQHStE8LVt2zbYERAlJBKJWl3JoF3QXiGCI5FI9PDhQ9gpECWEBshIZ1JRUXHw4EHYKRAlVF9fr6mpiWGDTZdCKo1IInea5VCRDlCnk8mquL/FJBJp/PjxePcio6lHUZDVhLu0BqBjoELEv3rU1tbK424T7W4qpe/rMOwGUShSSUNhbq2OPu4rQ+nr68vtHmR1DVJlkUA+fSHNYZUIAQByWFa+trYW2+Urmi6FRj3V64UN4nr0HaucCnPrbAZhObhoTnFx8ZMnT+TQEQDA0o5eUYBKIWTFb+usnehteOK3qqurk0cpJBKB+zS96MuKuFYG8o0qi4TpMayR0+SxIGdycnJ0dLQcOgIAGFlRjSypz26Vy6c75GvZiRweq76/qzzmZKutraXRaBg22OzZ6G6mqq5Tdc9tyXMYydTUU1HTwHJYjsgfiUhgl9cLa8T5//D8V5nIp1NjY2N5LoJs76aVHlv9+HopsztVz5hKQCcF5YJEJFQUC/g8CadS6D2/u3w6FQgE2JbCpif0bySVghePqso+Cmq5Egx7VTRisbi6ugq/WQ4VAV2HTKEQDCzUbAczYGfBV2m+8O0rXh1PUlXeyW744/P5mJ8YlQNtPRWKKsHISq2ng/zm3Thw4ACTyZw1axZWDbZyjSKRCJy8tFt+jhJ4//79qlXbrl+/DjuIsomLizM1NbWwkOs6BwYWqgYWnXKFk/Dw8FevXi343ybYQToBNpvds2dPDBtEQwgER+fOneNwOLBTIEqIzWZju6gsKoUIjoYMGWJl1eyy0QjSYZiXQnQPMgAAEIlE9D8WD/PmzYMdoTOhUqlMJhN2is4B7RXi5c2bN7AjKBsulxsREQE7RWdSX19fUVEBO0XnYGhoiEoh9kgkkr6+PuwUyiYtLS0uLg52is5EVVUV2wtElFVZWVlpaSla5gl7VCr13bt3sFMoGwaD4efnBztFJ4OWxGqLwsJCY2NjbNtExwoBAEBNTc3U1BR2CmXj4OAAO0Ino66uzmAo+VWfmCgoKDAxwfg2AbRXCGQfwZycHD6fDzuIUrlw4UJlZSXsFJ2Jmpra+/fvYafoBPDYK0Sl8BNHR8eqqirYKZSHUCgMCQnR1dWFHaQzodPp2J4KUFaoFOJIKpV++PABdgrlUVNTs3fvXtgpOhkmk/nixQvYKToBHo+H+S1MqBR+Ym5ujsYmGGIymUOGDIGdopPR1dVFhxRaJRaLU1NTMb8QGJXCT/r06YNuEcPQ2bNn8/LyYKfofJycnMrKymCnUGhZWVk2NjaYN4tK4SfW1taPHj2CnUJ5BAcH9+jRA3aKzkdFRQV9hbQsKyurT58+mDeLSuEnPXr0YLFYaMcQE9XV1SdOnCAS0aer3Xr06JGfnw87hULLzs5Ge4X4Gj169KtXr2CnUAZaWlr29vawU3RK1tbWOTk5sFMotNra2n79+mHeLCqF/7K3t7979y7sFMpgzZo16MqkjrGzs8vIyICdQnEVFhbm5uaamZlh3jIqhf/y9PRE65d/u4yMDBaLpa2t/DP+4sHQ0JBGo7FYLNhBFNSzZ89wujIBlcJ/kUgkf39/ua3QpqwsLS2PHDkCO0UnZmNj8/TpU9gpFNTTp0+HDh2KR8uoFP6Hh4fHmTNnYKfo3EgkkpqaGuwUndjIkSNjYmJgp1BQqBTKib29vVAozMrKgh2ks4qIiNizZw/sFJ3biBEj3r9/L5Eo88JqHRMfHz9hwgQCPgvOo1L4pTlz5ty/fx92is4qKSkpKCgIdopOb8CAAbdu3YKdQuFcvXrV09MTp8ZRKfySp6dnYmJibm4u7CCd0vbt2zGfPakL8vPzCwsLg51CsZSXl+fm5uI0OkalsGmrV6/et28f7BSdT3x8PJp5FBO9evUyMjLKzMyEHUSB3Lx508fHB7/2USlsgpOTk7q6OpqMvl0eP35848YNNMcUVnx9fY8ePQo7hQLJyspCpRCCTZs2HTx4EHaKzkQkEm3ZsgV2CuXh4uIilUqTkpJgB1EIERERTCZTT08Pvy4IDQ0N+LXeqUVGRqakpGzevBl2EKSLys7OPn369O7du2EHgW/cuHGnT5/GdS02tFfYLG9vbz6fj+4/aZVYLMZ15NJl2djY6OjoXL16FXYQyMLDw4cMGYL3mpSoFLZk165d169fF4lEsIMotOPHj//000+wUyindevWHTlyhMfjwQ4C0/379xcuXIh3L2iA3Ir8/Pw1a9Zcu3YNdhCki0pMTIyNje2yXzYnT54UCoXff/893h2hvcJWWFhYLFiwYP369bCDKCh01RHeBg0aRCaTL126BDsIBGw2+6+//pJDHUSlsE1Gjx5taGiI7k3+2rJlywYPHgw7hfJbtWpVREREF5zdeuvWrZs2bZJPX2iA3FY///yzp6enh4cH7CCKoq6uTiqVamhowA7SJXA4nDVr1vz555+wg8jPs2fPnjx5snbtWvl0h0phOyxYsGDJkiWOjo6wg8BXW1ubn59va2sLO0gXkpKSEhoaeuzYMdhB5EEsFg8bNiwhIUFuPaIBcjucOHFix44daI1QsVjs7u6O6qCcOTk5eXp6hoSEwA4iD8uWLTt06JA8e0SlsH2uXbu2b98+LpcLOwhMmZmZsbGxsFN0Rb6+vjU1NVeuXIEdBF/Xr193dHQcOHCgPDtFA+SOcHNzu337Np1Ohx0Ego8fP2pqampqasIO0nX973//8/HxGTFiBOwguEhPTz98+PDJkyfl3C8qhR00fPjwe/fu0Wg02EHkau/evUZGRjNmzIAdpKtbtWrVokWLevXqBTsIxgQCgYeHB5T1DFAp7Lj58+fv3r2768zFUl5eLhaLDQ0NYQdBAABg8uTJhw8fVrLZIVetWrVs2TJzc3P5d42OFXZcaGjo1KlTS0tLYQeRBzabLRKJUB1UHOHh4bt27VKmCSKXLl06bdo0KHUQlcJvFRMTM2/evPz8fNhB8BUZGXnw4EEjIyPYQZD/CA4OnjJlinKsFPrbb7+NGjXKxcUFVgA0QMZAQEDA2rVr7e3tYQfBBZvNZrPZVlZWsIMgTZs/f/7+/fsZDIbsx9GjR3e6xXlOnjxJo9GmT58OMQPaK8TApUuXgoODHz16BDsI9iIjI3V0dFAdVGShoaGLFi3icDiys3ksFuvAgQOwQ7VDcHCwUCiEWwdRKcRMaGjo/fv3lWxquXfv3qWnp8NOgbTu8uXLPj4+bm5ufD5ftlgw7ERtdfjw4f79+8tnwoWWoVKImd27d799+1Zp7hIVCAQ1NTUbN26EHQRpk4aGhpqaGtm/q6ur09LSYCdq3Y0bN0Qi0fDhw2EHAagUYmzdunVUKlUJyse2bdsAAHZ2drCDIG3i5ub2+fSubDY7JiYGaqLWnT17lsPhrFy5EnaQT1ApxNjs2bOHDh26fPly2EE6LjIy0tbWlkqlwg6CtMnUqVP5fP4X5z/j4+PhJWrd6dOnORxOUFAQ7CD/IqFljDDXs2dPQ0PDoKAgPz8/EokEO077SCQSdXX1QYMGwQ6CtJW/vz+DwWhoaJBKpQKBQCKREAgEAoHQp08fxbz+KTQ0lM/nL1u2DHaQ/0AX0+ClvLx80qRJly5dsrCwgJ2lTerr693c3J49ewY7iBIS1Ek5FaIGgO//tfLy8qysrLS0tJKSEhaLNXz48Llz5+LaYwfExcWxWKwpU6bIrUcymahrqAIIrTwNlUJ8rV69euLEiY13zru4uMycOXPp0qWwc4Hz588fPXq0sfAJBIKMjAx7e3tVVVXY0ZTKx5y6tJjqsgKBcU8ajy2n9cKkDVKJREohk+XTXbuIxCIKmSLPHuk6lHcveb2dGCP99MiUZisiKoW4+9///ufs7BwQEODu7s7lco2NjcPCwlRUVOCm8vX1ff/+vbq6+uPHj8PDw52dnRVzMNWp5WfWpj6qdp3WnUpDB+UhK/sgeHytJPBnM1W1pt8L9A7h7o8//igpKRk6dKhslsPKykroZ/diY2MrKytlk/K7u7tnZmaiOoi5D9l1qY+qR881QnVQEeibUScuMT2/rdl5l9GbJA+PHz8WCoWyf/P5/LCwMLh5bt261XgNGpfLTUpKgptHKaXHcVz9usNOgfxLVZ1k766b+rCqyUdRKcTd1KlTi4qKGn8kEAhFRUUZGRmw8uTm5ubk5Hy+pbi42N/fH1YepSSok5Z/5FPV0f8vxaKhSS56y2/yIfRW4Y7FYn1xQLaysjIiIgJWntu3b5eVlTX+2NDQ0NDQ8PkW5NtxKkTGPbvWtL6dAkNXpUHa9JkTRTzHpGRiY2NDQkJSUlKqqqqqq6tlRwyTk5MrKyt1dXXlHKauru7JkycEAgEAQKfTGQxGt27d+vXr5+DgIOckyq0BNHCr5HS+GGm7hoYGLqu+yYdQKcRX8Vt+eYHQ1sDPfPhUiVTMrqipra2rq60ViURxfwkBKGpDGxhzMlo6xEJVXV1dXV1dR49GJlFomiSaiFyUxzeyUpN/HgRRBKgU4qLoreBlPOdDdq0aXUWVrkpWIZFVKGRVio6RJvTp//t9tpAYgUCorxfXlUlKPooyE2prqwSmNhp2wxgmvVBNRLoWVAoxxiqpj7laWS8kqOmo9xyqQ6J0pqOxUkkDt7z2SSSHRGC7TdXtZoout0a6ClQKsRRzjf3uFa+bFVNXt1PuVRFJBK3uGlrdNWrYgjuny016qXnOkPfRTASBojPtsyi4a4eKq9gESxdjeuesg5/T0KFaDDSsqaP8tbcQdhYEkQdUCrERdqBIVZuhY8KAHQRLWoYaDEPti7sKcZ5GAEHgQ6UQAxd+/0jT01KCncGvqWtTmRa6p3/7ADsIguALlcJv9ffZMrq+Jk1HaSc6pdIpuhY6EcdKYAdBEByhUvhNshO5AgFZs7sG7CD4ondTbyCrZsRxYAdBELygUvhN4m5UaBoq1fHB5mgZacaHV8BOgSB4QaWw45Lus5kmmkRyV/kbdu+l/SSiEnYKBMFFV/lvjIc3aXW6PbRhp2hCYkrE6k2DuFyMyxbTXOt9tkAixrZVRFHU1NS8yc1pwxOVEyqFHfTxdV0DkE1r0IUQSKT8f2pgp0BwMX/h9L//hjZhEnSoFHZQXnqturY67BTyRtNRz02vhZ0CwUV9fdNTtigOXFcfQaWwgzgssWY3XCakq68XRNz9Y/POMRu2jjxwdG76qwey7Y+fXT50fF76q4e//zF1/RbXI6GLyiv+nZ28qPj1kdBF634bvmO/z8t/ovEIBgBg6NNqqtAIGS9p6SnfL507euyQ6QHeu3b/xmJVAgCiY6JGejjFP/m0CITsx4SEJ7IfI25dC5w1efTYIXOCfM+dD22cLF0gEJwIDQ4InOg12mXmbJ9z50MlEklKauJID6esrFeNPY4dP+zPE4cBANMDvKuq2OERV0d6OE0P8G5sJPjIPp+pXuMnjFi8ZFZ0TFSrL0EgEBwJ2e/rN2b8hBGbfll94ODOLVt/BgC00DUAoKS0eNMvq8d5D588xXPtT0tzXmfJth88tGuK76hnzx7PnO0z0sPpZnjY568dAHDnbvhIDyeBQPDNf3t0D3JHFeXV2pp3w7xZqVR66uKqqqoS9xFzNDR03r5LvRC2UVjPHzRgIgDgY2Fm3NOL0yatl0jE1279/teNLcsXnQIAlFW8P3pqCU1da5zX9yQi+UHsScyDyRBJhMoigUjYQFHtYocG8Jf6Imndz8u9PMf5TPbncTnXb1xeuXrx8aMX3EeOevDw7pGQfc5Og2traw4c3Ok93sfFZRgA4MzZP69euzDFZ7qZWY+CgvdXws4VFn1cv26LRCJZv2HFq8z0KT7TrSx7vf/wrqDwQ8tLcm/+dffan5ba9x8wzTeQoqIi+yhu2Pi/0tLiwIAgLS2d9PSUrdvWCwT8cWMnNdeI7FfS0lMmTfTtY9Pv9Zvsm+FXXEd4tPzCWazKZcu/MzIyWfrDagKBEBV158cV84+FnLewsAQA1NbWnDwdsuLHdQIBf+gQ14hbV+9HRcpePgDg8eNHtrb9qVQMrupFpbAj+DUSiiqx1ZVVO+BVVkz++/T1q8I1GXoAAEe70cL6uifPr8hKIQAgKHAvg84EAAxz8bt972BtHYemrnnn/mECgbhs0UkNmjYAgEAk3ri9G/twAAAAVNTItVyxlp5c12/sCg4H75ngPWX5srWyH52cXOYE+SanPB8+bOSK5euC5k07fyH0XX4eg874fslKAEBlZcXFS6c2btjeWGuYTL0/Dvy+9IfVKSkJaekpa1ZvaqFsfcG6dx8ymcxk6vbrZy/b8jg++uWrtMsXb+vq6gEAPD3G8Pl1129cbqHNhIQnL9KSFy1cPt1/NgDAy2tc6ovEVrs+fyFUW0tn356jZDIZAODlOW7m7MmRd28u+2G1bNi+euVGGxtb2ZPHjpl46vRRLo/LoDO4PO6LtOQfvl/VxtfYMlQKO6KOI9HQwmUCq+zXTyVS8Y79Po1bpFKJGvXfS7hVVT7d3qet1R0AwOVWUMiqr/MSBjtPldVBAACJiOPbqs6g1HElqBRiq6qK/eFDflFRQeSdm59vLy8vAwDo6xvM++6H4CN7iUTioQOhampqAIDU1ESxWLx9x8btOzbKniw7lFZZUZ6U/ExVVXX0KO9viZSQ8EQsFgfMnNi4RSKR0Ggt3U2QmpYEAJjgPbVdHSUmPi2vKBvnPbxxi0gkqij/tMIElUptrIOyQhl68khMTNSkib5Pn8Y2NDSMdPNqV3fNQaWwI4hkgrAOl0NmvBoWg667OOjIf7prqrSRSRRZoeTyKiUSsY62nBZXEwokxJZGWkhH8HhcAMCc2QtHDHf/fLuOzqdJ0kaP8j7+50Erq959+9rJtrDYlQCAHdsPdNPT//xXDA2Nq9gsXaZeyyPiVlVVsZhM3f17j32+kdTiMvM8HldDQ4NGa98xdHYVa/Dg4QvnL/t8Y2PNVVP7z8lJJlPX2Xnw/ajISRN9Y+MeDhgwSFNTq13dNQeVwo6gaZKEfFxKoboao6a2SlurO4XS1r1O2c5gTU3TSxpiTiSQ0DTRxwZjsv/wQqHA1NS8ySf8eeIQmUzOzs68czd8/LjJAAA6/dNtTl//ioYGnV3F+rqRVi/++vwULZ3OqK6u0tfvrqra1o+iLlOvpqaGz+fL9lvb2DWdzuBwqpt74V8bN3bSL7+uycp69eJF0trVv7Txt1qFziB3hAqV2NAApBLsT+1bWTpLpZJnSdcbtwjrm16rsBGVStNlmmT880gslse6QvV1YhoDlUKM6erq6esb/H3vFp//6e0Wi8Ui0ac39EVa8u3IGz98v2rSRN/gI3s/fnwPAHBwcCYQCDfDrzQ20vi7Dg7OfD7/UfT9xofEYjEAQFtLBwBQyfp0AyWLVdnYBQBAjaomO2ct4+g4UCKR3Lp97ev2m9Orlw0A4O7d8K8faqFrR8eBmZkZr99kt7GjwS7DNTW1tv++iUwmDx3q1nKktiNt3rwZq7a6lIJcAVFFlayK8VjRoFuPN28TU9Lu1NVxeDXslLQ7NyP3ujj5kEjkDwWZr/MSPEbMJZMpAICKyo9pr6IGO/sw6Lrqaoyk1FvZb55JJeLC4pzHzy7X1XFchwaqqmJ85aNIICE21NsO6RK3XX+LGo74Q3ZdT8e2/qEIBIK+fve7dyOePX/c0ACysl4dOrxbJBb16dOPz+evW7fMwsJy+dI1DvbOj6LvPXsWN3bMRG0tbR6PFxV1501utlAoTEh8umPnJgcHZyZT18ysx/OE+Dt3bvJ43Co268HDuydCD3uPn8JgaEY9iHz9Osvc3PL9h3d79m5hsSttbfsPGDAIAJCb+zr+STSZTH7/4R2FTHFwcE5OSbgfFcnhVldVse/djzwcvNt7/BRy82NkU1Pzx/GPHj66x+FWV1dVPXz0d1LSM1NTc1dXTzqd0VzXPXr0fPDw7oMHdyUSSUHhh4sXT8XFP3IfOVp2GPHDh3x/v1mf90IkEktLi1NSEoYPG+npObZd74uQL81/xes/ookxNSqFHcRl1ZcX1tN0MJ6jkEgk2dl68Pm8jMyHL7NiBILagQMmWJjZE4nEFkphdwMrmrpW7rvkzJw4DqfC2LB3cWkuHqWwqpCnb0Qys+ly15a3V3tLIQDAzNTCunefly/Toh7cyc7JtOzR08trPJOpe/TYH2npKTt3HNTS0iaTyTY2tpcun6mtrRk4cIiz82B1ddrz5/HRMfcLiz4OHeI6ZPAINTU1Mpns6urF4VTHxj14+iyWw612c/Xq06cfhUKxtbVPSn4edvVCbm7O3NmLnj1/bGNtKyuFffva5eW9fvDwbm5ujrV1XwsLSzdXr5oabmzsg8fx0bV1NWPHTOrXz55IbHYoSSAQBrsMLykpio+PTklJUKfRamp4+t0MXF09iURic10z6IyhQ1w/fMx/8OBOcspzGk1j/LjJ5uY9miuFAAAOp/rJ09j53/3Q9mG1TAulkIDrBdxKrKJQeOdUmbmzEewgcvXxRYmHPxOtEdqq0g+CuOuV4+YZww4CWdA8Pwtzy182/Y5tszdu/HXm7PHr16IolPZdycBli6IvFs/aaPb1Q+igTwfpGavStSkigYRCbXaMvG3vRIGwidvUzEz6fSh49fV2mprmzytvYBjySOiikrK8r7drMfSruWXtDSARNaiqE1Ed7OJOhAZ/fgCxEYOuefEC7rcwv3qVfj8q8n5U5MzAee2tgy1DpbDj7IZpJD1kGdk2e8/JD/P/bGiQNvFAAwEQmtgZJxAwPos102+bRNLEuRSxWCQbZbcrQHkey84Fl3sNkU7Ez2+Wt/eUr7cTsf70Nik55fmrzPTFi1ZM8fHHtmVUCjuupwM98X41n1uvxlBp8gnaWgZyD/UfsltWMFFfJxZw+X2H6LfhuYgy02RoajI02/jk0yfDsO39u6Al3wUtwbZNGXQxzTfx8NerKefCTiEP3FKOuz9mhRVBFA0qhd+kuwW1V39qea6Sz+1c8Y5takUxs0GjY0RpoVL4rfqP0NQzIJa9YcMOgpfyt9UMRsPA0Yo4XzeCYAWVQgyM9NMz600uz1PCaliZX6VvCEbPwn46MgRRKKgUYsNljLaFNbkkq1xcL4GdBRtSsbQsl2VoSnCdwoSdBUFwh84gY8bZS1vfhH/vXJGmgYa+lQ4esxnKTXleFbuA4xVoYNkfHR9EugRUCrFkaq22cIdF6qPql/GFKjRVDT11RjdaJ1oKiltex6uoFdXV9xlE91tmCTsOgsgPKoXYG+Ch5eiu9SaV9zq1JuthOU1blUgmklXIFDWKRKRYw2eyCqm+TiSpF4vrJXXceiMrmuMImrWTgVyulkUQBYJKIS4IBNDbid7biQ4AqCyur+WIa7licX2DSKhYu4gUVSKZQqYxyOoMkp4xLvNyI0ingEoh7nQNVXQNm74dBUEQBYEGQgiCPSKRwGCi5V8UD4Gg08x+CSqFCII9XUOV/Fc82CmQL7GLBURi0wepUClEEOwRSQRLOzq7RAg7CPIfXFa9mXXTEw+jUogguBg2SfdpYWxFAAAAkElEQVTBhWLYKZB/vUnhln3g93FpempxNIs1guCljic5/Wu+67TudB2Klp4K+r8GRYMUVBYLKgsFlUX8CQsNm3saKoUIgqMGKXgWyfqYU0siE1nFaLwMgYE5tQGAnv01+g1vaZpFVAoRBEHQsUIEQRBUChEEQVApRBAEAagUIgiCAFQKEQRBACqFCIIgAADwf+raP/3ZyrXiAAAAAElFTkSuQmCC", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Example usage\n", "agent = SQLAgent()\n", "agent.setup_database_connection(\"mysql+pymysql://admin:9522359448@mydatabase.cf8u2cy0a4h6.us-east-1.rds.amazonaws.com:3306/mydb\")" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['customers', 'employees', 'orders']\n", "\n", "CREATE TABLE customers (\n", "\tcustomer_id BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\tphone VARCHAR(50), \n", "\tPRIMARY KEY (customer_id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from customers table:\n", "customer_id\tfirst_name\tlast_name\temail\tphone\n", "1\tJohn\tDoe\tjohn.doe@example.com\t1234567890\n", "2\tJane\tSmith\tjane.smith@example.com\t9876543210\n", "3\tEmily\tDavis\temily.davis@example.com\t4567891230\n", "*/\n", "CREATE TABLE employees (\n", "\tid BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\thire_date DATE NOT NULL, \n", "\tsalary DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from employees table:\n", "id\tfirst_name\tlast_name\temail\thire_date\tsalary\n", "1\tJohn\tDoe\tjohnD@abc.com\t2020-01-01\t50000.00\n", "2\tJane\tDoe\tJaneDabc.com\t2020-05-01\t60000.00\n", "3\tTom\tSmith\ttoms@abc.com\t2020-03-01\t70000.00\n", "*/\n", "CREATE TABLE orders (\n", "\torder_id BIGINT NOT NULL, \n", "\torder_date DATE NOT NULL, \n", "\tcustomer_id BIGINT NOT NULL, \n", "\tamount DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (order_id), \n", "\tCONSTRAINT orders_ibfk_1 FOREIGN KEY(customer_id) REFERENCES customers (customer_id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from orders table:\n", "order_id\torder_date\tcustomer_id\tamount\n", "1\t2020-01-01\t1\t1000.00\n", "2\t2020-02-01\t2\t2000.00\n", "3\t2020-03-01\t3\t3000.00\n", "*/\n", "Please provide a question about the tables.\n" ] } ], "source": [ "\n", "response = agent.execute_query(\"List all the tables present\")\n", "print(response) # Should return the list of tables" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['customers', 'employees', 'orders']\n", "\n", "CREATE TABLE customers (\n", "\tcustomer_id BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\tphone VARCHAR(50), \n", "\tPRIMARY KEY (customer_id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from customers table:\n", "customer_id\tfirst_name\tlast_name\temail\tphone\n", "1\tJohn\tDoe\tjohn.doe@example.com\t1234567890\n", "2\tJane\tSmith\tjane.smith@example.com\t9876543210\n", "3\tEmily\tDavis\temily.davis@example.com\t4567891230\n", "*/\n", "CREATE TABLE employees (\n", "\tid BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\thire_date DATE NOT NULL, \n", "\tsalary DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from employees table:\n", "id\tfirst_name\tlast_name\temail\thire_date\tsalary\n", "1\tJohn\tDoe\tjohnD@abc.com\t2020-01-01\t50000.00\n", "2\tJane\tDoe\tJaneDabc.com\t2020-05-01\t60000.00\n", "3\tTom\tSmith\ttoms@abc.com\t2020-03-01\t70000.00\n", "*/\n", "CREATE TABLE orders (\n", "\torder_id BIGINT NOT NULL, \n", "\torder_date DATE NOT NULL, \n", "\tcustomer_id BIGINT NOT NULL, \n", "\tamount DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (order_id), \n", "\tCONSTRAINT orders_ibfk_1 FOREIGN KEY(customer_id) REFERENCES customers (customer_id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from orders table:\n", "order_id\torder_date\tcustomer_id\tamount\n", "1\t2020-01-01\t1\t1000.00\n", "2\t2020-02-01\t2\t2000.00\n", "3\t2020-03-01\t3\t3000.00\n", "*/\n", "Not relevent to database.\n", "Please ask a question that pertains to database operations, such as querying tables, retrieving data, or understanding the database schema. I'm here to help with all your database-related queries!\n" ] } ], "source": [ "\n", "\n", "\n", "# # Non-database related query\n", "# response = agent.execute_query(\"Capital of france?\")\n", "# print(response) # Should return a direct answer from the LLM\n", "\n", "# Database related query\n", "response = agent.execute_query(\"Hi\")\n", "print(response) # Should return the result from the SQL workflow" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['customers', 'employees', 'orders']\n", "\n", "CREATE TABLE customers (\n", "\tcustomer_id BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\tphone VARCHAR(50), \n", "\tPRIMARY KEY (customer_id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from customers table:\n", "customer_id\tfirst_name\tlast_name\temail\tphone\n", "1\tJohn\tDoe\tjohn.doe@example.com\t1234567890\n", "2\tJane\tSmith\tjane.smith@example.com\t9876543210\n", "3\tEmily\tDavis\temily.davis@example.com\t4567891230\n", "*/\n", "\n", "CREATE TABLE employees (\n", "\tid BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\thire_date DATE NOT NULL, \n", "\tsalary DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from employees table:\n", "id\tfirst_name\tlast_name\temail\thire_date\tsalary\n", "1\tJohn\tDoe\tjohnD@abc.com\t2020-01-01\t50000.00\n", "2\tJane\tDoe\tJaneDabc.com\t2020-05-01\t60000.00\n", "3\tTom\tSmith\ttoms@abc.com\t2020-03-01\t70000.00\n", "*/\n", "\n", "CREATE TABLE orders (\n", "\torder_id BIGINT NOT NULL, \n", "\torder_date DATE NOT NULL, \n", "\tcustomer_id BIGINT NOT NULL, \n", "\tamount DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (order_id), \n", "\tCONSTRAINT orders_ibfk_1 FOREIGN KEY(customer_id) REFERENCES customers (customer_id)\n", ")ENGINE=InnoDB COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4\n", "\n", "/*\n", "3 rows from orders table:\n", "order_id\torder_date\tcustomer_id\tamount\n", "1\t2020-01-01\t1\t1000.00\n", "2\t2020-02-01\t2\t2000.00\n", "3\t2020-03-01\t3\t3000.00\n", "*/\n" ] } ], "source": [ "# print(agent.list_tables_tool(\"\"))\n", "tables = agent.list_tables_tool(\"\")\n", "table_list= tables.split(\", \")\n", "print(table_list)\n", "# print(agent.get_schema_tool.invoke(table_list[0]))\n", "for table in table_list:\n", " print(agent.get_schema_tool.invoke(table))\n", "# print(agent.get_schema_tool(agent.get_schema_tool.invoke(table) for table in table_list ))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "tables_list = tables.split(\", \")\n", "print(tables_list)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "ename": "ValidationError", "evalue": "1 validation error for _ListSQLDatabaseToolInput\n Input should be a valid dictionary or instance of _ListSQLDatabaseToolInput [type=model_type, input_value={''}, input_type=set]\n For further information visit https://errors.pydantic.dev/2.10/v/model_type", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mValidationError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[13], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43magent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute_query\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mHow many users are in the database?\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(response) \u001b[38;5;66;03m# Should return the result from the SQL workflow\u001b[39;00m\n", "Cell \u001b[1;32mIn[11], line 255\u001b[0m, in \u001b[0;36mSQLAgent.execute_query\u001b[1;34m(self, query)\u001b[0m\n\u001b[0;32m 252\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWorkflow not initialized. Please set up the connection first.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 254\u001b[0m \u001b[38;5;66;03m# Check if the query is relevant to the database\u001b[39;00m\n\u001b[1;32m--> 255\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mis_query_relevant\u001b[49m\u001b[43m(\u001b[49m\u001b[43mquery\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[0;32m 256\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNot relevent to database.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 257\u001b[0m \u001b[38;5;66;03m# If not relevant, let the LLM answer the question directly\u001b[39;00m\n", "Cell \u001b[1;32mIn[11], line 225\u001b[0m, in \u001b[0;36mSQLAgent.is_query_relevant\u001b[1;34m(self, query)\u001b[0m\n\u001b[0;32m 223\u001b[0m \u001b[38;5;66;03m# Retrieve the schema of the relevant tables\u001b[39;00m\n\u001b[0;32m 224\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlist_tables_tool:\n\u001b[1;32m--> 225\u001b[0m relevant_tables \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlist_tables_tool\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 226\u001b[0m \u001b[38;5;28mprint\u001b[39m(relevant_tables)\n\u001b[0;32m 228\u001b[0m \u001b[38;5;66;03m# if self.get_schema_tool:\u001b[39;00m\n\u001b[0;32m 229\u001b[0m \u001b[38;5;66;03m# schema_response = self.get_schema_tool.invoke({})\u001b[39;00m\n\u001b[0;32m 230\u001b[0m \u001b[38;5;66;03m# table_schema = schema_response.content # Assuming this returns the schema as a string\u001b[39;00m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\tools\\base.py:500\u001b[0m, in \u001b[0;36mBaseTool.invoke\u001b[1;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[0;32m 493\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21minvoke\u001b[39m(\n\u001b[0;32m 494\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 495\u001b[0m \u001b[38;5;28minput\u001b[39m: Union[\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;28mdict\u001b[39m, ToolCall],\n\u001b[0;32m 496\u001b[0m config: Optional[RunnableConfig] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m 497\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any,\n\u001b[0;32m 498\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[0;32m 499\u001b[0m tool_input, kwargs \u001b[38;5;241m=\u001b[39m _prep_run_args(\u001b[38;5;28minput\u001b[39m, config, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m--> 500\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtool_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\tools\\base.py:754\u001b[0m, in \u001b[0;36mBaseTool.run\u001b[1;34m(self, tool_input, verbose, start_color, color, callbacks, tags, metadata, run_name, run_id, config, tool_call_id, **kwargs)\u001b[0m\n\u001b[0;32m 752\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m error_to_raise:\n\u001b[0;32m 753\u001b[0m run_manager\u001b[38;5;241m.\u001b[39mon_tool_error(error_to_raise)\n\u001b[1;32m--> 754\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m error_to_raise\n\u001b[0;32m 755\u001b[0m output \u001b[38;5;241m=\u001b[39m _format_output(content, artifact, tool_call_id, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mname, status)\n\u001b[0;32m 756\u001b[0m run_manager\u001b[38;5;241m.\u001b[39mon_tool_end(output, color\u001b[38;5;241m=\u001b[39mcolor, name\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mname, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\tools\\base.py:718\u001b[0m, in \u001b[0;36mBaseTool.run\u001b[1;34m(self, tool_input, verbose, start_color, color, callbacks, tags, metadata, run_name, run_id, config, tool_call_id, **kwargs)\u001b[0m\n\u001b[0;32m 716\u001b[0m context \u001b[38;5;241m=\u001b[39m copy_context()\n\u001b[0;32m 717\u001b[0m context\u001b[38;5;241m.\u001b[39mrun(_set_config_context, child_config)\n\u001b[1;32m--> 718\u001b[0m tool_args, tool_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_to_args_and_kwargs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtool_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtool_call_id\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 719\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m signature(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_run)\u001b[38;5;241m.\u001b[39mparameters\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrun_manager\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m 720\u001b[0m tool_kwargs \u001b[38;5;241m=\u001b[39m tool_kwargs \u001b[38;5;241m|\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrun_manager\u001b[39m\u001b[38;5;124m\"\u001b[39m: run_manager}\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\tools\\base.py:640\u001b[0m, in \u001b[0;36mBaseTool._to_args_and_kwargs\u001b[1;34m(self, tool_input, tool_call_id)\u001b[0m\n\u001b[0;32m 632\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[0;32m 633\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39margs_schema \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 634\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39margs_schema, \u001b[38;5;28mtype\u001b[39m)\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 637\u001b[0m ):\n\u001b[0;32m 638\u001b[0m \u001b[38;5;66;03m# StructuredTool with no args\u001b[39;00m\n\u001b[0;32m 639\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m (), {}\n\u001b[1;32m--> 640\u001b[0m tool_input \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_parse_input\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtool_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtool_call_id\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 641\u001b[0m \u001b[38;5;66;03m# For backwards compatibility, if run_input is a string,\u001b[39;00m\n\u001b[0;32m 642\u001b[0m \u001b[38;5;66;03m# pass as a positional argument.\u001b[39;00m\n\u001b[0;32m 643\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tool_input, \u001b[38;5;28mstr\u001b[39m):\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\tools\\base.py:556\u001b[0m, in \u001b[0;36mBaseTool._parse_input\u001b[1;34m(self, tool_input, tool_call_id)\u001b[0m\n\u001b[0;32m 554\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(msg)\n\u001b[0;32m 555\u001b[0m tool_input[k] \u001b[38;5;241m=\u001b[39m tool_call_id\n\u001b[1;32m--> 556\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43minput_args\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel_validate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtool_input\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 557\u001b[0m result_dict \u001b[38;5;241m=\u001b[39m result\u001b[38;5;241m.\u001b[39mmodel_dump()\n\u001b[0;32m 558\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(input_args, BaseModelV1):\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\pydantic\\main.py:627\u001b[0m, in \u001b[0;36mBaseModel.model_validate\u001b[1;34m(cls, obj, strict, from_attributes, context)\u001b[0m\n\u001b[0;32m 625\u001b[0m \u001b[38;5;66;03m# `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks\u001b[39;00m\n\u001b[0;32m 626\u001b[0m __tracebackhide__ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m--> 627\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__pydantic_validator__\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalidate_python\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 628\u001b[0m \u001b[43m \u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstrict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstrict\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfrom_attributes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfrom_attributes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcontext\u001b[49m\n\u001b[0;32m 629\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[1;31mValidationError\u001b[0m: 1 validation error for _ListSQLDatabaseToolInput\n Input should be a valid dictionary or instance of _ListSQLDatabaseToolInput [type=model_type, input_value={''}, input_type=set]\n For further information visit https://errors.pydantic.dev/2.10/v/model_type" ] } ], "source": [ "response = agent.execute_query(\"How many users are in the database?\")\n", "print(response) # Should return the result from the SQL workflow" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Creating Visualizer agent \n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: pandas in c:\\code\\aiagents\\aiagents\\lib\\site-packages (2.2.3)\n", "Collecting matplotlib\n", " Downloading matplotlib-3.10.1-cp312-cp312-win_amd64.whl.metadata (11 kB)\n", "Requirement already satisfied: numpy>=1.26.0 in c:\\code\\aiagents\\aiagents\\lib\\site-packages (from pandas) (2.2.1)\n", "Requirement already satisfied: python-dateutil>=2.8.2 in c:\\code\\aiagents\\aiagents\\lib\\site-packages (from pandas) (2.9.0.post0)\n", "Requirement already satisfied: pytz>=2020.1 in c:\\code\\aiagents\\aiagents\\lib\\site-packages (from pandas) (2024.2)\n", "Requirement already satisfied: tzdata>=2022.7 in c:\\code\\aiagents\\aiagents\\lib\\site-packages (from pandas) (2024.2)\n", "Collecting contourpy>=1.0.1 (from matplotlib)\n", " Using cached contourpy-1.3.1-cp312-cp312-win_amd64.whl.metadata (5.4 kB)\n", "Collecting cycler>=0.10 (from matplotlib)\n", " Using cached cycler-0.12.1-py3-none-any.whl.metadata (3.8 kB)\n", "Collecting fonttools>=4.22.0 (from matplotlib)\n", " Using cached fonttools-4.56.0-cp312-cp312-win_amd64.whl.metadata (103 kB)\n", "Collecting kiwisolver>=1.3.1 (from matplotlib)\n", " Using cached kiwisolver-1.4.8-cp312-cp312-win_amd64.whl.metadata (6.3 kB)\n", "Requirement already satisfied: packaging>=20.0 in c:\\code\\aiagents\\aiagents\\lib\\site-packages (from matplotlib) (24.2)\n", "Requirement already satisfied: pillow>=8 in c:\\code\\aiagents\\aiagents\\lib\\site-packages (from matplotlib) (11.1.0)\n", "Requirement already satisfied: pyparsing>=2.3.1 in c:\\code\\aiagents\\aiagents\\lib\\site-packages (from matplotlib) (3.2.1)\n", "Requirement already satisfied: six>=1.5 in c:\\code\\aiagents\\aiagents\\lib\\site-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n", "Downloading matplotlib-3.10.1-cp312-cp312-win_amd64.whl (8.1 MB)\n", " ---------------------------------------- 0.0/8.1 MB ? eta -:--:--\n", " ---------------------------------------- 0.0/8.1 MB ? eta -:--:--\n", " ---------------------------------------- 0.0/8.1 MB ? eta -:--:--\n", " ---------------------------------------- 0.0/8.1 MB ? eta -:--:--\n", " ---------------------------------------- 0.0/8.1 MB ? eta -:--:--\n", " - -------------------------------------- 0.3/8.1 MB ? eta -:--:--\n", " - -------------------------------------- 0.3/8.1 MB ? eta -:--:--\n", " - -------------------------------------- 0.3/8.1 MB ? eta -:--:--\n", " -- ------------------------------------- 0.5/8.1 MB 289.0 kB/s eta 0:00:27\n", " -- ------------------------------------- 0.5/8.1 MB 289.0 kB/s eta 0:00:27\n", " -- ------------------------------------- 0.5/8.1 MB 289.0 kB/s eta 0:00:27\n", " -- ------------------------------------- 0.5/8.1 MB 289.0 kB/s eta 0:00:27\n", " --- ------------------------------------ 0.8/8.1 MB 289.2 kB/s eta 0:00:26\n", " --- ------------------------------------ 0.8/8.1 MB 289.2 kB/s eta 0:00:26\n", " --- ------------------------------------ 0.8/8.1 MB 289.2 kB/s eta 0:00:26\n", " --- ------------------------------------ 0.8/8.1 MB 289.2 kB/s eta 0:00:26\n", " ----- ---------------------------------- 1.0/8.1 MB 287.5 kB/s eta 0:00:25\n", " ----- ---------------------------------- 1.0/8.1 MB 287.5 kB/s eta 0:00:25\n", " ----- ---------------------------------- 1.0/8.1 MB 287.5 kB/s eta 0:00:25\n", " ------ --------------------------------- 1.3/8.1 MB 294.3 kB/s eta 0:00:23\n", " ------ --------------------------------- 1.3/8.1 MB 294.3 kB/s eta 0:00:23\n", " ------ --------------------------------- 1.3/8.1 MB 294.3 kB/s eta 0:00:23\n", " ------ --------------------------------- 1.3/8.1 MB 294.3 kB/s eta 0:00:23\n", " ------- -------------------------------- 1.6/8.1 MB 299.6 kB/s eta 0:00:22\n", " ------- -------------------------------- 1.6/8.1 MB 299.6 kB/s eta 0:00:22\n", " --------- ------------------------------ 1.8/8.1 MB 313.6 kB/s eta 0:00:20\n", " --------- ------------------------------ 1.8/8.1 MB 313.6 kB/s eta 0:00:20\n", " --------- ------------------------------ 1.8/8.1 MB 313.6 kB/s eta 0:00:20\n", " --------- ------------------------------ 1.8/8.1 MB 313.6 kB/s eta 0:00:20\n", " ---------- ----------------------------- 2.1/8.1 MB 313.1 kB/s eta 0:00:20\n", " ---------- ----------------------------- 2.1/8.1 MB 313.1 kB/s eta 0:00:20\n", " ---------- ----------------------------- 2.1/8.1 MB 313.1 kB/s eta 0:00:20\n", " ---------- ----------------------------- 2.1/8.1 MB 313.1 kB/s eta 0:00:20\n", " ----------- ---------------------------- 2.4/8.1 MB 306.4 kB/s eta 0:00:19\n", " ----------- ---------------------------- 2.4/8.1 MB 306.4 kB/s eta 0:00:19\n", " ----------- ---------------------------- 2.4/8.1 MB 306.4 kB/s eta 0:00:19\n", " ----------- ---------------------------- 2.4/8.1 MB 306.4 kB/s eta 0:00:19\n", " ------------- -------------------------- 2.6/8.1 MB 302.0 kB/s eta 0:00:19\n", " ------------- -------------------------- 2.6/8.1 MB 302.0 kB/s eta 0:00:19\n", " ------------- -------------------------- 2.6/8.1 MB 302.0 kB/s eta 0:00:19\n", " ------------- -------------------------- 2.6/8.1 MB 302.0 kB/s eta 0:00:19\n", " -------------- ------------------------- 2.9/8.1 MB 297.5 kB/s eta 0:00:18\n", " -------------- ------------------------- 2.9/8.1 MB 297.5 kB/s eta 0:00:18\n", " -------------- ------------------------- 2.9/8.1 MB 297.5 kB/s eta 0:00:18\n", " -------------- ------------------------- 2.9/8.1 MB 297.5 kB/s eta 0:00:18\n", " --------------- ------------------------ 3.1/8.1 MB 294.8 kB/s eta 0:00:17\n", " --------------- ------------------------ 3.1/8.1 MB 294.8 kB/s eta 0:00:17\n", " --------------- ------------------------ 3.1/8.1 MB 294.8 kB/s eta 0:00:17\n", " --------------- ------------------------ 3.1/8.1 MB 294.8 kB/s eta 0:00:17\n", " --------------- ------------------------ 3.1/8.1 MB 294.8 kB/s eta 0:00:17\n", " ---------------- ----------------------- 3.4/8.1 MB 290.1 kB/s eta 0:00:17\n", " ---------------- ----------------------- 3.4/8.1 MB 290.1 kB/s eta 0:00:17\n", " ---------------- ----------------------- 3.4/8.1 MB 290.1 kB/s eta 0:00:17\n", " ---------------- ----------------------- 3.4/8.1 MB 290.1 kB/s eta 0:00:17\n", " ---------------- ----------------------- 3.4/8.1 MB 290.1 kB/s eta 0:00:17\n", " ------------------ --------------------- 3.7/8.1 MB 286.6 kB/s eta 0:00:16\n", " ------------------ --------------------- 3.7/8.1 MB 286.6 kB/s eta 0:00:16\n", " ------------------ --------------------- 3.7/8.1 MB 286.6 kB/s eta 0:00:16\n", " ------------------ --------------------- 3.7/8.1 MB 286.6 kB/s eta 0:00:16\n", " ------------------ --------------------- 3.7/8.1 MB 286.6 kB/s eta 0:00:16\n", " ------------------- -------------------- 3.9/8.1 MB 280.9 kB/s eta 0:00:15\n", " ------------------- -------------------- 3.9/8.1 MB 280.9 kB/s eta 0:00:15\n", " ------------------- -------------------- 3.9/8.1 MB 280.9 kB/s eta 0:00:15\n", " ------------------- -------------------- 3.9/8.1 MB 280.9 kB/s eta 0:00:15\n", " ------------------- -------------------- 3.9/8.1 MB 280.9 kB/s eta 0:00:15\n", " -------------------- ------------------- 4.2/8.1 MB 277.5 kB/s eta 0:00:14\n", " -------------------- ------------------- 4.2/8.1 MB 277.5 kB/s eta 0:00:14\n", " -------------------- ------------------- 4.2/8.1 MB 277.5 kB/s eta 0:00:14\n", " -------------------- ------------------- 4.2/8.1 MB 277.5 kB/s eta 0:00:14\n", " ---------------------- ----------------- 4.5/8.1 MB 279.0 kB/s eta 0:00:13\n", " ---------------------- ----------------- 4.5/8.1 MB 279.0 kB/s eta 0:00:13\n", " ---------------------- ----------------- 4.5/8.1 MB 279.0 kB/s eta 0:00:13\n", " ----------------------- ---------------- 4.7/8.1 MB 283.2 kB/s eta 0:00:12\n", " ----------------------- ---------------- 4.7/8.1 MB 283.2 kB/s eta 0:00:12\n", " ----------------------- ---------------- 4.7/8.1 MB 283.2 kB/s eta 0:00:12\n", " ------------------------ --------------- 5.0/8.1 MB 286.8 kB/s eta 0:00:11\n", " ------------------------ --------------- 5.0/8.1 MB 286.8 kB/s eta 0:00:11\n", " ------------------------ --------------- 5.0/8.1 MB 286.8 kB/s eta 0:00:11\n", " ------------------------ --------------- 5.0/8.1 MB 286.8 kB/s eta 0:00:11\n", " -------------------------- ------------- 5.2/8.1 MB 287.4 kB/s eta 0:00:10\n", " -------------------------- ------------- 5.2/8.1 MB 287.4 kB/s eta 0:00:10\n", " -------------------------- ------------- 5.2/8.1 MB 287.4 kB/s eta 0:00:10\n", " -------------------------- ------------- 5.2/8.1 MB 287.4 kB/s eta 0:00:10\n", " -------------------------- ------------- 5.2/8.1 MB 287.4 kB/s eta 0:00:10\n", " --------------------------- ------------ 5.5/8.1 MB 286.5 kB/s eta 0:00:09\n", " --------------------------- ------------ 5.5/8.1 MB 286.5 kB/s eta 0:00:09\n", " --------------------------- ------------ 5.5/8.1 MB 286.5 kB/s eta 0:00:09\n", " ---------------------------- ----------- 5.8/8.1 MB 288.3 kB/s eta 0:00:08\n", " ---------------------------- ----------- 5.8/8.1 MB 288.3 kB/s eta 0:00:08\n", " ---------------------------- ----------- 5.8/8.1 MB 288.3 kB/s eta 0:00:08\n", " ----------------------------- ---------- 6.0/8.1 MB 292.7 kB/s eta 0:00:07\n", " ----------------------------- ---------- 6.0/8.1 MB 292.7 kB/s eta 0:00:07\n", " ----------------------------- ---------- 6.0/8.1 MB 292.7 kB/s eta 0:00:07\n", " ------------------------------- -------- 6.3/8.1 MB 296.8 kB/s eta 0:00:06\n", " ------------------------------- -------- 6.3/8.1 MB 296.8 kB/s eta 0:00:06\n", " -------------------------------- ------- 6.6/8.1 MB 301.4 kB/s eta 0:00:06\n", " -------------------------------- ------- 6.6/8.1 MB 301.4 kB/s eta 0:00:06\n", " -------------------------------- ------- 6.6/8.1 MB 301.4 kB/s eta 0:00:06\n", " --------------------------------- ------ 6.8/8.1 MB 305.9 kB/s eta 0:00:05\n", " --------------------------------- ------ 6.8/8.1 MB 305.9 kB/s eta 0:00:05\n", " --------------------------------- ------ 6.8/8.1 MB 305.9 kB/s eta 0:00:05\n", " --------------------------------- ------ 6.8/8.1 MB 305.9 kB/s eta 0:00:05\n", " ----------------------------------- ---- 7.1/8.1 MB 306.1 kB/s eta 0:00:04\n", " ----------------------------------- ---- 7.1/8.1 MB 306.1 kB/s eta 0:00:04\n", " ----------------------------------- ---- 7.1/8.1 MB 306.1 kB/s eta 0:00:04\n", " ----------------------------------- ---- 7.1/8.1 MB 306.1 kB/s eta 0:00:04\n", " ------------------------------------ --- 7.3/8.1 MB 305.0 kB/s eta 0:00:03\n", " ------------------------------------ --- 7.3/8.1 MB 305.0 kB/s eta 0:00:03\n", " ------------------------------------ --- 7.3/8.1 MB 305.0 kB/s eta 0:00:03\n", " ------------------------------------- -- 7.6/8.1 MB 306.2 kB/s eta 0:00:02\n", " ------------------------------------- -- 7.6/8.1 MB 306.2 kB/s eta 0:00:02\n", " --------------------------------------- 7.9/8.1 MB 311.3 kB/s eta 0:00:01\n", " --------------------------------------- 7.9/8.1 MB 311.3 kB/s eta 0:00:01\n", " ---------------------------------------- 8.1/8.1 MB 313.8 kB/s eta 0:00:00\n", "Using cached contourpy-1.3.1-cp312-cp312-win_amd64.whl (220 kB)\n", "Using cached cycler-0.12.1-py3-none-any.whl (8.3 kB)\n", "Using cached fonttools-4.56.0-cp312-cp312-win_amd64.whl (2.2 MB)\n", "Using cached kiwisolver-1.4.8-cp312-cp312-win_amd64.whl (71 kB)\n", "Installing collected packages: kiwisolver, fonttools, cycler, contourpy, matplotlib\n", "Successfully installed contourpy-1.3.1 cycler-0.12.1 fonttools-4.56.0 kiwisolver-1.4.8 matplotlib-3.10.1\n", "Note: you may need to restart the kernel to use updated packages.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n", "[notice] A new release of pip is available: 25.0 -> 25.0.1\n", "[notice] To update, run: python.exe -m pip install --upgrade pip\n" ] } ], "source": [ "%pip install pandas matplotlib " ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "from langchain_experimental.utilities import PythonREPL\n", "from langchain_groq import ChatGroq\n", "from langgraph.graph import END, StateGraph, START\n", "from typing import Annotated, TypedDict\n", "from langchain_core.messages import AIMessage, HumanMessage\n", "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n", "from langgraph.graph.message import AnyMessage, add_messages\n", "from typing import Sequence\n", "from pydantic import BaseModel, Field\n", "import pandas as pd\n", "import logging\n", "import io # Add this import\n", "import base64 # Add this import\n", "import matplotlib\n", "matplotlib.use('Agg') # Set this before importing pyplot\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import os " ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "creating _create_query_tool\n", "Database connection successful!\n", "Initialized tool: sql_db_query\n", "Initialized tool: sql_db_schema\n", "Initialized tool: sql_db_list_tables\n", "Initialized tool: sql_db_query_checker\n", "Intializing Workflow....\n", "['customers', 'employees', 'orders']\n", "\n", "CREATE TABLE customers (\n", "\tcustomer_id BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\tphone VARCHAR(50), \n", "\tPRIMARY KEY (customer_id)\n", ")COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4 ENGINE=InnoDB\n", "\n", "/*\n", "3 rows from customers table:\n", "customer_id\tfirst_name\tlast_name\temail\tphone\n", "1\tJohn\tDoe\tjohn.doe@example.com\t1234567890\n", "2\tJane\tSmith\tjane.smith@example.com\t9876543210\n", "3\tEmily\tDavis\temily.davis@example.com\t4567891230\n", "*/\n", "CREATE TABLE employees (\n", "\tid BIGINT NOT NULL, \n", "\tfirst_name VARCHAR(255) NOT NULL, \n", "\tlast_name VARCHAR(255) NOT NULL, \n", "\temail VARCHAR(255) NOT NULL, \n", "\thire_date DATE NOT NULL, \n", "\tsalary DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (id)\n", ")COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4 ENGINE=InnoDB\n", "\n", "/*\n", "3 rows from employees table:\n", "id\tfirst_name\tlast_name\temail\thire_date\tsalary\n", "1\tJohn\tDoe\tjohnD@abc.com\t2020-01-01\t50000.00\n", "2\tJane\tDoe\tJaneDabc.com\t2020-05-01\t60000.00\n", "3\tTom\tSmith\ttoms@abc.com\t2020-03-01\t70000.00\n", "*/\n", "CREATE TABLE orders (\n", "\torder_id BIGINT NOT NULL, \n", "\torder_date DATE NOT NULL, \n", "\tcustomer_id BIGINT NOT NULL, \n", "\tamount DECIMAL(10, 2) NOT NULL, \n", "\tPRIMARY KEY (order_id), \n", "\tCONSTRAINT orders_ibfk_1 FOREIGN KEY(customer_id) REFERENCES customers (customer_id)\n", ")COLLATE utf8mb4_0900_ai_ci DEFAULT CHARSET=utf8mb4 ENGINE=InnoDB\n", "\n", "/*\n", "3 rows from orders table:\n", "order_id\torder_date\tcustomer_id\tamount\n", "1\t2020-01-01\t1\t1000.00\n", "2\t2020-02-01\t2\t2000.00\n", "3\t2020-03-01\t3\t3000.00\n", "*/\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:httpx:HTTP Request: POST https://api.groq.com/openai/v1/chat/completions \"HTTP/1.1 200 OK\"\n", "INFO:httpx:HTTP Request: POST https://api.groq.com/openai/v1/chat/completions \"HTTP/1.1 200 OK\"\n", "INFO:httpx:HTTP Request: POST https://api.groq.com/openai/v1/chat/completions \"HTTP/1.1 200 OK\"\n", "INFO:__main__:---------------------------Giving advice on how to improve the visualization---------------------------\n", "INFO:__main__:Messages inside the viz_advice function: [HumanMessage(content='Here is the bar graph of order tables with order id and amount:\\n\\nOrder ID: 1, Amount: 1000.00\\nOrder ID: 2, Amount: 2000.00\\nOrder ID: 3, Amount: 3000.00', additional_kwargs={}, response_metadata={})]\n", "INFO:__main__:---------------------------------------------------------------------------\n", "INFO:httpx:HTTP Request: POST https://api.groq.com/openai/v1/chat/completions \"HTTP/1.1 200 OK\"\n", "INFO:__main__:Viz advice result: advice='Consider using a bar chart with the order ID on the x-axis and the amount on the y-axis to effectively display the variation in order amounts. This visualization will allow the viewer to quickly compare the amounts of each order and identify any trends or patterns.'\n", "INFO:__main__:--------------------------------Advice given--------------------------------\n", "INFO:__main__:---------------------------Creating python code---------------------------\n", "INFO:__main__:Messages inside the create_python_code function: [HumanMessage(content='Here is the bar graph of order tables with order id and amount:\\n\\nOrder ID: 1, Amount: 1000.00\\nOrder ID: 2, Amount: 2000.00\\nOrder ID: 3, Amount: 3000.00', additional_kwargs={}, response_metadata={}), AIMessage(content='Consider using a bar chart with the order ID on the x-axis and the amount on the y-axis to effectively display the variation in order amounts. This visualization will allow the viewer to quickly compare the amounts of each order and identify any trends or patterns.', additional_kwargs={}, response_metadata={})]\n", "INFO:__main__:---------------------------------------------------------------------------\n", "INFO:httpx:HTTP Request: POST https://api.groq.com/openai/v1/chat/completions \"HTTP/1.1 200 OK\"\n", "INFO:__main__:Create python code result: code='import matplotlib.pyplot as plt\\norders = [(1, 1000.00), (2, 2000.00), (3, 3000.00)]\\norder_ids, amounts = zip(*orders)\\nplt.bar(order_ids, amounts)\\n'\n", "INFO:__main__:--------------------------------Python code created--------------------------------\n", "INFO:__main__:Executing python code: import matplotlib.pyplot as plt\n", "orders = [(1, 1000.00), (2, 2000.00), (3, 3000.00)]\n", "order_ids, amounts = zip(*orders)\n", "plt.bar(order_ids, amounts)\n", "\n", "INFO:__main__:Python REPL output: \n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import io\n", "import base64\n", "from langchain_core.messages import AIMessage, HumanMessage, ToolMessage\n", "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n", "from langchain_experimental.utilities import PythonREPL\n", "from langgraph.graph import END, StateGraph, START\n", "from typing import Annotated, TypedDict, Sequence, Union, Any, Optional\n", "from pydantic import BaseModel, Field\n", "import os\n", "from langchain_groq import ChatGroq\n", "import logging\n", "from IPython.display import Image, display\n", "from langchain_community.utilities import SQLDatabase\n", "from langchain_community.agent_toolkits import SQLDatabaseToolkit\n", "from langchain_core.tools import tool\n", "from langchain_core.runnables import RunnableLambda, RunnableWithFallbacks\n", "from langgraph.prebuilt import ToolNode\n", "from dotenv import load_dotenv\n", "\n", "logging.basicConfig(level=logging.INFO)\n", "logger = logging.getLogger(__name__)\n", "\n", "# ------------------------ Data Models ------------------------\n", "\n", "class VisualizationCode(BaseModel):\n", " code: str = Field(..., description=\"Valid Python code snippet that can be executed to create a visualization\")\n", "\n", "class VisualizationAdvice(BaseModel):\n", " advice: str = Field(..., description=\"A single paragraph of advice on how to improve the visualization.\")\n", "\n", "class State(TypedDict):\n", " messages: Annotated[Sequence[Union[AIMessage, HumanMessage]], \"messages\"]\n", "\n", "\n", "# ------------------------ Visualization Agent ------------------------\n", "\n", "class VisualizationAgent:\n", " def __init__(self, model=\"llama3-70b-8192\"):\n", " self.llm = ChatGroq(model=model, api_key=os.getenv(\"GROQ_API_KEY\"))\n", " self.python_repl = PythonREPL()\n", "\n", " def create_python_code(self, state: State):\n", " \"\"\"Create visualization based on the query result\"\"\"\n", " messages = state[\"messages\"]\n", " logger.info(\"---------------------------Creating python code---------------------------\")\n", " logger.info(f\"Messages inside the create_python_code function: {messages}\")\n", " logger.info(\"---------------------------------------------------------------------------\")\n", "\n", " create_python_code_system = \"\"\"\n", " You are a data visualization expert. Your ONLY task is to write valid Python code to create a matplotlib visualization based on the provided data. The data can be database results, text from files, etc.\n", " Return ONLY the code. Do not include any explanations or surrounding text. Do not use plt.show() and do not set any style elements (colors, gridlines, etc.). The variable names should be descriptive.\n", " \"\"\"\n", "\n", " create_python_code_prompt = ChatPromptTemplate.from_messages(\n", " [(\"system\", create_python_code_system), (MessagesPlaceholder(variable_name=\"messages\"))]\n", " )\n", " formatted_create_python_code_prompt = create_python_code_prompt.invoke(\n", " {\"messages\": messages}\n", " )\n", " create_python_code_llm = self.llm.with_structured_output(VisualizationCode)\n", " create_python_code_result = create_python_code_llm.invoke(\n", " formatted_create_python_code_prompt\n", " )\n", " logger.info(f\"Create python code result: {create_python_code_result}\")\n", " logger.info(\n", " \"--------------------------------Python code created--------------------------------\"\n", " )\n", " return {\n", " \"messages\": state[\"messages\"] + [AIMessage(content=create_python_code_result.code)]\n", " }\n", "\n", " def viz_advice(self, state: State):\n", " \"\"\"Give advice on how to improve the visualization\"\"\"\n", " messages = state[\"messages\"]\n", " logger.info(\n", " \"---------------------------Giving advice on how to improve the visualization---------------------------\"\n", " )\n", " logger.info(f\"Messages inside the viz_advice function: {messages}\")\n", " logger.info(\n", " \"---------------------------------------------------------------------------\"\n", " )\n", "\n", " viz_advice_system = \"\"\"\n", " You are a data visualization expert. You are given a description of data (e.g., database query results, text) and you need to give advice on how to create the best, most intuitive, and comprehensive visualization. Consider the data type, relationships, and what insights the user might be looking for.\n", "\n", " Return the advice as a single paragraph of text describing the plot to create.\n", " \"\"\"\n", "\n", " viz_advice_prompt = ChatPromptTemplate.from_messages(\n", " [(\"system\", viz_advice_system), (\"user\", f\"Here is the data description: {messages[0].content if messages else ''}\")]\n", " )\n", " formatted_viz_advice_prompt = viz_advice_prompt.invoke({})\n", " viz_advice_llm = self.llm.with_structured_output(VisualizationAdvice)\n", " viz_advice_result = viz_advice_llm.invoke(formatted_viz_advice_prompt)\n", "\n", " logger.info(f\"Viz advice result: {viz_advice_result}\")\n", " logger.info(\n", " \"--------------------------------Advice given--------------------------------\"\n", " )\n", " return {\"messages\": state[\"messages\"] + [AIMessage(content=viz_advice_result.advice)]}\n", "\n", " def create_visualization(self, state: State):\n", " messages = state[\"messages\"]\n", " python_code = messages[-1].content\n", "\n", " try:\n", " logger.info(f\"Executing python code: {python_code}\")\n", "\n", " # Execute visualization code\n", " output = self.python_repl.run(python_code)\n", " logger.info(f\"Python REPL output: {output}\")\n", "\n", " buf = io.BytesIO()\n", " plt.savefig(buf,\n", " format='png',\n", " bbox_inches='tight',\n", " dpi=300,\n", " facecolor='#ffffff',\n", " edgecolor='none',\n", " pad_inches=0.5,\n", " transparent=False)\n", " buf.seek(0)\n", "\n", " img_str = base64.b64encode(buf.getvalue()).decode('utf-8')\n", " img_data_url = f\"data:image/png;base64,{img_str}\"\n", "\n", " plt.close('all')\n", "\n", " return {\"messages\": state[\"messages\"] + [AIMessage(content=img_data_url)]}\n", "\n", " except Exception as e:\n", " import traceback\n", " traceback.print_exc()\n", " logger.error(f\"Error during code execution: {str(e)}\")\n", " return {\"messages\": state[\"messages\"] + [AIMessage(content=f\"Error creating visualization: {str(e)}\")]}\n", "\n", " def graph_workflow(self, query_result: str):\n", " workflow = StateGraph(State)\n", "\n", " workflow.add_node(\"viz_advice\", self.viz_advice)\n", " workflow.add_node(\"create_python_code\", self.create_python_code)\n", " workflow.add_node(\"create_visualization\", self.create_visualization)\n", "\n", " workflow.add_edge(START, \"viz_advice\")\n", " workflow.add_edge(\"viz_advice\", \"create_python_code\")\n", " workflow.add_edge(\"create_python_code\", \"create_visualization\")\n", " workflow.add_edge(\"create_visualization\", END)\n", "\n", " app = workflow.compile()\n", "\n", " response = app.invoke({\"messages\": [HumanMessage(content=query_result)]})\n", " return response[\"messages\"][-1].content\n", "\n", "# ------------------------ SQL Agent ------------------------\n", "\n", "class SQLAgent:\n", " def __init__(self, model=\"llama3-70b-8192\"):\n", " load_dotenv()\n", " # Initialize instance variables\n", " self.db = None\n", " self.toolkit = None\n", " self.tools = None\n", " self.list_tables_tool = None\n", " self.sql_db_query = None\n", " self.get_schema_tool = None\n", " self.app = None\n", " \n", " # Setting up LLM\n", " self.llm = ChatGroq(model=model, api_key=os.getenv(\"GROQ_API_KEY\"))\n", " \n", " # Register the tool method\n", " self.query_to_database = self._create_query_tool()\n", "\n", " def _create_query_tool(self):\n", " \"\"\"Create the query tool bound to this instance\"\"\"\n", " print(\"creating _create_query_tool\")\n", " @tool\n", " def query_to_database(query: str) -> str:\n", " \"\"\"\n", " Execute a SQL query against the database and return the result.\n", " If the query is invalid or returns no result, an error message will be returned.\n", " In case of an error, the user is advised to rewrite the query and try again.\n", " \"\"\"\n", " if self.db is None:\n", " return \"Error: Database connection not established. Please set up the connection first.\"\n", " result = self.db.run_no_throw(query)\n", " if not result:\n", " return \"Error: Query failed. Please rewrite your query and try again.\"\n", " return result\n", " \n", " return query_to_database\n", "\n", " def setup_database_connection(self, connection_string: str):\n", " \"\"\"Set up database connection and initialize tools\"\"\"\n", " try:\n", " # Initialize database connection\n", " self.db = SQLDatabase.from_uri(connection_string)\n", " print(\"Database connection successful!\")\n", "\n", " try:\n", " # Initialize toolkit and tools\n", " self.toolkit = SQLDatabaseToolkit(db=self.db, llm=self.llm)\n", " self.tools = self.toolkit.get_tools()\n", " for tool in self.tools:\n", " print(f\"Initialized tool: {tool.name}\")\n", "\n", " # Create instances of the tools\n", " self.list_tables_tool = next((tool for tool in self.tools if tool.name == \"sql_db_list_tables\"), None)\n", " self.sql_db_query = next((tool for tool in self.tools if tool.name == \"sql_db_query\"), None)\n", " self.get_schema_tool = next((tool for tool in self.tools if tool.name == \"sql_db_schema\"), None)\n", "\n", " if not all([self.list_tables_tool, self.sql_db_query, self.get_schema_tool]):\n", " raise ValueError(\"Failed to initialize one or more required database tools\")\n", "\n", " # Initialize workflow and compile it into an app\n", " self.initialize_workflow()\n", " \n", " return self.db\n", "\n", " except Exception as e:\n", " print(f\"Error initializing tools and workflow: {str(e)}\")\n", " raise ValueError(f\"Failed to initialize database tools: {str(e)}\")\n", "\n", " except ImportError as e:\n", " print(f\"Database driver import error: {str(e)}\")\n", " raise ValueError(f\"Missing database driver or invalid database type: {str(e)}\")\n", " except ValueError as e:\n", " print(f\"Invalid connection string or configuration: {str(e)}\")\n", " raise\n", " except Exception as e:\n", " print(f\"Unexpected error during database connection: {str(e)}\")\n", " raise ValueError(f\"Failed to establish database connection: {str(e)}\")\n", "\n", " def initialize_workflow(self):\n", " \"\"\"Initialize the workflow graph\"\"\"\n", " \n", " print(\"Intializing Workflow....\")\n", " # Binding tools with LLM\n", " llm_to_get_schema = self.llm.bind_tools([self.get_schema_tool]) if self.get_schema_tool else None\n", " llm_with_tools = self.llm.bind_tools([self.query_to_database])\n", "\n", " class State(TypedDict):\n", " messages: Annotated[list[AnyMessage], add_messages]\n", "\n", " class SubmitFinalAnswer(BaseModel):\n", " final_answer: str = Field(..., description=\"The final answer to the user\")\n", "\n", " llm_with_final_answer = self.llm.bind_tools([SubmitFinalAnswer])\n", "\n", " def handle_tool_error(state: State):\n", " error = state.get(\"error\")\n", " tool_calls = state[\"messages\"][-1].tool_calls\n", " return {\"messages\": [ToolMessage(content=f\"Error: {repr(error)}\\n please fix your mistakes.\", tool_call_id=tc[\"id\"],) for tc in tool_calls]}\n", "\n", " def create_node_from_tool_with_fallback(tools: list) -> RunnableWithFallbacks[Any, dict]:\n", " return ToolNode(tools).with_fallbacks([RunnableLambda(handle_tool_error)], exception_key=\"error\")\n", "\n", " list_tables = create_node_from_tool_with_fallback([self.list_tables_tool]) if self.list_tables_tool else None\n", " get_schema = create_node_from_tool_with_fallback([self.get_schema_tool]) if self.get_schema_tool else None\n", " query_database = create_node_from_tool_with_fallback([self.query_to_database])\n", "\n", " query_check_system = \"\"\"You are a SQL expert. Carefully review the SQL query for common mistakes, including:\n", "\n", " Issues with NULL handling (e.g., NOT IN with NULLs)\n", " Improper use of UNION instead of UNION ALL\n", " Incorrect use of BETWEEN for exclusive ranges\n", " Data type mismatches or incorrect casting\n", " Quoting identifiers improperly\n", " Incorrect number of arguments in functions\n", " Errors in JOIN conditions\n", "\n", " If you find any mistakes, rewrite the query to fix them. If it's correct, reproduce it as is.\"\"\"\n", " query_check_prompt = ChatPromptTemplate.from_messages([(\"system\", query_check_system), (\"placeholder\", \"{messages}\")])\n", " check_generated_query = query_check_prompt | llm_with_tools\n", " \n", " def check_the_given_query(state: State):\n", " return {\"messages\": [check_generated_query.invoke({\"messages\": [state[\"messages\"][-1]]})]}\n", "\n", " query_gen_system_prompt = \"\"\"You are a SQL expert with a strong attention to detail.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", " 1. DO NOT call any tool besides SubmitFinalAnswer to submit the final answer.\n", "\n", " When generating the query:\n", "\n", " 2. Output the SQL query that answers the input question without a tool call.\n", "\n", " 3. Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most 5 results.\n", "\n", " 4. You can order the results by a relevant column to return the most interesting examples in the database.\n", "\n", " 5. Never query for all the columns from a specific table, only ask for the relevant columns given the question.\n", "\n", " 6. If you get an error while executing a query, rewrite the query and try again.\n", "\n", " 7. If you get an empty result set, you should try to rewrite the query to get a non-empty result set.\n", "\n", " 8. 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", " 9. 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", " 10. DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database. Do not return any sql query except answer.\"\"\"\n", " query_gen_prompt = ChatPromptTemplate.from_messages([(\"system\", query_gen_system_prompt), (\"placeholder\", \"{messages}\")])\n", " query_generator = query_gen_prompt | llm_with_final_answer\n", "\n", " def first_tool_call(state: State) -> dict[str, list[AIMessage]]:\n", " return {\"messages\": [AIMessage(content=\"\", tool_calls=[{\"name\": \"sql_db_list_tables\", \"args\": {}, \"id\": \"tool_abcd123\"}])]}\n", "\n", " def generation_query(state: State):\n", " message = query_generator.invoke(state)\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", " def should_continue(state: State):\n", " messages = state[\"messages\"]\n", " last_message = messages[-1]\n", " if getattr(last_message, \"tool_calls\", None):\n", " # Check if the tool call is SubmitFinalAnswer\n", " if len(last_message.tool_calls) > 0 and last_message.tool_calls[0][\"name\"] == \"SubmitFinalAnswer\":\n", " return END\n", " else:\n", " # Wrong tool called, route to error handling (not implemented here)\n", " return \"query_gen\" # Or a dedicated error node\n", " elif last_message.content.startswith(\"Error:\"):\n", " return \"query_gen\"\n", " else:\n", " return \"correct_query\"\n", "\n", " def llm_get_schema(state: State):\n", " response = llm_to_get_schema.invoke(state[\"messages\"])\n", " return {\"messages\": [response]}\n", "\n", " # Create workflow\n", " workflow = StateGraph(State)\n", " workflow.add_node(\"first_tool_call\", first_tool_call)\n", " workflow.add_node(\"list_tables_tool\", list_tables)\n", " workflow.add_node(\"get_schema_tool\", get_schema)\n", " workflow.add_node(\"model_get_schema\", llm_get_schema)\n", " workflow.add_node(\"query_gen\", generation_query)\n", " workflow.add_node(\"correct_query\", check_the_given_query)\n", " workflow.add_node(\"execute_query\", query_database)\n", "\n", " workflow.add_edge(START, \"first_tool_call\")\n", " workflow.add_edge(\"first_tool_call\", \"list_tables_tool\")\n", " workflow.add_edge(\"list_tables_tool\", \"model_get_schema\")\n", " workflow.add_edge(\"model_get_schema\", \"get_schema_tool\")\n", " workflow.add_edge(\"get_schema_tool\", \"query_gen\")\n", " workflow.add_conditional_edges(\"query_gen\", should_continue, {END: END, \"correct_query\": \"correct_query\", \"query_gen\": \"query_gen\"})\n", " workflow.add_edge(\"correct_query\", \"execute_query\")\n", " workflow.add_edge(\"execute_query\", \"query_gen\")\n", "\n", " # Compile the workflow into an executable app\n", " self.app = workflow.compile()\n", " \n", " def is_query_relevant(self, query: str) -> bool:\n", " \"\"\"Check if the query is relevant to the database using the LLM.\"\"\"\n", " \n", " # Retrieve the schema of the relevant tables\n", " if self.list_tables_tool:\n", " relevant_tables = self.list_tables_tool.invoke(\"\")\n", " # print(relevant_tables)\n", " table_list= relevant_tables.split(\", \")\n", " print(table_list)\n", " # print(agent.get_schema_tool.invoke(table_list[0]))\n", " schema = \"\"\n", " for table in table_list:\n", " schema+= self.get_schema_tool.invoke(table)\n", "\n", " print(schema)\n", " \n", " # if self.get_schema_tool:\n", " # schema_response = self.get_schema_tool.invoke({})\n", " # table_schema = schema_response.content # Assuming this returns the schema as a string\n", "\n", " relevance_check_prompt = (\n", " \"\"\"You are an expert SQL agent which takes user query in Natural language and find out it have releavnce with the given schema or not. Please determine if the following query is related to a database.Here is the schema of the tables present in database:\\n{schema}\\n\\n. If the query related to given schema respond with 'yes'. Here is the query: {query}. Answer with only 'yes' or 'no'.\"\"\"\n", " ).format(schema=relevant_tables, query=query)\n", " \n", " response = self.llm.invoke([{\"role\": \"user\", \"content\": relevance_check_prompt}])\n", " \n", " # Assuming the LLM returns a simple 'yes' or 'no'\n", " return response.content == \"yes\"\n", " \n", " def execute_query(self, query: str) -> Union[str, bytes]:\n", " \"\"\"Execute a query through the workflow and potentially visualize the results.\"\"\"\n", " if self.db is None:\n", " raise ValueError(\"Database connection not established. Please set up the connection first.\")\n", " if self.app is None:\n", " raise ValueError(\"Workflow not initialized. Please set up the connection first.\")\n", "\n", " # First, handle simple queries like \"list tables\" directly\n", " query_lower = query.lower()\n", " if any(phrase in query_lower for phrase in [\"list all the tables\", \"show tables\", \"name of tables\",\n", " \"which tables are present\", \"how many tables\"]):\n", " if self.list_tables_tool:\n", " tables = self.list_tables_tool.invoke(\"\")\n", " return f\"The tables in the database are: {tables}\"\n", " else:\n", " return \"Error: Unable to list tables. The list_tables_tool is not initialized.\"\n", "\n", " # Check if the query is relevant to the database\n", " if not self.is_query_relevant(query):\n", " print(\"Not relevent to database.\")\n", " # If not relevant, let the LLM answer the question directly\n", " non_relevant_prompt = (\n", " \"\"\"You are an expert SQL agent created by Kshitij Kumrawat. You can only assist with questions related to databases so repond the user with the following example resonse and Do not answer any questions that are not related to databases.: \n", " Please ask a question that pertains to database operations, such as querying tables, retrieving data, or understanding the database schema. \"\"\"\n", " )\n", " response = self.llm.invoke([{\"role\": \"user\", \"content\": non_relevant_prompt}])\n", " return response.content\n", "\n", " # If relevant, proceed with the SQL workflow\n", " response = self.app.invoke({\"messages\": [HumanMessage(content=query, role=\"user\")]})\n", "\n", " # More robust final answer extraction\n", " if (\n", " response\n", " and response[\"messages\"]\n", " and response[\"messages\"][-1].tool_calls\n", " and len(response[\"messages\"][-1].tool_calls) > 0\n", " and \"args\" in response[\"messages\"][-1].tool_calls[0]\n", " and \"final_answer\" in response[\"messages\"][-1].tool_calls[0][\"args\"]\n", " ):\n", " final_answer = response[\"messages\"][-1].tool_calls[0][\"args\"][\"final_answer\"]\n", " else:\n", " return \"Error: Could not extract final answer.\"\n", "\n", " # Check if visualization is requested\n", " if \"visualize\" in query_lower or \"chart\" in query_lower or \"graph\" in query_lower:\n", " try:\n", " # Chain Visualization Agent to the SQL results\n", " viz_agent = VisualizationAgent()\n", " image_data = viz_agent.graph_workflow(final_answer)\n", " return image_data # Return the base64-encoded image data\n", " except Exception as e:\n", " logger.error(f\"Error during visualization: {e}\")\n", " return f\"Error creating visualization: {e}\"\n", " else:\n", " return final_answer\n", "\n", "# ------------------------ Main Execution ------------------------\n", "\n", "if __name__ == \"__main__\":\n", " # Example usage:\n", " database_connection_string = \"mysql+pymysql://admin:9522359448@mydatabase.cf8u2cy0a4h6.us-east-1.rds.amazonaws.com:3306/mydb\" # Replace with your database connection string\n", "\n", " # Initialize agents\n", " sql_agent = SQLAgent()\n", " sql_agent.setup_database_connection(database_connection_string)\n", "\n", " # Example query with visualization request\n", " query = \"Create a bar graph of order tables with order id and amount\"\n", " result = sql_agent.execute_query(query)\n", "\n", " if isinstance(result, str) and result.startswith(\"data:image/png;base64,\"):\n", " # Display the image\n", " try:\n", " image_data = base64.b64decode(result.split(',')[1])\n", " display(Image(data=image_data))\n", " except Exception as e:\n", " print(f\"Error displaying image: {e}\")\n", " else:\n", " print(\"Query Result:\", result)" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from IPython.display import Image, display\n", "\n", "# Assuming 'response' contains the base64 string:\n", "image_data = base64.b64decode(response.split(',')[1]) # Remove the \"data:image/png;base64,\" prefix\n", "display(Image(data=image_data))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from IPython.display import Image, display\n", "\n", "# Assuming 'response' contains the base64 string:\n", "image_data = base64.b64decode(response.split(',')[1]) # Remove the \"data:image/png;base64,\" prefix\n", "display(Image(data=image_data))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "---------------------------Giving advice on how to improve the visualization---------------------------\n", "Messages inside the viz_advice function: [HumanMessage(content=\"Create a histogram for this -Here is the data for Led Zeppelin's and Queen's total sales and number of tracks sold each year:\\n\\n- **2009**\\n - Led Zeppelin: $22.77, 23 tracks\\n - Queen: $4.95, 5 tracks\\n\\n- **2010**\\n - Led Zeppelin: $21.78, 22 tracks\\n - Queen: $0.99, 1 track\\n\\n- **2011**\\n - Led Zeppelin: $2.97, 3 tracks\\n - Queen: $10.89, 11 tracks\\n\\n- **2012**\\n - Led Zeppelin: $23.76, 24 tracks\\n - Queen: $10.89, 11 tracks\\n\\n- **2013**\\n - Led Zeppelin: $14.85, 15 tracks\\n - Queen: $8.91, 9 tracks\", additional_kwargs={}, response_metadata={}, id='ce6cb3ec-eb4c-480e-99c3-3b59d657f7ed')]\n", "---------------------------------------------------------------------------\n", "advice=\"Create a histogram to visualize the total sales and number of tracks sold each year for Led Zeppelin and Queen. The x-axis should represent the years (2009-2013), and the y-axis should display the total sales and number of tracks sold. Use a dual-axis chart with the left y-axis for total sales and the right y-axis for the number of tracks sold. Use different colors and markers to distinguish between Led Zeppelin and Queen's data. Ensure proper data labeling, including axis labels, legend descriptions, and clear data point labels. Apply the provided guidelines for data representation, axis labeling, and overall layout to create an intuitive and comprehensive visualization.\"\n", "--------------------------------Advice given--------------------------------\n", "----------creating python code -------------\n", "Messages inside the create python_code function: [HumanMessage(content=\"Create a histogram for this -Here is the data for Led Zeppelin's and Queen's total sales and number of tracks sold each year:\\n\\n- **2009**\\n - Led Zeppelin: $22.77, 23 tracks\\n - Queen: $4.95, 5 tracks\\n\\n- **2010**\\n - Led Zeppelin: $21.78, 22 tracks\\n - Queen: $0.99, 1 track\\n\\n- **2011**\\n - Led Zeppelin: $2.97, 3 tracks\\n - Queen: $10.89, 11 tracks\\n\\n- **2012**\\n - Led Zeppelin: $23.76, 24 tracks\\n - Queen: $10.89, 11 tracks\\n\\n- **2013**\\n - Led Zeppelin: $14.85, 15 tracks\\n - Queen: $8.91, 9 tracks\", additional_kwargs={}, response_metadata={}, id='ce6cb3ec-eb4c-480e-99c3-3b59d657f7ed'), AIMessage(content=\"Create a histogram to visualize the total sales and number of tracks sold each year for Led Zeppelin and Queen. The x-axis should represent the years (2009-2013), and the y-axis should display the total sales and number of tracks sold. Use a dual-axis chart with the left y-axis for total sales and the right y-axis for the number of tracks sold. Use different colors and markers to distinguish between Led Zeppelin and Queen's data. Ensure proper data labeling, including axis labels, legend descriptions, and clear data point labels. Apply the provided guidelines for data representation, axis labeling, and overall layout to create an intuitive and comprehensive visualization.\", additional_kwargs={}, response_metadata={}, id='70c74266-b0e7-4e24-80a9-bb89e3eef107')]\n" ] }, { "ename": "BadRequestError", "evalue": "Error code: 400 - {'error': {'message': \"Failed to call a function. Please adjust your prompt. See 'failed_generation' for more details.\", 'type': 'invalid_request_error', 'code': 'tool_use_failed', 'failed_generation': ''}}", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mBadRequestError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[8], line 398\u001b[0m\n\u001b[0;32m 396\u001b[0m viz_agent \u001b[38;5;241m=\u001b[39m VisualizationAgent()\n\u001b[0;32m 397\u001b[0m query_result \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCreate a histogram for this -Here is the data for Led Zeppelin\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ms and Queen\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ms total sales and number of tracks sold each year:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m- **2009**\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Led Zeppelin: $22.77, 23 tracks\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Queen: $4.95, 5 tracks\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m- **2010**\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Led Zeppelin: $21.78, 22 tracks\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Queen: $0.99, 1 track\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m- **2011**\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Led Zeppelin: $2.97, 3 tracks\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Queen: $10.89, 11 tracks\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m- **2012**\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Led Zeppelin: $23.76, 24 tracks\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Queen: $10.89, 11 tracks\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m- **2013**\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Led Zeppelin: $14.85, 15 tracks\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m - Queen: $8.91, 9 tracks\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m--> 398\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mviz_agent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgraph_workflow\u001b[49m\u001b[43m(\u001b[49m\u001b[43mquery_result\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 399\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m--------------------------------Graph workflow completed--------------------------------\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 400\u001b[0m \u001b[38;5;28mprint\u001b[39m(response)\n", "Cell \u001b[1;32mIn[8], line 352\u001b[0m, in \u001b[0;36mVisualizationAgent.graph_workflow\u001b[1;34m(self, query_result)\u001b[0m\n\u001b[0;32m 347\u001b[0m workflow\u001b[38;5;241m.\u001b[39madd_edge(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcreate_visualization\u001b[39m\u001b[38;5;124m\"\u001b[39m, END)\n\u001b[0;32m 349\u001b[0m app \u001b[38;5;241m=\u001b[39m workflow\u001b[38;5;241m.\u001b[39mcompile()\n\u001b[1;32m--> 352\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mapp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmessages\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mHumanMessage\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcontent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mquery_result\u001b[49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 353\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmessages\u001b[39m\u001b[38;5;124m\"\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mcontent\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\pregel\\__init__.py:2124\u001b[0m, in \u001b[0;36mPregel.invoke\u001b[1;34m(self, input, config, stream_mode, output_keys, interrupt_before, interrupt_after, debug, **kwargs)\u001b[0m\n\u001b[0;32m 2122\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 2123\u001b[0m chunks \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m-> 2124\u001b[0m \u001b[43m\u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mchunk\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 2125\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2126\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2127\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_mode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_mode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2128\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_keys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_keys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2129\u001b[0m \u001b[43m \u001b[49m\u001b[43minterrupt_before\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterrupt_before\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2130\u001b[0m \u001b[43m \u001b[49m\u001b[43minterrupt_after\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterrupt_after\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2131\u001b[0m \u001b[43m \u001b[49m\u001b[43mdebug\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdebug\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2132\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2133\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[0;32m 2134\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mstream_mode\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mvalues\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\n\u001b[0;32m 2135\u001b[0m \u001b[43m \u001b[49m\u001b[43mlatest\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mchunk\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\pregel\\__init__.py:1779\u001b[0m, in \u001b[0;36mPregel.stream\u001b[1;34m(self, input, config, stream_mode, output_keys, interrupt_before, interrupt_after, debug, subgraphs)\u001b[0m\n\u001b[0;32m 1773\u001b[0m \u001b[38;5;66;03m# Similarly to Bulk Synchronous Parallel / Pregel model\u001b[39;00m\n\u001b[0;32m 1774\u001b[0m \u001b[38;5;66;03m# computation proceeds in steps, while there are channel updates.\u001b[39;00m\n\u001b[0;32m 1775\u001b[0m \u001b[38;5;66;03m# Channel updates from step N are only visible in step N+1\u001b[39;00m\n\u001b[0;32m 1776\u001b[0m \u001b[38;5;66;03m# channels are guaranteed to be immutable for the duration of the step,\u001b[39;00m\n\u001b[0;32m 1777\u001b[0m \u001b[38;5;66;03m# with channel updates applied only at the transition between steps.\u001b[39;00m\n\u001b[0;32m 1778\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m loop\u001b[38;5;241m.\u001b[39mtick(input_keys\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_channels):\n\u001b[1;32m-> 1779\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m_\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrunner\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtick\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1780\u001b[0m \u001b[43m \u001b[49m\u001b[43mloop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtasks\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1781\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep_timeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1782\u001b[0m \u001b[43m \u001b[49m\u001b[43mretry_policy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mretry_policy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1783\u001b[0m \u001b[43m \u001b[49m\u001b[43mget_waiter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mget_waiter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1784\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[0;32m 1785\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# emit output\u001b[39;49;00m\n\u001b[0;32m 1786\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01myield from\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43moutput\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1787\u001b[0m \u001b[38;5;66;03m# emit output\u001b[39;00m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\pregel\\runner.py:230\u001b[0m, in \u001b[0;36mPregelRunner.tick\u001b[1;34m(self, tasks, reraise, timeout, retry_policy, get_waiter)\u001b[0m\n\u001b[0;32m 228\u001b[0m t \u001b[38;5;241m=\u001b[39m tasks[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m 229\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 230\u001b[0m \u001b[43mrun_with_retry\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 231\u001b[0m \u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 232\u001b[0m \u001b[43m \u001b[49m\u001b[43mretry_policy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 233\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfigurable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\n\u001b[0;32m 234\u001b[0m \u001b[43m \u001b[49m\u001b[43mCONFIG_KEY_SEND\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwriter\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 235\u001b[0m \u001b[43m \u001b[49m\u001b[43mCONFIG_KEY_CALL\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcall\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 236\u001b[0m \u001b[43m \u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 237\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 238\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcommit(t, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m 239\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exc:\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\pregel\\retry.py:40\u001b[0m, in \u001b[0;36mrun_with_retry\u001b[1;34m(task, retry_policy, configurable)\u001b[0m\n\u001b[0;32m 38\u001b[0m task\u001b[38;5;241m.\u001b[39mwrites\u001b[38;5;241m.\u001b[39mclear()\n\u001b[0;32m 39\u001b[0m \u001b[38;5;66;03m# run the task\u001b[39;00m\n\u001b[1;32m---> 40\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mproc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minput\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 41\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m ParentCommand \u001b[38;5;28;01mas\u001b[39;00m exc:\n\u001b[0;32m 42\u001b[0m ns: \u001b[38;5;28mstr\u001b[39m \u001b[38;5;241m=\u001b[39m config[CONF][CONFIG_KEY_CHECKPOINT_NS]\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\utils\\runnable.py:546\u001b[0m, in \u001b[0;36mRunnableSeq.invoke\u001b[1;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[0;32m 542\u001b[0m config \u001b[38;5;241m=\u001b[39m patch_config(\n\u001b[0;32m 543\u001b[0m config, callbacks\u001b[38;5;241m=\u001b[39mrun_manager\u001b[38;5;241m.\u001b[39mget_child(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mseq:step:\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;250m \u001b[39m\u001b[38;5;241m+\u001b[39m\u001b[38;5;250m \u001b[39m\u001b[38;5;241m1\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 544\u001b[0m )\n\u001b[0;32m 545\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m i \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m--> 546\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mstep\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 547\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 548\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m step\u001b[38;5;241m.\u001b[39minvoke(\u001b[38;5;28minput\u001b[39m, config)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langgraph\\utils\\runnable.py:310\u001b[0m, in \u001b[0;36mRunnableCallable.invoke\u001b[1;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[0;32m 308\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 309\u001b[0m context\u001b[38;5;241m.\u001b[39mrun(_set_config_context, config)\n\u001b[1;32m--> 310\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mcontext\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 311\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(ret, Runnable) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrecurse:\n\u001b[0;32m 312\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ret\u001b[38;5;241m.\u001b[39minvoke(\u001b[38;5;28minput\u001b[39m, config)\n", "Cell \u001b[1;32mIn[8], line 122\u001b[0m, in \u001b[0;36mVisualizationAgent.create_python_code\u001b[1;34m(self, state)\u001b[0m\n\u001b[0;32m 120\u001b[0m formatted_create_python_code_prompt \u001b[38;5;241m=\u001b[39m create_python_code_prompt\u001b[38;5;241m.\u001b[39minvoke({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmessages\u001b[39m\u001b[38;5;124m\"\u001b[39m: messages})\n\u001b[0;32m 121\u001b[0m create_python_code_llm \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mllm\u001b[38;5;241m.\u001b[39mwith_structured_output(VisualizationCode)\n\u001b[1;32m--> 122\u001b[0m create_python_code_result \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_python_code_llm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\u001b[43mformatted_create_python_code_prompt\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 123\u001b[0m \u001b[38;5;28mprint\u001b[39m(create_python_code_result)\n\u001b[0;32m 124\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m--------------------------------Python code created--------------------------------\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\runnables\\base.py:3022\u001b[0m, in \u001b[0;36mRunnableSequence.invoke\u001b[1;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[0;32m 3020\u001b[0m context\u001b[38;5;241m.\u001b[39mrun(_set_config_context, config)\n\u001b[0;32m 3021\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m i \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m-> 3022\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mcontext\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3023\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 3024\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m context\u001b[38;5;241m.\u001b[39mrun(step\u001b[38;5;241m.\u001b[39minvoke, \u001b[38;5;28minput\u001b[39m, config)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\runnables\\base.py:5360\u001b[0m, in \u001b[0;36mRunnableBindingBase.invoke\u001b[1;34m(self, input, config, **kwargs)\u001b[0m\n\u001b[0;32m 5354\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21minvoke\u001b[39m(\n\u001b[0;32m 5355\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 5356\u001b[0m \u001b[38;5;28minput\u001b[39m: Input,\n\u001b[0;32m 5357\u001b[0m config: Optional[RunnableConfig] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m 5358\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Optional[Any],\n\u001b[0;32m 5359\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Output:\n\u001b[1;32m-> 5360\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbound\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvoke\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 5361\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 5362\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_merge_configs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 5363\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 5364\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\language_models\\chat_models.py:284\u001b[0m, in \u001b[0;36mBaseChatModel.invoke\u001b[1;34m(self, input, config, stop, **kwargs)\u001b[0m\n\u001b[0;32m 273\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21minvoke\u001b[39m(\n\u001b[0;32m 274\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 275\u001b[0m \u001b[38;5;28minput\u001b[39m: LanguageModelInput,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 279\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any,\n\u001b[0;32m 280\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m BaseMessage:\n\u001b[0;32m 281\u001b[0m config \u001b[38;5;241m=\u001b[39m ensure_config(config)\n\u001b[0;32m 282\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cast(\n\u001b[0;32m 283\u001b[0m ChatGeneration,\n\u001b[1;32m--> 284\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_prompt\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 285\u001b[0m \u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_convert_input\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 286\u001b[0m \u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 287\u001b[0m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcallbacks\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 288\u001b[0m \u001b[43m \u001b[49m\u001b[43mtags\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtags\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 289\u001b[0m \u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmetadata\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 290\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrun_name\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 291\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpop\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrun_id\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 292\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 293\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mgenerations[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m],\n\u001b[0;32m 294\u001b[0m )\u001b[38;5;241m.\u001b[39mmessage\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\language_models\\chat_models.py:860\u001b[0m, in \u001b[0;36mBaseChatModel.generate_prompt\u001b[1;34m(self, prompts, stop, callbacks, **kwargs)\u001b[0m\n\u001b[0;32m 852\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mgenerate_prompt\u001b[39m(\n\u001b[0;32m 853\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 854\u001b[0m prompts: \u001b[38;5;28mlist\u001b[39m[PromptValue],\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 857\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any,\n\u001b[0;32m 858\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m LLMResult:\n\u001b[0;32m 859\u001b[0m prompt_messages \u001b[38;5;241m=\u001b[39m [p\u001b[38;5;241m.\u001b[39mto_messages() \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m prompts]\n\u001b[1;32m--> 860\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprompt_messages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\language_models\\chat_models.py:690\u001b[0m, in \u001b[0;36mBaseChatModel.generate\u001b[1;34m(self, messages, stop, callbacks, tags, metadata, run_name, run_id, **kwargs)\u001b[0m\n\u001b[0;32m 687\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(messages):\n\u001b[0;32m 688\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 689\u001b[0m results\u001b[38;5;241m.\u001b[39mappend(\n\u001b[1;32m--> 690\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_generate_with_cache\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 691\u001b[0m \u001b[43m \u001b[49m\u001b[43mm\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 692\u001b[0m \u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 693\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_manager\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_managers\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrun_managers\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m 694\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 695\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 696\u001b[0m )\n\u001b[0;32m 697\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mBaseException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 698\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m run_managers:\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_core\\language_models\\chat_models.py:925\u001b[0m, in \u001b[0;36mBaseChatModel._generate_with_cache\u001b[1;34m(self, messages, stop, run_manager, **kwargs)\u001b[0m\n\u001b[0;32m 923\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 924\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m inspect\u001b[38;5;241m.\u001b[39msignature(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_generate)\u001b[38;5;241m.\u001b[39mparameters\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrun_manager\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m--> 925\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_generate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 926\u001b[0m \u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrun_manager\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_manager\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[0;32m 927\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 928\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 929\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_generate(messages, stop\u001b[38;5;241m=\u001b[39mstop, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\langchain_groq\\chat_models.py:480\u001b[0m, in \u001b[0;36mChatGroq._generate\u001b[1;34m(self, messages, stop, run_manager, **kwargs)\u001b[0m\n\u001b[0;32m 475\u001b[0m message_dicts, params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_create_message_dicts(messages, stop)\n\u001b[0;32m 476\u001b[0m params \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m 477\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mparams,\n\u001b[0;32m 478\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[0;32m 479\u001b[0m }\n\u001b[1;32m--> 480\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmessage_dicts\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 481\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_create_chat_result(response)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\resources\\chat\\completions.py:316\u001b[0m, in \u001b[0;36mCompletions.create\u001b[1;34m(self, messages, model, frequency_penalty, function_call, functions, logit_bias, logprobs, max_completion_tokens, max_tokens, n, parallel_tool_calls, presence_penalty, response_format, seed, service_tier, stop, stream, temperature, tool_choice, tools, top_logprobs, top_p, user, extra_headers, extra_query, extra_body, timeout)\u001b[0m\n\u001b[0;32m 163\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mcreate\u001b[39m(\n\u001b[0;32m 164\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 165\u001b[0m \u001b[38;5;241m*\u001b[39m,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 194\u001b[0m timeout: \u001b[38;5;28mfloat\u001b[39m \u001b[38;5;241m|\u001b[39m httpx\u001b[38;5;241m.\u001b[39mTimeout \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m|\u001b[39m NotGiven \u001b[38;5;241m=\u001b[39m NOT_GIVEN,\n\u001b[0;32m 195\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ChatCompletion \u001b[38;5;241m|\u001b[39m Stream[ChatCompletionChunk]:\n\u001b[0;32m 196\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 197\u001b[0m \u001b[38;5;124;03m Creates a model response for the given chat conversation.\u001b[39;00m\n\u001b[0;32m 198\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 314\u001b[0m \u001b[38;5;124;03m timeout: Override the client-level default timeout for this request, in seconds\u001b[39;00m\n\u001b[0;32m 315\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m--> 316\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_post\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 317\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/openai/v1/chat/completions\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 318\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmaybe_transform\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 319\u001b[0m \u001b[43m \u001b[49m\u001b[43m{\u001b[49m\n\u001b[0;32m 320\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmessages\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 321\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmodel\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 322\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfrequency_penalty\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfrequency_penalty\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 323\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunction_call\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunction_call\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 324\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunctions\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunctions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 325\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlogit_bias\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogit_bias\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 326\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlogprobs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogprobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 327\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmax_completion_tokens\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_completion_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 328\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmax_tokens\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 329\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mn\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 330\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mparallel_tool_calls\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mparallel_tool_calls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 331\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpresence_penalty\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mpresence_penalty\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 332\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mresponse_format\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mresponse_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 333\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mseed\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mseed\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 334\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mservice_tier\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mservice_tier\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 335\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstop\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 336\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstream\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 337\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtemperature\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtemperature\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 338\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtool_choice\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtool_choice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 339\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtools\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtools\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 340\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtop_logprobs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtop_logprobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 341\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtop_p\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtop_p\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 342\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43muser\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43muser\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 343\u001b[0m \u001b[43m \u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 344\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompletion_create_params\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mCompletionCreateParams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 345\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 346\u001b[0m \u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmake_request_options\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 347\u001b[0m \u001b[43m \u001b[49m\u001b[43mextra_headers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_headers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_query\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_query\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_body\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_body\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\n\u001b[0;32m 348\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 349\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mChatCompletion\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 350\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m 351\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mStream\u001b[49m\u001b[43m[\u001b[49m\u001b[43mChatCompletionChunk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 352\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\_base_client.py:1266\u001b[0m, in \u001b[0;36mSyncAPIClient.post\u001b[1;34m(self, path, cast_to, body, options, files, stream, stream_cls)\u001b[0m\n\u001b[0;32m 1252\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mpost\u001b[39m(\n\u001b[0;32m 1253\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 1254\u001b[0m path: \u001b[38;5;28mstr\u001b[39m,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1261\u001b[0m stream_cls: \u001b[38;5;28mtype\u001b[39m[_StreamT] \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m 1262\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResponseT \u001b[38;5;241m|\u001b[39m _StreamT:\n\u001b[0;32m 1263\u001b[0m opts \u001b[38;5;241m=\u001b[39m FinalRequestOptions\u001b[38;5;241m.\u001b[39mconstruct(\n\u001b[0;32m 1264\u001b[0m method\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpost\u001b[39m\u001b[38;5;124m\"\u001b[39m, url\u001b[38;5;241m=\u001b[39mpath, json_data\u001b[38;5;241m=\u001b[39mbody, files\u001b[38;5;241m=\u001b[39mto_httpx_files(files), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions\n\u001b[0;32m 1265\u001b[0m )\n\u001b[1;32m-> 1266\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cast(ResponseT, \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mopts\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m)\u001b[49m)\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\_base_client.py:958\u001b[0m, in \u001b[0;36mSyncAPIClient.request\u001b[1;34m(self, cast_to, options, remaining_retries, stream, stream_cls)\u001b[0m\n\u001b[0;32m 955\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 956\u001b[0m retries_taken \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m--> 958\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 959\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 960\u001b[0m \u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 961\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 962\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 963\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries_taken\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mretries_taken\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 964\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[1;32mc:\\code\\AiAgents\\AiAgents\\Lib\\site-packages\\groq\\_base_client.py:1061\u001b[0m, in \u001b[0;36mSyncAPIClient._request\u001b[1;34m(self, cast_to, options, retries_taken, stream, stream_cls)\u001b[0m\n\u001b[0;32m 1058\u001b[0m err\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mread()\n\u001b[0;32m 1060\u001b[0m log\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRe-raising status error\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m-> 1061\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_status_error_from_response(err\u001b[38;5;241m.\u001b[39mresponse) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 1063\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_process_response(\n\u001b[0;32m 1064\u001b[0m cast_to\u001b[38;5;241m=\u001b[39mcast_to,\n\u001b[0;32m 1065\u001b[0m options\u001b[38;5;241m=\u001b[39moptions,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1069\u001b[0m retries_taken\u001b[38;5;241m=\u001b[39mretries_taken,\n\u001b[0;32m 1070\u001b[0m )\n", "\u001b[1;31mBadRequestError\u001b[0m: Error code: 400 - {'error': {'message': \"Failed to call a function. Please adjust your prompt. See 'failed_generation' for more details.\", 'type': 'invalid_request_error', 'code': 'tool_use_failed', 'failed_generation': ''}}", "\u001b[0mDuring task with name 'create_python_code' and id '3ac7af34-b837-593a-99f7-b30fd392c092'" ] } ], "source": [ "class State(TypedDict):\n", " messages: Annotated[Sequence[AnyMessage], add_messages] #Using Sequence provides more flexibility as it allows any sequence type to be accepted, while list strictly requires a list.\n", " \n", "class VisualizationCode(BaseModel):\n", " code: str = Field(...,\n", " description= \"Should only consists of valid Python code snippet that can be executed\",\n", " )\n", "\n", "class VisualizationAdvice(BaseModel):\n", " advice: str = Field(...,\n", " description= \"Should only consists of valid Python advice on how create best, intuitive visualization \",\n", " )\n", "\n", "class VisualizationAgent: \n", " def __init__(self):\n", " self.llm= ChatGroq(model = \"llama3-70b-8192\", api_key = os.getenv(\"GROQ_API_KEY\"))\n", " self.python_repl = PythonREPL()\n", " \n", " def create_python_code(self,state:State):\n", " \"\"\"Create visualization based on the query results\"\"\"\n", " messages = state[\"messages\"]\n", " print(\"----------creating python code -------------\")\n", " print(f\"Messages inside the create python_code function: {messages}\")\n", " create_python_code_system = \"\"\"\n", "\n", " You are a data visualization expert. Create intuitive and comprehensive visualizations from SQL query results that make the data immediately understandable without referencing the original query. Place significant emphasis on data labeling to enhance clarity.\n", " You are also given some advice on how to create the best, intuitive and comprehensive visualization.\n", "\n", " **Core Principles:**\n", "\n", " 1. **Data Analysis & Preprocessing:**\n", " - Understand the structure of SQL results.\n", " - Distinguish between metrics (quantitative) and dimensions (categorical/temporal).\n", " - Identify data hierarchies and relationships.\n", " - Handle null values and format data appropriately.\n", " - Apply meaningful sorting (e.g., by key metrics, chronological order).\n", " - Calculate derived metrics when useful (e.g., percentages, growth rates).\n", "\n", " 2. **Visualization Selection:**\n", " - **Categorical Data:**\n", " - Use horizontal bar charts for 7 or more categories.\n", " - Use vertical bar charts for fewer categories.\n", " - Include totals and averages as reference lines.\n", " - Avoid pie/donut charts unless displaying compositions with 6 or fewer categories.\n", " - **Time Series:**\n", " - Use line charts for continuous trends.\n", " - Use bar charts for discrete time periods.\n", " - Mark year-over-year or month-over-month changes.\n", " - Highlight minimum and maximum points.\n", " - **Comparisons:**\n", " - Use grouped or stacked bar charts for comparisons.\n", " - Use scatter plots for correlations.\n", " - Use combo charts for mixed metric types.\n", " - **Multi-Axis Design:**\n", " - When data ranges differ significantly, use separate axes to improve clarity and readability.\n", " - Implement dual-axis charts to display metrics with different scales effectively.\n", "\n", " 3. **Comprehensive Labeling:**\n", " - **Data Point Labels:**\n", " - Display actual values on or near data points.\n", " - Include percentages of total where relevant.\n", " - Add growth indicators (e.g., ±%).\n", " - Position labels to avoid overlap between data labels and different data representations. Use offsets or callouts if necessary.\n", " - **Axis Labels:**\n", " - Use clear, descriptive labels with units.\n", " - Format scales appropriately (e.g., K for thousands, M for millions).\n", " - Apply proper date formats.\n", " - Avoid truncated labels.\n", " - **Annotations:**\n", " - Indicate totals, averages, and significant changes.\n", " - Highlight outliers or notable trends.\n", " - Include brief explanatory notes when necessary.\n", "\n", " 4. **Layout & Design:**\n", " - Set appropriate figure dimensions and margins (e.g., `plt.figure(figsize=(12, 7))`). Adjust the figure size if needed to prevent overlapping elements.\n", " - Apply a clear title hierarchy:\n", " - **Main Title:** Convey key insights.\n", " - **Subtitle:** Provide context and time period.\n", " - **Caption:** Include data sources or notes.\n", " - Position legends optimally based on chart space, ensuring they do not overlap with chart elements.\n", " - Use light gridlines for reference (`alpha=0.2`).\n", " - Apply consistent font sizes:\n", " - **Title:** 14pt bold.\n", " - **Labels:** 10pt.\n", " - **Annotations:** 9pt.\n", "\n", " 5. **Color Standards:**\n", " - Primary colors for consistency:\n", " - Single series: '#6366F1' (Indigo-500)\n", " - Two series: ['#6366F1', '#818CF8'] (Indigo-500, Indigo-400)\n", " - Multiple series: Use color gradients from blue to purple\n", " - Highlight colors: '#E11D48' (Rose-600) for emphasis\n", " - Positive trends: '#22C55E' (Green-600)\n", " - Negative trends: '#EF4444' (Red-500)\n", " - Apply alpha=0.8 for main elements\n", " - Use darker shades for important data points\n", " - For categorical data, use evenly spaced colors from the blue-purple gradient\n", " - Add subtle gradients for fill areas using alpha blending\n", "\n", " **Key Considerations:**\n", "\n", " - Tailor the visualization to data complexity and audience needs.\n", " - Ensure clarity and readability at intended display sizes.\n", " - Use multi-axis or dual-axis designs to effectively communicate data with different value ranges.\n", " - Include all necessary context within the visualization.\n", "\n", " **The final visualization should:**\n", "\n", " - Tell a complete data story at a glance.\n", " - Highlight key insights and patterns.\n", " - Clearly display all relevant metrics, using distinct axes if necessary.\n", " - Maintain proper proportions and scales.\n", " - Be uncluttered, well-organized, and immediately understandable.\n", " \"\"\"\n", " \n", " create_python_code_prompt = ChatPromptTemplate.from_messages([\n", " (\"system\", create_python_code_system),\n", " (MessagesPlaceholder(variable_name=\"messages\"))\n", " ])\n", " formatted_create_python_code_prompt = create_python_code_prompt.invoke({\"messages\": messages})\n", " create_python_code_llm = self.llm.with_structured_output(VisualizationCode)\n", " create_python_code_result = create_python_code_llm.invoke(formatted_create_python_code_prompt)\n", " print(create_python_code_result)\n", " print(\"--------------------------------Python code created--------------------------------\")\n", " return {\"messages\": state[\"messages\"] + [AIMessage(content = f\"{create_python_code_result.code}\")]}\n", " \n", " def viz_advice(self, state: State):\n", " \"\"\"Give advice on how to improve the visualization\"\"\"\n", " messages = state[\"messages\"]\n", " print(\"---------------------------Giving advice on how to improve the visualization---------------------------\")\n", " print(f\"Messages inside the viz_advice function: {messages}\")\n", " print(\"---------------------------------------------------------------------------\")\n", "\n", " viz_advice_system = \"\"\"\n", " **You are a data visualization expert.**\n", "\n", " **You have been given data generated from querying a database. Your task is to provide advice on how to best visualize this data. Structure your advice as a prompt for an LLM to generate the visualization code. Your goal is to create the best, most intuitive, and comprehensive visualization.**\n", "\n", " **Make sure your instructions take into account all details mentioned in the provided data and emphasize the following:**\n", "\n", " - **Data labeling** to enhance clarity.\n", " - **Proper axis labeling.**\n", " - **Accurate data representation.**\n", " - **Appropriate color scheme.**\n", " - **Clear legend descriptions.**\n", " - **Proper spacing and figure size.**\n", " - **Effective overall layout.**\n", "\n", " **Ensure that:**\n", "\n", " - There is **no overlap** among graph elements, data labels, and legends.\n", " - Data labels **do not overlap** with each other.\n", " - **Data from different categories or rows are not incorrectly aggregated or mixed together. Each category's data should be represented separately and accurately.**\n", "\n", " ---\n", "\n", " ### **Instructions for the Visualization:**\n", "\n", " 1. **Data Labeling:**\n", "\n", " - **Accuracy:**\n", " - Ensure all data labels correctly correspond to their respective data points.\n", " - Use appropriate metrics and units (e.g., percentages, currency, units of measurement).\n", " - **Consistency:**\n", " - Maintain consistent formatting and precision across all labels (e.g., number of decimal places).\n", "\n", " 2. **X-Axis Tick Labels:**\n", "\n", " - **Rotation for Readability:**\n", " - Rotate the x-axis tick labels by **45 degrees** to improve readability.\n", " - If labels still overlap after a 45-degree rotation:\n", " - Rotate the tick labels by **90 degrees** (vertical orientation).\n", " - **Adjust Font Size:** Reduce the font size to fit labels without overlap.\n", " - **Abbreviation:** Abbreviate or truncate labels while keeping them understandable.\n", " - **Spacing:** Ensure adequate spacing between labels to prevent overlapping.\n", "\n", " 3. **Prevent Data Label Overlapping:**\n", "\n", " - **Detection of Overlaps:**\n", " - Identify potential overlaps by checking for data points with similar values or close proximity on the chart.\n", " - **Spacing and Positioning:**\n", " - **Reposition Overlapping Labels:** Place them in areas with more space, away from crowded regions.\n", " - **Offsets and Staggering:** Use offsets or stagger label positions (e.g., alternate above and below data points) to enhance visibility.\n", " - **Color Differentiation:**\n", " - Use colors from the legend to differentiate labels, matching label colors with their corresponding data series or categories.\n", "\n", " 4. **Data Representation:**\n", "\n", " - **Accuracy:**\n", " - Accurately plot all data points from the query result.\n", " - Ensure data points align correctly with the x and y axes.\n", " - **Prevent Incorrect Aggregation:**\n", " - Do **not** sum or combine data from different categories unless explicitly required.\n", " - Ensure that data from different categories (e.g., artists and their sales partnerships) are represented separately and accurately.\n", " - **Completeness:**\n", " - Include all relevant data series and categories in the visualization.\n", " - **Integrity:**\n", " - Do not distort or manipulate data representation in ways that could mislead interpretation.\n", "\n", " 5. **Axis Labels:**\n", "\n", " - **Clarity:**\n", " - Use clear, descriptive labels for both x and y axes.\n", " - Include units of measurement where applicable (e.g., \"Artist Name\", \"Revenue (USD)\").\n", " - **Formatting:**\n", " - Use a readable font size and style consistent with the rest of the visualization.\n", " - **Positioning:**\n", " - Ensure axis labels do not overlap with graph elements like data points, lines, or bars.\n", " - Adjust label placement if necessary (e.g., add padding or adjust margins).\n", "\n", " 6. **Totals and Averages:**\n", "\n", " - **Display:**\n", " - Show totals or averages only when meaningful and appropriate.\n", " - **Aggregate Correctly:**\n", " - Aggregate data within the same category if required (e.g., total revenue per artist).\n", " - Do not aggregate across different categories unintentionally.\n", " - **Positioning:**\n", " - Place these values where they do not interfere with other data.\n", " - **Labeling:**\n", " - Clearly indicate what each total or average represents (e.g., \"Total Revenue per Artist\").\n", " - **Formatting:**\n", " - Differentiate these values using distinct styles (e.g., dashed lines, different colors).\n", "\n", " 7. **Clarity and Spacing:**\n", "\n", " - **Uncluttered Design:**\n", " - Avoid overcrowding the visualization with too many elements.\n", " - Remove unnecessary gridlines or background elements that do not add value.\n", " - **Whitespace:**\n", " - Utilize whitespace effectively to separate different sections and elements.\n", " - **Element Sizing:**\n", " - Ensure all elements (text, markers, lines) are appropriately sized for readability.\n", " - **Alignment:**\n", " - Align elements neatly to create a professional and organized appearance.\n", "\n", " 8. **Handling Varying Data Ranges:**\n", "\n", " - **Separate Axes:**\n", " - Use separate y-axes for data series with significantly different ranges.\n", " - Implement dual-axis charts with one y-axis on the left and another on the right if necessary.\n", " - **Differentiation:**\n", " - Use different line styles or markers to distinguish between data series associated with different axes.\n", " - **Axis Labels:**\n", " - Clearly label each axis with the units and data series it represents.\n", " - Match the color of axis labels and tick marks with the corresponding data series if appropriate.\n", " - **Scaling:**\n", " - Ensure the scales of both axes are appropriate for the data they represent to prevent misinterpretation.\n", "\n", " ---\n", "\n", " Use these guidelines to advise on creating the most effective, intuitive, and comprehensive visualization possible based on the provided data, ensuring that data from different categories or rows are represented separately and not incorrectly aggregated or mixed together.\n", " \"\"\"\n", "\n", " viz_advice_prompt = ChatPromptTemplate.from_messages([\n", " (\"system\", viz_advice_system),\n", " (\"user\", f\"Here is the text information used to generate the code: {messages[0].content}\")\n", " ])\n", " formatted_viz_advice_prompt = viz_advice_prompt.invoke({})\n", " viz_advice_llm = self.llm.with_structured_output(VisualizationAdvice)\n", " viz_advice_result = viz_advice_llm.invoke(formatted_viz_advice_prompt)\n", " print(viz_advice_result)\n", " print(\"--------------------------------Advice given--------------------------------\")\n", " return {\"messages\": state[\"messages\"] + [AIMessage(content = f\"{viz_advice_result.advice}\")]}\n", " \n", " def create_visualization(self, state: State):\n", " messages = state[\"messages\"]\n", " python_code = messages[-1].content\n", "\n", " try:\n", " plt.style.use('seaborn-v0_8-whitegrid')\n", " plt.rcParams.update({\n", " # Increase figure size\n", " 'figure.figsize': (20, 12),\n", " 'figure.dpi': 300,\n", " \n", " # Keep font sizes smaller for better aesthetics\n", " 'axes.titlesize': 14,\n", " 'axes.labelsize': 12,\n", " 'xtick.labelsize': 10,\n", " 'ytick.labelsize': 10,\n", " 'legend.fontsize': 10,\n", " \n", " # Other settings remain the same\n", " 'font.family': 'sans-serif',\n", " 'font.sans-serif': ['Arial', 'Helvetica'],\n", " 'font.weight': 'medium',\n", " 'figure.facecolor': '#ffffff',\n", " 'axes.facecolor': '#ffffff',\n", " 'axes.edgecolor': '#E2E8F0',\n", " 'axes.linewidth': 0.8,\n", " 'axes.grid': True,\n", " 'axes.titleweight': 'semibold',\n", " 'axes.titlepad': 20,\n", " 'axes.labelweight': 'medium',\n", " 'axes.labelcolor': '#4B5563',\n", " 'axes.spines.top': False,\n", " 'axes.spines.right': False,\n", " 'grid.color': '#E2E8F0',\n", " 'grid.alpha': 0.2,\n", " 'grid.linestyle': '--',\n", " 'legend.frameon': False,\n", " 'figure.constrained_layout.use': True,\n", " 'figure.constrained_layout.h_pad': 1.0,\n", " 'figure.constrained_layout.w_pad': 1.0\n", " })\n", " \n", " # Execute visualization code\n", " output = self.python_repl.run(python_code)\n", " \n", " # Apply rotation to x-axis labels after plot is created\n", " plt.xticks(rotation=45, ha='right')\n", " \n", " # Save with enhanced quality settings\n", " buf = io.BytesIO()\n", " plt.savefig(buf, \n", " format='png',\n", " bbox_inches='tight',\n", " dpi=300,\n", " facecolor='#ffffff',\n", " edgecolor='none',\n", " pad_inches=0.5,\n", " transparent=False)\n", " buf.seek(0)\n", " \n", " img_str = base64.b64encode(buf.getvalue()).decode('utf-8')\n", " img_data_url = f\"data:image/png;base64,{img_str}\"\n", " \n", " plt.close('all')\n", " \n", " return {\"messages\": state[\"messages\"] + [AIMessage(content=img_data_url)]}\n", " \n", " except Exception as e:\n", " return {\"messages\": state[\"messages\"] + [AIMessage(content=f\"Error creating visualization: {str(e)}\")]}\n", "\n", " def graph_workflow(self, query_result: str):\n", " workflow = StateGraph(State)\n", " \n", " workflow.add_node(\"create_python_code\", self.create_python_code)\n", " workflow.add_node(\"create_visualization\", self.create_visualization) \n", " workflow.add_node(\"viz_advice\", self.viz_advice)\n", "\n", " workflow.add_edge(START, \"viz_advice\")\n", " workflow.add_edge(\"viz_advice\", \"create_python_code\")\n", " workflow.add_edge(\"create_python_code\", \"create_visualization\")\n", " #workflow.add_edge(\"correct_python_code\", \"create_visualization\")\n", " workflow.add_edge(\"create_visualization\", END)\n", " \n", " app = workflow.compile()\n", " \n", "\n", " response = app.invoke({\"messages\": [HumanMessage(content=query_result)]})\n", " return response[\"messages\"][-1].content\n", " \n", " def apply_style_enhancements(self):\n", " \"\"\"Apply consistent style enhancements to the current plot\"\"\"\n", " # Get current axis\n", " ax = plt.gca()\n", " \n", " # Add subtle gradient background\n", " ax.set_facecolor('#F8FAFC')\n", " \n", " # Enhance legend\n", " if ax.get_legend():\n", " ax.legend(\n", " facecolor='white',\n", " edgecolor='#E2E8F0',\n", " framealpha=0.9,\n", " loc='best',\n", " bbox_to_anchor=(1.02, 1),\n", " )\n", " \n", " # Add subtle top border gradient\n", " gradient = np.linspace(0, 1, 100).reshape(1, -1)\n", " gradient = np.vstack((gradient, gradient))\n", " extent = [ax.get_xlim()[0], ax.get_xlim()[1], 1.01, 1.02]\n", " ax.imshow(gradient, aspect='auto', extent=extent, \n", " cmap='RdYlBu_r', alpha=0.1)\n", " \n", " # Enhance grid\n", " ax.grid(True, 'major', color='#E2E8F0', alpha=0.2, linestyle='--')\n", " \n", " # Add padding\n", " plt.tight_layout(pad=1.5)\n", "\n", " def get_color_palette(self, n_colors):\n", " \"\"\"Generate a consistent color palette for n series\"\"\"\n", " if n_colors == 1:\n", " return ['#6366F1']\n", " elif n_colors == 2:\n", " return ['#6366F1', '#818CF8']\n", " else:\n", " return [plt.cm.RdYlBu(i/n_colors) for i in range(n_colors)]\n", "\n", "if __name__ == \"__main__\":\n", " viz_agent = VisualizationAgent()\n", " query_result = \"Create a histogram for this -Here is the data for Led Zeppelin's and Queen's total sales and number of tracks sold each year:\\n\\n- **2009**\\n - Led Zeppelin: $22.77, 23 tracks\\n - Queen: $4.95, 5 tracks\\n\\n- **2010**\\n - Led Zeppelin: $21.78, 22 tracks\\n - Queen: $0.99, 1 track\\n\\n- **2011**\\n - Led Zeppelin: $2.97, 3 tracks\\n - Queen: $10.89, 11 tracks\\n\\n- **2012**\\n - Led Zeppelin: $23.76, 24 tracks\\n - Queen: $10.89, 11 tracks\\n\\n- **2013**\\n - Led Zeppelin: $14.85, 15 tracks\\n - Queen: $8.91, 9 tracks\"\n", " response = viz_agent.graph_workflow(query_result)\n", " print(\"--------------------------------Graph workflow completed--------------------------------\")\n", " print(response)\n", " \n", " \n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "backend", "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.13.3" } }, "nbformat": 4, "nbformat_minor": 2 }