sql.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from dotenv import load_dotenv\n",
    "from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, Float\n",
    "from sqlalchemy.orm import sessionmaker, relationship, declarative_base\n",
    "from langchain_core.runnables.config import RunnableConfig\n",
    "\n",
    "\n",
    "load_dotenv()\n",
    "\n",
    "DATABASE_URL = os.getenv(\"DATABASE_URL\", \"sqlite:///example.db\")\n",
    "engine = create_engine(DATABASE_URL)\n",
    "SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\n",
    "\n",
    "Base = declarative_base()\n",
    "\n",
    "# Definition of the Users table\n",
    "class User(Base):\n",
    "    __tablename__ = \"users\"\n",
    "\n",
    "    id = Column(Integer, primary_key=True, index=True)\n",
    "    name = Column(String, index=True)\n",
    "    age = Column(Integer)\n",
    "    email = Column(String, unique=True, index=True)\n",
    "\n",
    "    orders = relationship(\"Order\", back_populates=\"user\")\n",
    "\n",
    "# Definition of the Food table\n",
    "class Food(Base):\n",
    "    __tablename__ = \"food\"\n",
    "\n",
    "    id = Column(Integer, primary_key=True, index=True)\n",
    "    name = Column(String, unique=True, index=True)\n",
    "    price = Column(Float)\n",
    "\n",
    "    orders = relationship(\"Order\", back_populates=\"food\")\n",
    "\n",
    "# Definition of the Orders table\n",
    "class Order(Base):\n",
    "    __tablename__ = \"orders\"\n",
    "\n",
    "    id = Column(Integer, primary_key=True, index=True)\n",
    "    food_id = Column(Integer, ForeignKey(\"food.id\"))\n",
    "    user_id = Column(Integer, ForeignKey(\"users.id\"))\n",
    "\n",
    "    user = relationship(\"User\", back_populates=\"orders\")\n",
    "    food = relationship(\"Food\", back_populates=\"orders\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sql_agent.py\n",
    "\n",
    "import os\n",
    "from dotenv import load_dotenv\n",
    "from typing_extensions import TypedDict\n",
    "from pydantic import BaseModel, Field\n",
    "from langchain_openai import ChatOpenAI\n",
    "from langchain_core.prompts import ChatPromptTemplate\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "from sqlalchemy import text, inspect\n",
    "from langgraph.graph import StateGraph, END\n",
    "\n",
    "class AgentState(TypedDict):\n",
    "    question: str\n",
    "    sql_query: str\n",
    "    query_result: str\n",
    "    query_rows: list\n",
    "    current_user: str\n",
    "    attempts: int\n",
    "    relevance: str\n",
    "    sql_error: bool\n",
    "\n",
    "def get_database_schema(engine):\n",
    "    inspector = inspect(engine)\n",
    "    schema = \"\"\n",
    "    for table_name in inspector.get_table_names():\n",
    "        schema += f\"Table: {table_name}\\n\"\n",
    "        for column in inspector.get_columns(table_name):\n",
    "            col_name = column[\"name\"]\n",
    "            col_type = str(column[\"type\"])\n",
    "            if column.get(\"primary_key\"):\n",
    "                col_type += \", Primary Key\"\n",
    "            if column.get(\"foreign_keys\"):\n",
    "                fk = list(column[\"foreign_keys\"])[0]\n",
    "                col_type += f\", Foreign Key to {fk.column.table.name}.{fk.column.name}\"\n",
    "            schema += f\"- {col_name}: {col_type}\\n\"\n",
    "        schema += \"\\n\"\n",
    "    print(\"Retrieved database schema.\")\n",
    "    return schema\n",
    "\n",
    "class GetCurrentUser(BaseModel):\n",
    "    current_user: str = Field(\n",
    "        description=\"The name of the current user based on the provided user ID.\"\n",
    "    )\n",
    "\n",
    "def get_current_user(state: AgentState, config: RunnableConfig):\n",
    "    print(\"Retrieving the current user based on user ID.\")\n",
    "    user_id = config[\"configurable\"].get(\"current_user_id\", None)\n",
    "    if not user_id:\n",
    "        state[\"current_user\"] = \"User not found\"\n",
    "        print(\"No user ID provided in the configuration.\")\n",
    "        return state\n",
    "\n",
    "    session = SessionLocal()\n",
    "    try:\n",
    "        user = session.query(User).filter(User.id == int(user_id)).first()\n",
    "        if user:\n",
    "            state[\"current_user\"] = user.name\n",
    "            print(f\"Current user set to: {state['current_user']}\")\n",
    "        else:\n",
    "            state[\"current_user\"] = \"User not found\"\n",
    "            print(\"User not found in the database.\")\n",
    "    except Exception as e:\n",
    "        state[\"current_user\"] = \"Error retrieving user\"\n",
    "        print(f\"Error retrieving user: {str(e)}\")\n",
    "    finally:\n",
    "        session.close()\n",
    "    return state\n",
    "\n",
    "class CheckRelevance(BaseModel):\n",
    "    relevance: str = Field(\n",
    "        description=\"Indicates whether the question is related to the database schema. 'relevant' or 'not_relevant'.\"\n",
    "    )\n",
    "\n",
    "def check_relevance(state: AgentState, config: RunnableConfig):\n",
    "    question = state[\"question\"]\n",
    "    schema = get_database_schema(engine)\n",
    "    print(f\"Checking relevance of the question: {question}\")\n",
    "    system = \"\"\"You are an assistant that determines whether a given question is related to the following database schema.\n",
    "\n",
    "Schema:\n",
    "{schema}\n",
    "\n",
    "Respond with only \"relevant\" or \"not_relevant\".\n",
    "\"\"\".format(schema=schema)\n",
    "    human = f\"Question: {question}\"\n",
    "    check_prompt = ChatPromptTemplate.from_messages(\n",
    "        [\n",
    "            (\"system\", system),\n",
    "            (\"human\", human),\n",
    "        ]\n",
    "    )\n",
    "    llm = ChatOpenAI(temperature=0)\n",
    "    structured_llm = llm.with_structured_output(CheckRelevance)\n",
    "    relevance_checker = check_prompt | structured_llm\n",
    "    relevance = relevance_checker.invoke({})\n",
    "    state[\"relevance\"] = relevance.relevance\n",
    "    print(f\"Relevance determined: {state['relevance']}\")\n",
    "    return state\n",
    "\n",
    "class ConvertToSQL(BaseModel):\n",
    "    sql_query: str = Field(\n",
    "        description=\"The SQL query corresponding to the user's natural language question.\"\n",
    "    )\n",
    "\n",
    "def convert_nl_to_sql(state: AgentState, config: RunnableConfig):\n",
    "    question = state[\"question\"]\n",
    "    current_user = state[\"current_user\"]\n",
    "    schema = get_database_schema(engine)\n",
    "    print(f\"Converting question to SQL for user '{current_user}': {question}\")\n",
    "    system = \"\"\"You are an assistant that converts natural language questions into SQL queries based on the following schema:\n",
    "\n",
    "{schema}\n",
    "\n",
    "The current user is '{current_user}'. Ensure that all query-related data is scoped to this user.\n",
    "\n",
    "Provide only the SQL query without any explanations. Alias columns appropriately to match the expected keys in the result.\n",
    "\n",
    "For example, alias 'food.name' as 'food_name' and 'food.price' as 'price'.\n",
    "\"\"\".format(schema=schema, current_user=current_user)\n",
    "    convert_prompt = ChatPromptTemplate.from_messages(\n",
    "        [\n",
    "            (\"system\", system),\n",
    "            (\"human\", \"Question: {question}\"),\n",
    "        ]\n",
    "    )\n",
    "    llm = ChatOpenAI(temperature=0)\n",
    "    structured_llm = llm.with_structured_output(ConvertToSQL)\n",
    "    sql_generator = convert_prompt | structured_llm\n",
    "    result = sql_generator.invoke({\"question\": question})\n",
    "    state[\"sql_query\"] = result.sql_query\n",
    "    print(f\"Generated SQL query: {state['sql_query']}\")\n",
    "    return state\n",
    "\n",
    "def execute_sql(state: AgentState):\n",
    "    sql_query = state[\"sql_query\"].strip()\n",
    "    session = SessionLocal()\n",
    "    print(f\"Executing SQL query: {sql_query}\")\n",
    "    try:\n",
    "        result = session.execute(text(sql_query))\n",
    "        if sql_query.lower().startswith(\"select\"):\n",
    "            rows = result.fetchall()\n",
    "            columns = result.keys()\n",
    "            if rows:\n",
    "                header = \", \".join(columns)\n",
    "                state[\"query_rows\"] = [dict(zip(columns, row)) for row in rows]\n",
    "                print(f\"Raw SQL Query Result: {state['query_rows']}\")\n",
    "                # Format the result for readability\n",
    "                data = \"; \".join([f\"{row.get('food_name', row.get('name'))} for ${row.get('price', row.get('food_price'))}\" for row in state[\"query_rows\"]])\n",
    "                formatted_result = f\"{header}\\n{data}\"\n",
    "            else:\n",
    "                state[\"query_rows\"] = []\n",
    "                formatted_result = \"No results found.\"\n",
    "            state[\"query_result\"] = formatted_result\n",
    "            state[\"sql_error\"] = False\n",
    "            print(\"SQL SELECT query executed successfully.\")\n",
    "        else:\n",
    "            session.commit()\n",
    "            state[\"query_result\"] = \"The action has been successfully completed.\"\n",
    "            state[\"sql_error\"] = False\n",
    "            print(\"SQL command executed successfully.\")\n",
    "    except Exception as e:\n",
    "        state[\"query_result\"] = f\"Error executing SQL query: {str(e)}\"\n",
    "        state[\"sql_error\"] = True\n",
    "        print(f\"Error executing SQL query: {str(e)}\")\n",
    "    finally:\n",
    "        session.close()\n",
    "    return state\n",
    "\n",
    "def generate_human_readable_answer(state: AgentState):\n",
    "    sql = state[\"sql_query\"]\n",
    "    result = state[\"query_result\"]\n",
    "    current_user = state[\"current_user\"]\n",
    "    query_rows = state.get(\"query_rows\", [])\n",
    "    sql_error = state.get(\"sql_error\", False)\n",
    "    print(\"Generating a human-readable answer.\")\n",
    "    system = \"\"\"You are an assistant that converts SQL query results into clear, natural language responses without including any identifiers like order IDs. Start the response with a friendly greeting that includes the user's name.\n",
    "    \"\"\"\n",
    "    if sql_error:\n",
    "        # Directly relay the error message\n",
    "        generate_prompt = ChatPromptTemplate.from_messages(\n",
    "            [\n",
    "                (\"system\", system),\n",
    "                (\n",
    "                    \"human\",\n",
    "                    f\"\"\"SQL Query:\n",
    "{sql}\n",
    "\n",
    "Result:\n",
    "{result}\n",
    "\n",
    "Formulate a clear and understandable error message in a single sentence, starting with 'Hello {current_user},' informing them about the issue.\"\"\"\n",
    "                ),\n",
    "            ]\n",
    "        )\n",
    "    elif sql.lower().startswith(\"select\"):\n",
    "        if not query_rows:\n",
    "            # Handle cases with no orders\n",
    "            generate_prompt = ChatPromptTemplate.from_messages(\n",
    "                [\n",
    "                    (\"system\", system),\n",
    "                    (\n",
    "                        \"human\",\n",
    "                        f\"\"\"SQL Query:\n",
    "{sql}\n",
    "\n",
    "Result:\n",
    "{result}\n",
    "\n",
    "Formulate a clear and understandable answer to the original question in a single sentence, starting with 'Hello {current_user},' and mention that there are no orders found.\"\"\"\n",
    "                    ),\n",
    "                ]\n",
    "            )\n",
    "        else:\n",
    "            # Handle displaying orders\n",
    "            generate_prompt = ChatPromptTemplate.from_messages(\n",
    "                [\n",
    "                    (\"system\", system),\n",
    "                    (\n",
    "                        \"human\",\n",
    "                        f\"\"\"SQL Query:\n",
    "{sql}\n",
    "\n",
    "Result:\n",
    "{result}\n",
    "\n",
    "Formulate a clear and understandable answer to the original question in a single sentence, starting with 'Hello {current_user},' and list each item ordered along with its price. For example: 'Hello Bob, you have ordered Lasagne for $14.0 and Spaghetti Carbonara for $15.0.'\"\"\"\n",
    "                    ),\n",
    "                ]\n",
    "            )\n",
    "    else:\n",
    "        # Handle non-select queries\n",
    "        generate_prompt = ChatPromptTemplate.from_messages(\n",
    "            [\n",
    "                (\"system\", system),\n",
    "                (\n",
    "                    \"human\",\n",
    "                    f\"\"\"SQL Query:\n",
    "{sql}\n",
    "\n",
    "Result:\n",
    "{result}\n",
    "\n",
    "Formulate a clear and understandable confirmation message in a single sentence, starting with 'Hello {current_user},' confirming that your request has been successfully processed.\"\"\"\n",
    "                ),\n",
    "            ]\n",
    "        )\n",
    "\n",
    "    llm = ChatOpenAI(temperature=0)\n",
    "    human_response = generate_prompt | llm | StrOutputParser()\n",
    "    answer = human_response.invoke({})\n",
    "    state[\"query_result\"] = answer\n",
    "    print(\"Generated human-readable answer.\")\n",
    "    return state\n",
    "\n",
    "class RewrittenQuestion(BaseModel):\n",
    "    question: str = Field(description=\"The rewritten question.\")\n",
    "\n",
    "def regenerate_query(state: AgentState):\n",
    "    question = state[\"question\"]\n",
    "    print(\"Regenerating the SQL query by rewriting the question.\")\n",
    "    system = \"\"\"You are an assistant that reformulates an original question to enable more precise SQL queries. Ensure that all necessary details, such as table joins, are preserved to retrieve complete and accurate data.\n",
    "    \"\"\"\n",
    "    rewrite_prompt = ChatPromptTemplate.from_messages(\n",
    "        [\n",
    "            (\"system\", system),\n",
    "            (\n",
    "                \"human\",\n",
    "                f\"Original Question: {question}\\nReformulate the question to enable more precise SQL queries, ensuring all necessary details are preserved.\",\n",
    "            ),\n",
    "        ]\n",
    "    )\n",
    "    llm = ChatOpenAI(temperature=0)\n",
    "    structured_llm = llm.with_structured_output(RewrittenQuestion)\n",
    "    rewriter = rewrite_prompt | structured_llm\n",
    "    rewritten = rewriter.invoke({})\n",
    "    state[\"question\"] = rewritten.question\n",
    "    state[\"attempts\"] += 1\n",
    "    print(f\"Rewritten question: {state['question']}\")\n",
    "    return state\n",
    "\n",
    "def generate_funny_response(state: AgentState):\n",
    "    print(\"Generating a funny response for an unrelated question.\")\n",
    "    system = \"\"\"You are a charming and funny assistant who responds in a playful manner.\n",
    "    \"\"\"\n",
    "    human_message = \"I can not help with that, but doesn't asking questions make you hungry? You can always order something delicious.\"\n",
    "    funny_prompt = ChatPromptTemplate.from_messages(\n",
    "        [\n",
    "            (\"system\", system),\n",
    "            (\"human\", human_message),\n",
    "        ]\n",
    "    )\n",
    "    llm = ChatOpenAI(temperature=0.7)\n",
    "    funny_response = funny_prompt | llm | StrOutputParser()\n",
    "    message = funny_response.invoke({})\n",
    "    state[\"query_result\"] = message\n",
    "    print(\"Generated funny response.\")\n",
    "    return state\n",
    "\n",
    "def end_max_iterations(state: AgentState):\n",
    "    state[\"query_result\"] = \"Please try again.\"\n",
    "    print(\"Maximum attempts reached. Ending the workflow.\")\n",
    "    return state\n",
    "\n",
    "def relevance_router(state: AgentState):\n",
    "    if state[\"relevance\"].lower() == \"relevant\":\n",
    "        return \"convert_to_sql\"\n",
    "    else:\n",
    "        return \"generate_funny_response\"\n",
    "\n",
    "def check_attempts_router(state: AgentState):\n",
    "    if state[\"attempts\"] < 3:\n",
    "        return \"convert_to_sql\"\n",
    "    else:\n",
    "        return \"end_max_iterations\"\n",
    "\n",
    "def execute_sql_router(state: AgentState):\n",
    "    if not state.get(\"sql_error\", False):\n",
    "        return \"generate_human_readable_answer\"\n",
    "    else:\n",
    "        return \"regenerate_query\"\n",
    "\n",
    "workflow = StateGraph(AgentState)\n",
    "\n",
    "workflow.add_node(\"get_current_user\", get_current_user)\n",
    "workflow.add_node(\"check_relevance\", check_relevance)\n",
    "workflow.add_node(\"convert_to_sql\", convert_nl_to_sql)\n",
    "workflow.add_node(\"execute_sql\", execute_sql)\n",
    "workflow.add_node(\"generate_human_readable_answer\", generate_human_readable_answer)\n",
    "workflow.add_node(\"regenerate_query\", regenerate_query)\n",
    "workflow.add_node(\"generate_funny_response\", generate_funny_response)\n",
    "workflow.add_node(\"end_max_iterations\", end_max_iterations)\n",
    "\n",
    "workflow.add_edge(\"get_current_user\", \"check_relevance\")\n",
    "\n",
    "workflow.add_conditional_edges(\n",
    "    \"check_relevance\",\n",
    "    relevance_router,\n",
    "    {\n",
    "        \"convert_to_sql\": \"convert_to_sql\",\n",
    "        \"generate_funny_response\": \"generate_funny_response\",\n",
    "    },\n",
    ")\n",
    "\n",
    "workflow.add_edge(\"convert_to_sql\", \"execute_sql\")\n",
    "\n",
    "workflow.add_conditional_edges(\n",
    "    \"execute_sql\",\n",
    "    execute_sql_router,\n",
    "    {\n",
    "        \"generate_human_readable_answer\": \"generate_human_readable_answer\",\n",
    "        \"regenerate_query\": \"regenerate_query\",\n",
    "    },\n",
    ")\n",
    "\n",
    "workflow.add_conditional_edges(\n",
    "    \"regenerate_query\",\n",
    "    check_attempts_router,\n",
    "    {\n",
    "        \"convert_to_sql\": \"convert_to_sql\",\n",
    "        \"max_iterations\": \"end_max_iterations\",\n",
    "    },\n",
    ")\n",
    "\n",
    "workflow.add_edge(\"generate_human_readable_answer\", END)\n",
    "workflow.add_edge(\"generate_funny_response\", END)\n",
    "workflow.add_edge(\"end_max_iterations\", END)\n",
    "\n",
    "workflow.set_entry_point(\"get_current_user\")\n",
    "\n",
    "app = workflow.compile()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import Image, display\n",
    "\n",
    "try:\n",
    "    display(Image(app.get_graph(xray=True).draw_mermaid_png()))\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "fake_config = {\"configurable\": {\"current_user_id\": \"2\"}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Retrieving the current user based on user ID.\n",
      "Current user set to: Bob\n",
      "Retrieved database schema.\n",
      "Checking relevance of the question: Get me all the orders.\n",
      "Relevance determined: relevant\n",
      "Retrieved database schema.\n",
      "Converting question to SQL for user 'Bob': Get me all the orders.\n",
      "Generated SQL query: SELECT orders.id AS order_id, food.name AS food_name, food.price AS price, users.name AS user_name FROM orders JOIN food ON orders.food_id = food.id JOIN users ON orders.user_id = users.id WHERE users.name = 'Bob'\n",
      "Executing SQL query: SELECT orders.id AS order_id, food.name AS food_name, food.price AS price, users.name AS user_name FROM orders JOIN food ON orders.food_id = food.id JOIN users ON orders.user_id = users.id WHERE users.name = 'Bob'\n",
      "Raw SQL Query Result: [{'order_id': 3, 'food_name': 'Lasagne', 'price': 14.0, 'user_name': 'Bob'}, {'order_id': 4, 'food_name': 'Spaghetti Carbonara', 'price': 15.0, 'user_name': 'Bob'}]\n",
      "SQL SELECT query executed successfully.\n",
      "Generating a human-readable answer.\n",
      "Generated human-readable answer.\n",
      "Result: Hello Bob, you have ordered Lasagne for $14.0 and Spaghetti Carbonara for $15.0.\n"
     ]
    }
   ],
   "source": [
    "user_question_1 = \"Get me all the orders.\"\n",
    "result_1 = app.invoke({\"question\": user_question_1, \"attempts\": 0}, config=fake_config)\n",
    "print(\"Result:\", result_1[\"query_result\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'order_id': 3, 'food_name': 'Lasagne', 'price': 14.0},\n",
       " {'order_id': 4, 'food_name': 'Spaghetti Carbonara', 'price': 15.0}]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_orders_for_user(user_id: int):\n",
    "    session = SessionLocal()\n",
    "    try:\n",
    "        orders = (\n",
    "            session.query(Order)\n",
    "            .join(Food, Order.food_id == Food.id)\n",
    "            .filter(Order.user_id == user_id)\n",
    "            .all()\n",
    "        )\n",
    "        if not orders:\n",
    "            print(f\"No orders found for user_id {user_id}.\")\n",
    "            return []\n",
    "\n",
    "        order_list = []\n",
    "        for order in orders:\n",
    "            order_info = {\n",
    "                \"order_id\": order.id,\n",
    "                \"food_name\": order.food.name,\n",
    "                \"price\": order.food.price\n",
    "            }\n",
    "            order_list.append(order_info)\n",
    "\n",
    "        return order_list\n",
    "    except Exception as e:\n",
    "        print(f\"Error retrieving orders for user_id {user_id}: {e}\")\n",
    "        return []\n",
    "    finally:\n",
    "        session.close()\n",
    "\n",
    "orders = get_orders_for_user(2)\n",
    "orders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_question_2 = \"Tell me a joke.\"\n",
    "result_2 = app.invoke({\"question\": user_question_2, \"attempts\": 0}, config=fake_config)\n",
    "print(\"Result:\", result_2[\"query_result\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_question_3 = \"Show me my orders\"\n",
    "result_3 = app.invoke({\"question\": user_question_3, \"attempts\": 0}, config=fake_config)\n",
    "print(\"Result:\", result_3[\"query_result\"])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}