Error with run Customer Support with langgraph using gemini api

[AtmehEsraa]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

%%capture --no-stderr
%pip install langchain_openai langchain-core langchain-community langchain-experimental \
    langgraph python-docx docx2txt pypdf unstructured faiss-gpu
%pip install -qU langchain-google-genai langchain-google-vertexai

from langchain_google_genai import ChatGoogleGenerativeAI, GoogleGenerativeAIEmbeddings
from langchain_google_vertexai import ChatVertexAI, VertexAIEmbeddings
from langchain_community.llms import Ollama
import os

os.environ["GOOGLE_API_KEY"]= ""
llm = ChatGoogleGenerativeAI(
    model="gemini-1.5-pro",
    temperature=0,
    max_retries=2,
    stream=True,
)

import os
import shutil
import sqlite3
from langchain_community.document_loaders import TextLoader
import pandas as pd
import requests
import re
import os
import docx
import numpy as np
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_community.document_loaders import (
    WebBaseLoader, PyPDFLoader, TextLoader, UnstructuredMarkdownLoader, DirectoryLoader, Docx2txtLoader
)
from langchain_community.document_loaders.csv_loader import CSVLoader
from langchain_openai import AzureOpenAIEmbeddings
from langchain_core.tools import tool
from urllib.parse import urlparse
from langchain.chains import RetrievalQA
db_url = "https://storage.googleapis.com/benchmarks-artifacts/travel-db/travel2.sqlite"
local_file = "travel2.sqlite"
# The backup lets us restart for each tutorial section
backup_file = "travel2.backup.sqlite"
overwrite = False
if overwrite or not os.path.exists(local_file):
    response = requests.get(db_url)
    response.raise_for_status()  # Ensure the request was successful
    with open(local_file, "wb") as f:
        f.write(response.content)
    # Backup - we will use this to "reset" our DB in each section
    shutil.copy(local_file, backup_file)


db = local_file  # We'll be using this local file as our DB in this tutorial

def is_url(path: str) -> bool:
    parsed = urlparse(path)
    return bool(parsed.scheme and parsed.netloc)

def load_file(file_path):
    file_extension = os.path.splitext(file_path)[1].lower()
    splitter = RecursiveCharacterTextSplitter(chunk_size=512, chunk_overlap=128)

    if file_extension == '.txt':
        loader = TextLoader(file_path)
    elif file_extension == '.pdf':
        loader = PyPDFLoader(file_path)
    elif file_extension == '.md':
        loader = UnstructuredMarkdownLoader(file_path)
    elif file_extension == '.csv':
        loader = CSVLoader(file_path)
    elif file_extension == '.docx':
        loader = Docx2txtLoader(file_path)
    elif is_url(file_path):
        loader = WebBaseLoader(file_path)
    else:
        raise ValueError(f"Unsupported file format: {file_extension}")

    docs = loader.load()
    return splitter.split_documents(docs)

# File paths
UAE_School_file_path = "/content/frameworkbooken.pdf"
Oman_Airport_file_path = "/content/data.txt"
Swiss_Policy_file_path = "/content/swiss_faq.md"
Jordanian_file_path = "/content/King_Abdullah_II.docx"
Employee_file_path = "/content/Employee.csv"
PIF_URL = "https://www.pif.gov.sa/en/"
Oman_Airports_URL = "https://www.omanairports.co.om/en"
GCO_URL = "https://www.gco.gov.qa/en/"
# MOH_KW_URL = "https://www.moh.gov.kw/en/Pages/default.aspx"
Bahrain_Services_URL = "https://services.bahrain.bh/wps/portal/en/BSP/HomeeServicesPortal/!ut/p/z1/jY_NDoIwEISfhiu7RqnVG5rgT4gHDQF7McWUgimUlAqvL1EvJtq4t9l8M5MBBhmwhveV5LbSDVejPjNymewC3NI14iJJIiR0E81mhB7nMYH0CeCPCxHYP34HwNzxKTBXxeoQvAFHxh6YVDp_zQ2bfEolMCMKYYTx72Z8l9a23dJDD4dh8KXWUgn_qmsPv1lK3VnIPkk4cQNtnWR4C1QfF-EDlTF7yg!!/dz/d5/L0lHSkpZQSEhL3dMTUFOa0FFa0EhIS80TlZFL2Vu/"

# Search settings
search_kwargs = {
    "distance_metric": "cos",
    "fetch_k": 20,
    "k": 1,
    "maximal_marginal_relevance": True
}

# Embedding client
embed = GoogleGenerativeAIEmbeddings(
    model="models/text-embedding-004", task_type="retrieval_query")
# Load and process files
def initialize_retriever(file_path, embed, search_kwargs):
    try:
        docs = load_file(file_path)
        vector = FAISS.from_documents(docs, embed)
        retriever = vector.as_retriever()
        retriever.search_kwargs = search_kwargs
        print(f"{file_path} retriever initialized successfully.")
        return retriever
    except Exception as e:
        print(f"Error processing {file_path}: {e}")
        return None

retriever_uae_school = initialize_retriever(UAE_School_file_path, embed, search_kwargs)
retriever_oman_airport = initialize_retriever(Oman_Airport_file_path, embed, search_kwargs)
retriever_swiss_policy = initialize_retriever(Swiss_Policy_file_path, embed, search_kwargs)
retriever_jordanian = initialize_retriever(Jordanian_file_path, embed, search_kwargs)
retriever_employee = initialize_retriever(Employee_file_path, embed, search_kwargs)
retriever_pif = initialize_retriever(PIF_URL, embed, search_kwargs)
retriever_oman = initialize_retriever(Oman_Airports_URL, embed, search_kwargs)
retriever_gco = initialize_retriever(GCO_URL, embed, search_kwargs)
# retriever_kw = initialize_retriever(MOH_KW_URL, embed, search_kwargs)
retriever_bahrain = initialize_retriever(Bahrain_Services_URL, embed, search_kwargs)

from langchain_experimental.agents import create_pandas_dataframe_agent
from langchain.agents import AgentType
from langchain_experimental.tools import PythonAstREPLTool
from langchain.chains import RetrievalQA

qa_oman_airport = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_oman_airport)
qa_swiss_policy = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_swiss_policy)
qa_jordanian = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_jordanian)
qa_uae_school = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_uae_school)
qa_employee_data = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_employee)
qa_pif = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_pif)
qa_oman = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_oman)
qa_gco = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_gco)
# qa_kw = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_kw)
qa_bahrain = RetrievalQA.from_chain_type(llm=llm, chain_type='stuff', retriever=retriever_bahrain)

@tool
def lookup_oman_airport_data(query: str) -> str:
    """Retrieve information about Oman Airport to answer questions related to airport operations, facilities, and services in Oman."""
    try:
        response = qa_oman_airport.invoke({"query": query})
        return response["result"]
    except Exception as e:
        return f"Error during query: {e}"

# @tool
# def lookup_swiss_policy_faq(query: str) -> str:
#     """Retrieve information related to Swiss Policy FAQs from available documents."""
#     try:
#         response = qa_swiss_policy.invoke({"query": query})
#         return response["result"]
#     except Exception as e:
#         return f"Error during query: {e}"

@tool
def lookup_jordanian_documents(query: str) -> str:
    """Retrieve information about Jordanian documents to answer questions related to official documents, regulations, and guidelines in Jordan."""
    try:
        response = qa_jordanian.invoke({"query": query})
        return response["result"]
    except Exception as e:
        return f"Error during query: {e}"

@tool
def lookup_uae_school_inspection(query: str) -> str:
    """Retrieve information about the UAE School Inspection Framework to answer questions related to school inspections in the United Arab Emirates."""
    try:
        response = qa_uae_school.invoke({"query": query})
        return response["result"]
    except Exception as e:
        return f"Error during query: {e}"

@tool
def lookup_employee_data(query: str) -> str:
    """Retrieve information from the Employee data to answer questions related to employee demographics, employment details, and any other relevant analysis."""
    try:

      csv_file='/content/Employee.csv'
      #creating the document with Pandas.
      document = pd.read_csv(csv_file)

      sm_ds_OAI = create_pandas_dataframe_agent(
          llm,
          document,
          tools=[PythonAstREPLTool()],
          allow_dangerous_code=True,
          agent_type=AgentType.OPENAI_FUNCTIONS,
          return_intermediate_steps=True)
      response = sm_ds_OAI.invoke({"input": query + " using tool python_repl_ast"})
      return response["output"]
    except Exception as e:
        return f"Error during query: {e}"

@tool
def lookup_public_investment_fund(query: str) -> str:
    """Retrieve information about the Public Investment Fund (PIF) to answer questions related to its investments, strategies, financials, and overall impact."""
    try:
        response = qa_pif.invoke({"query": query})
        return response["result"]
    except Exception as e:
        return f"Error during query: {e}"

@tool
def lookup_oman_airport_website(query: str) -> str:
    """Retrieve information about Oman Airport to answer questions related to airport operations, facilities, and services in Oman."""
    try:
        response = qa_oman.invoke({"query": query})
        return response["result"]
    except Exception as e:
        return f"Error during query: {e}"

@tool
def lookup_gco_data(query: str) -> str:
    """Retrieve information about the Government Communications Office (GCO) of Qatar to answer questions related to its communications, priorities, and objectives."""
    try:
        response = qa_gco.invoke({"query": query})
        return response["result"]
    except Exception as e:
        return f"Error during query: {e}"

@tool
def lookup_bahrain_government_data(query: str) -> str:
    """Retrieve information about the Bahrain government to answer questions related to its policies, services, and initiatives."""
    try:
        response = qa_bahrain.invoke({"query": query})
        return response["result"]
    except Exception as e:
        return f"Error during query: {e}"

import re

import numpy as np
from langchain_community.embeddings import OllamaEmbeddings
from langchain_core.tools import tool

response = requests.get(
    "https://storage.googleapis.com/benchmarks-artifacts/travel-db/swiss_faq.md"
)
response.raise_for_status()
faq_text = response.text

docs = [{"page_content": txt} for txt in re.split(r"(?=\n##)", faq_text)]


class VectorStoreRetriever:
    def __init__(self, docs: list, vectors: list, embed_client):
        self._arr = np.array(vectors)
        self._docs = docs
        self._client = embed_client

    @classmethod
    def from_docs(cls, docs, embed_client):
        embeddings = embed_client.embed_documents(
            [doc["page_content"] for doc in docs]
        )
        #vectors = [emb.embedding for emb in embeddings.data]
        return cls(docs, embeddings, embed_client)

    def query(self, query: str, k: int = 5) -> list[dict]:
        embed = self._client.embed_query(
            query
        )
        # "@" is just a matrix multiplication in python
        scores = np.array(embed) @ self._arr.T
        top_k_idx = np.argpartition(scores, -k)[-k:]
        top_k_idx_sorted = top_k_idx[np.argsort(-scores[top_k_idx])]
        return [
            {**self._docs[idx], "similarity": scores[idx]} for idx in top_k_idx_sorted
        ]


retriever = VectorStoreRetriever.from_docs(docs, embed)


@tool
def lookup_policy(query: str) -> str:
    """Consult the company policies to check whether certain options are permitted."""
    docs = retriever.query(query, k=2)
    return "\n\n".join([doc["page_content"] for doc in docs])

import sqlite3
from datetime import date, datetime
from typing import Optional
from langchain_core.tools import tool
import pytz
from langchain_core.runnables import ensure_config


@tool
def fetch_user_flight_information() -> list[dict]:
    """Fetch all tickets for the user along with corresponding flight information and seat assignments.

    Returns:
        A list of dictionaries where each dictionary contains the ticket details,
        associated flight details, and the seat assignments for each ticket belonging to the user.
    """
    config = ensure_config(configjson)
    configuration = config.get("configurable", {})
    passenger_id = configuration.get("passenger_id", None)
    if not passenger_id:
        raise ValueError("No passenger ID configured.")
    db = local_file
    conn = sqlite3.connect(db)
    cursor = conn.cursor()

    query = """
    SELECT
        t.ticket_no, t.book_ref,
        f.flight_id, f.flight_no, f.departure_airport, f.arrival_airport,
        f.scheduled_departure, f.scheduled_arrival,
        f.status, f.aircraft_code, f.actual_departure, f.actual_arrival,
        bp.seat_no, tf.fare_conditions
    FROM
        tickets t
        JOIN ticket_flights tf ON t.ticket_no = tf.ticket_no
        JOIN flights f ON tf.flight_id = f.flight_id
        JOIN boarding_passes bp ON bp.ticket_no = t.ticket_no AND bp.flight_id = f.flight_id
    WHERE
        t.passenger_id = ?
    """

    cursor.execute(query, (passenger_id,))
    rows = cursor.fetchall()
    column_names = [column[0] for column in cursor.description]
    results = [dict(zip(column_names, row)) for row in rows]

    cursor.close()
    conn.close()

    return results



@tool
def search_flights(
    departure_airport: Optional[str] = None,
    arrival_airport: Optional[str] = None,
    start_time: Optional[date | datetime] = None,
    end_time: Optional[date | datetime] = None,
    limit: int = 20,
) -> list[dict]:
    """Search for flights based on passenger ID, departure airport, arrival airport, and departure time range."""

    config = ensure_config(configjson)
    configuration = config.get("configurable", {})
    passenger_id = configuration.get("passenger_id", None)
    if not passenger_id:
        raise ValueError("No passenger ID configured.")

    conn = sqlite3.connect(db)
    cursor = conn.cursor()

    query = """
    SELECT f.*
    FROM flights f
    JOIN ticket_flights tf ON f.flight_id = tf.flight_id
    JOIN tickets t ON tf.ticket_no = t.ticket_no
    WHERE 1 = 1
    """
    params = []

    if passenger_id:
        query += " AND t.passenger_id = ?"
        params.append(passenger_id)

    if departure_airport:
        query += " AND f.departure_airport = ?"
        params.append(departure_airport)

    if arrival_airport:
        query += " AND f.arrival_airport = ?"
        params.append(arrival_airport)

    if start_time:
        query += " AND f.scheduled_departure >= ?"
        params.append(start_time)

    if end_time:
        query += " AND f.scheduled_departure <= ?"
        params.append(end_time)

    query += " LIMIT ?"
    params.append(limit)

    cursor.execute(query, params)
    rows = cursor.fetchall()
    column_names = [column[0] for column in cursor.description]
    results = [dict(zip(column_names, row)) for row in rows]

    cursor.close()
    conn.close()

    return results


@tool
def update_ticket_to_new_flight(ticket_no: str, new_flight_id: int) -> str:
    """Update the user's ticket to a new valid flight and save the update to the database."""

    config = ensure_config(configjson)
    configuration = config.get("configurable", {})

    passenger_id = configuration.get("passenger_id", None)
    db = local_file

    if not passenger_id:
        raise ValueError("No passenger ID configured.")

    try:
        with sqlite3.connect(db) as conn:
            cursor = conn.cursor()

            # Fetch new flight details
            cursor.execute(
                """
                SELECT flight_no, departure_airport, arrival_airport, scheduled_departure, scheduled_arrival
                FROM flights WHERE flight_id = ?
                """,
                (new_flight_id,)
            )
            new_flight = cursor.fetchone()
            if not new_flight:
                return "Invalid new flight ID provided."

            # Update `ticket_flights` table to link ticket to new flight
            cursor.execute(
                "UPDATE ticket_flights SET flight_id = ? WHERE ticket_no = ?",
                (new_flight_id, ticket_no)
            )

            # Update or reset seat number in `boarding_passes` if necessary
            cursor.execute(
                """
                SELECT seat_no FROM boarding_passes WHERE ticket_no = ? AND flight_id = ?
                """,
                (ticket_no, new_flight_id)
            )
            seat_no = cursor.fetchone()

            if not seat_no:
                cursor.execute(
                    "UPDATE boarding_passes SET flight_id = ?, seat_no = NULL WHERE ticket_no = ?",
                    (new_flight_id, ticket_no)
                )
            else:
                cursor.execute(
                    "UPDATE boarding_passes SET flight_id = ?, seat_no = ? WHERE ticket_no = ?",
                    (new_flight_id, seat_no[0], ticket_no)
                )

            # Optionally update fare conditions if related to the flight change
            cursor.execute(
                """
                UPDATE ticket_flights
                SET fare_conditions = (
                    SELECT fare_conditions FROM flights WHERE flight_id = ?
                ) WHERE ticket_no = ?
                """,
                (new_flight_id, ticket_no)
            )

            # Commit the transaction (this is what saves the changes)
            conn.commit()

            # Fetch the updated ticket information to return as a preview
            cursor.execute(
                """
                SELECT
                    t.ticket_no, t.book_ref,
                    f.flight_id, f.flight_no, f.departure_airport, f.arrival_airport, f.scheduled_departure, f.scheduled_arrival,
                    bp.seat_no, tf.fare_conditions
                FROM
                    tickets t
                    JOIN ticket_flights tf ON t.ticket_no = tf.ticket_no
                    JOIN flights f ON tf.flight_id = f.flight_id
                    JOIN boarding_passes bp ON bp.ticket_no = t.ticket_no AND bp.flight_id = f.flight_id
                WHERE
                    t.passenger_id = ? AND t.ticket_no = ?
                """,
                (passenger_id, ticket_no)
            )
            updated_ticket_info = cursor.fetchone()

            cursor.close()

            # Prepare the result as a dictionary (for display purposes)
            result = {
                'ticket_no': updated_ticket_info[0],
                'book_ref': updated_ticket_info[1],
                'flight_id': updated_ticket_info[2],
                'flight_no': updated_ticket_info[3],
                'departure_airport': updated_ticket_info[4],
                'arrival_airport': updated_ticket_info[5],
                'scheduled_departure': updated_ticket_info[6],
                'scheduled_arrival': updated_ticket_info[7],
                'seat_no': updated_ticket_info[8],
                'fare_conditions': updated_ticket_info[9],
            }

            return result

    except sqlite3.Error as e:
        return f"An error occurred with the database: {str(e)}"

@tool
def cancel_ticket(ticket_no: str) -> str:
    """Cancel the user's ticket and remove it from the database."""

    # Assuming the configuration and db connection are set up correctly
    config = ensure_config(configjson)
    configuration = config.get("configurable", {})

    passenger_id = configuration.get("passenger_id", None)
    if not passenger_id:
        raise ValueError("No passenger ID configured.")
    db = local_file
    conn = sqlite3.connect(db)
    cursor = conn.cursor()

    cursor.execute(
        "SELECT ticket_no FROM ticket_flights WHERE ticket_no = ?", (ticket_no,)
    )
    existing_ticket = cursor.fetchone()
    if not existing_ticket:
        cursor.close()
        conn.close()
        return "No existing ticket found for the given ticket number."

    cursor.execute(
        "SELECT ticket_no FROM tickets WHERE ticket_no = ? AND passenger_id = ?",
        (ticket_no, passenger_id),
    )
    current_ticket = cursor.fetchone()
    if not current_ticket:
        cursor.close()
        conn.close()
        return f"Current signed-in passenger with ID {passenger_id} is not the owner of ticket {ticket_no}"

    # Delete the ticket from the database
    cursor.execute("DELETE FROM ticket_flights WHERE ticket_no = ?", (ticket_no,))
    conn.commit()

    cursor.close()
    conn.close()
    return "Ticket successfully cancelled."

@tool
def book_hotel(hotel_id: int) -> str:
    """
    Book a hotel by its ID.

    Args:
        hotel_id (int): The ID of the hotel to book.

    Returns:
        str: A message indicating whether the hotel was successfully booked or not.
    """
    conn = sqlite3.connect(db)
    cursor = conn.cursor()

    cursor.execute("UPDATE hotels SET booked = 1 WHERE id = ?", (hotel_id,))
    conn.commit()

    if cursor.rowcount > 0:
        conn.close()
        return f"Hotel {hotel_id} successfully booked."
    else:
        conn.close()
        return f"No hotel found with ID {hotel_id}."
@tool
def book_ticket(
    flight_id: str, flight_no: str, departure_airport: str, arrival_airport: str,
    scheduled_departure: str, scheduled_arrival: str, status: str,
    aircraft_code: str, actual_departure: str = None, actual_arrival: str = None
) -> str:
    """Book a ticket for the user and add it to the database. Also insert the flight if not exists."""
    config = ensure_config(configjson)
    configuration = config.get("configurable", {})
    passenger_id = configuration.get("passenger_id", None)
    db = local_file
    if not passenger_id:
        return "Error: No passenger ID configured."

    conn = sqlite3.connect(db)
    cursor = conn.cursor()

    try:
        # Check if flight exists, if not, insert it
        cursor.execute("SELECT flight_id FROM flights WHERE flight_id = ?", (flight_id,))
        existing_flight = cursor.fetchone()

        if not existing_flight:
            cursor.execute(
                """
                INSERT INTO flights (
                    flight_id, flight_no, departure_airport, arrival_airport,
                    scheduled_departure, scheduled_arrival, status, aircraft_code,
                    actual_departure, actual_arrival
                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (flight_id, flight_no, departure_airport, arrival_airport,
                 scheduled_departure, scheduled_arrival, status, aircraft_code,
                 actual_departure, actual_arrival)
            )

        # Check if the passenger already has a ticket for this flight
        cursor.execute(
            """
            SELECT t.ticket_no
            FROM tickets t
            JOIN ticket_flights tf ON t.ticket_no = tf.ticket_no
            WHERE tf.flight_id = ? AND t.passenger_id = ?
            """,
            (flight_id, passenger_id)
        )
        existing_ticket = cursor.fetchone()
        if existing_ticket:
            return f"Passenger with ID {passenger_id} already has a ticket for flight {flight_id}."

        # Insert a new ticket
        cursor.execute(
            "INSERT INTO tickets (book_ref, passenger_id) VALUES (?, ?)",
            (str(uuid.uuid4())[:6], passenger_id)
        )
        ticket_no = cursor.lastrowid

        # Link the ticket to the flight
        cursor.execute(
            "INSERT INTO ticket_flights (ticket_no, flight_id, fare_conditions) VALUES (?, ?, ?)",
            (ticket_no, flight_id, 'Economy')
        )

        # Create a boarding pass
        cursor.execute(
            "INSERT INTO boarding_passes (ticket_no, flight_id, seat_no) VALUES (?, ?, ?)",
            (ticket_no, flight_id, '15A')
        )

        conn.commit()
        return f"Ticket for flight {flight_id} successfully booked for passenger {passenger_id}."

    except Exception as e:
        return f"An error occurred while booking the ticket: {str(e)}"

    finally:
        cursor.close()
        conn.close()
from typing import Optional, List, Dict, Union
from datetime import date, datetime, timedelta

@tool
def find_flights(
    departure_airport: Optional[str] = None,
    arrival_airport: Optional[str] = None,
    start_time: Optional[Union[date, datetime]] = None,
    end_time: Optional[Union[date, datetime]] = None,
    limit: int = 20,
) -> List[Dict]:
    """
    Search for flights based on departure airport, arrival airport, and departure time range.

    Args:
        departure_airport (Optional[str]): IATA code of the departure airport.
        arrival_airport (Optional[str]): IATA code of the arrival airport.
        start_time (Optional[Union[date, datetime]]): Start time for filtering flights.
        end_time (Optional[Union[date, datetime]]): End time for filtering flights.
        limit (int): Maximum number of results to return.

    Returns:
        List[Dict]: A list of dictionaries containing flight details.
    """

    # Adjust the database path to the actual location of your SQLite database
    conn = sqlite3.connect(db)
    cursor = conn.cursor()

    query = """
    SELECT flight_id, flight_no, scheduled_departure, scheduled_arrival, departure_airport, arrival_airport
    FROM flights
    WHERE 1 = 1
    """
    params = []

    if departure_airport:
        query += " AND departure_airport = ?"
        params.append(departure_airport)

    if arrival_airport:
        query += " AND arrival_airport = ?"
        params.append(arrival_airport)

    if start_time:
        if isinstance(start_time, date) and not isinstance(start_time, datetime):
            start_time = datetime.combine(start_time, datetime.min.time())
        query += " AND scheduled_departure >= ?"
        params.append(start_time)

    if end_time:
        if isinstance(end_time, date) and not isinstance(end_time, datetime):
            end_time = datetime.combine(end_time, datetime.max.time())
        query += " AND scheduled_departure <= ?"
        params.append(end_time)

    query += " LIMIT ?"
    params.append(limit)

    cursor.execute(query, params)
    rows = cursor.fetchall()
    column_names = [column[0] for column in cursor.description]
    results = [dict(zip(column_names, row)) for row in rows]

    cursor.close()
    conn.close()

    return results

@tool
def search_hotels(
    location: Optional[str] = None,
    name: Optional[str] = None,
    price_tier: Optional[str] = None,
    checkin_date: Optional[Union[datetime, date]] = None,
    checkout_date: Optional[Union[datetime, date]] = None,
) -> list[dict]:
    """
    Search for hotels based on location, name, price tier, check-in date, and check-out date.

    Args:
        location (Optional[str]): The location of the hotel. Defaults to None.
        name (Optional[str]): The name of the hotel. Defaults to None.
        price_tier (Optional[str]): The price tier of the hotel. Defaults to None. Examples: Midscale, Upper Midscale, Upscale, Luxury
        checkin_date (Optional[Union[datetime, date]]): The check-in date of the hotel. Defaults to None.
        checkout_date (Optional[Union[datetime, date]]): The check-out date of the hotel. Defaults to None.

    Returns:
        list[dict]: A list of hotel dictionaries matching the search criteria.
    """
    conn = sqlite3.connect(db)
    cursor = conn.cursor()

    query = "SELECT * FROM hotels WHERE 1=1"
    params = []

    if location:
        query += " AND location LIKE ?"
        params.append(f"%{location}%")
    if name:
        query += " AND name LIKE ?"
        params.append(f"%{name}%")
    # For the sake of this tutorial, we will let you match on any dates and price tier.
    cursor.execute(query, params)
    results = cursor.fetchall()

    conn.close()

    return [
        dict(zip([column[0] for column in cursor.description], row)) for row in results
    ]

from langchain_core.messages import ToolMessage
from langchain_core.runnables import RunnableLambda

from langgraph.prebuilt import ToolNode


def handle_tool_error(state) -> dict:
    error = state.get("error")
    tool_calls = state["messages"][-1].tool_calls
    return {
        "messages": [
            ToolMessage(
                content=f"Error: {repr(error)}\n please fix your mistakes.",
                tool_call_id=tc["id"],
            )
            for tc in tool_calls
        ]
    }


def create_tool_node_with_fallback(tools: list) -> dict:
    return ToolNode(tools).with_fallbacks(
        [RunnableLambda(handle_tool_error)], exception_key="error"
    )


def _print_event(event: dict, _printed: set, max_length=1500):
    current_state = event.get("dialog_state")
    if current_state:
        print("Currently in: ", current_state[-1])
    message = event.get("messages")
    if message:
        if isinstance(message, list):
            message = message[-1]
        if message.id not in _printed:
            msg_repr = message.pretty_repr(html=True)
            if len(msg_repr) > max_length:
                msg_repr = msg_repr[:max_length] + " ... (truncated)"
            print(msg_repr)
            _printed.add(message.id)

from typing import Annotated

from typing_extensions import TypedDict

from langgraph.graph.message import AnyMessage, add_messages


class State(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import Runnable, RunnableConfig
from langchain_experimental.llms.ollama_functions import OllamaFunctions

class Assistant:
    def __init__(self, runnable: Runnable):
        self.runnable = runnable

    def __call__(self, state: State, config: RunnableConfig):
        while True:
            configuration = config.get("configurable", {})
            passenger_id = configuration.get("passenger_id", None)
            state = {**state, "user_info": passenger_id}
            result = self.runnable.invoke(state)
            # If the LLM happens to return an empty response, we will re-prompt it
            # for an actual response.
            if not result.tool_calls and (
                not result.content
                or isinstance(result.content, list)
                and not result.content[0].get("text")
            ):
                messages = state["messages"] + [("user", "Respond with a real output.")]
                state = {**state, "messages": messages}
            else:
                break
        return {"messages": result}


primary_assistant_prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You are a helpful customer support assistant for Swiss Airlines. "
            " Use the provided tools to search for flights, company policies, and other information to assist the user's queries. "
            " When searching, be persistent. Expand your query bounds if the first search returns no results. "
            " If a search comes up empty, expand your search before giving up."
            "\n\nCurrent user:\n<User>\n{user_info}\n</User>"
            "\nCurrent time: {time}.",
        ),
        ("placeholder", "{messages}"),
    ]
).partial(time=datetime.now())






part_1_tools = [
    fetch_user_flight_information,
    update_ticket_to_new_flight,
    cancel_ticket,
    book_ticket,
    book_hotel,
    search_hotels,
    find_flights,
    lookup_public_investment_fund,
    lookup_employee_data,
    lookup_uae_school_inspection,
    lookup_jordanian_documents,
    lookup_policy,
    lookup_oman_airport_data,
    lookup_oman_airport_website,
    lookup_gco_data,
    # lookup_moh_kw_data,
    lookup_bahrain_government_data

]
part_1_assistant_runnable = primary_assistant_prompt | llm.bind_tools(part_1_tools)
!pip install -q langgraph-checkpoint-sqlite
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import END, StateGraph, START
from langgraph.prebuilt import tools_condition

builder = StateGraph(State)


# Define nodes: these do the work
builder.add_node("assistant", Assistant(part_1_assistant_runnable))
builder.add_node("tools", create_tool_node_with_fallback(part_1_tools))
# Define edges: these determine how the control flow moves
builder.add_edge(START, "assistant")
builder.add_conditional_edges(
    "assistant",
    tools_condition,
)
builder.add_edge("tools", "assistant")

# The checkpointer lets the graph persist its state
# this is a complete memory for the entire graph.
memory = MemorySaver()
part_1_graph = builder.compile(checkpointer=memory)
from IPython.display import Image, display

try:
    display(Image(part_1_graph.get_graph(xray=True).draw_mermaid_png()))
except Exception:
    # This requires some extra dependencies and is optional
    pass

import shutil
import uuid



tutorial_questions = [
    "Hello, Hi",
    "How are you",
    "What is the capital of France?",
    "I want to know more about Jordan history.",
    "Who call the shots?",
    "Who built you?",
    "What is your purpose?",
    "Tell me a joke?",
    "With whom am I talking?",
    "Are you interested in AI?",
    "Are you a real person?",
    "Perfect answer, thanks, Amazing",
    "Alexa is better, That's not relevant",
    "Back in a minute",
    "Hey I'm back",
    "I am just testing you",
    "What do you think of your chatbot?",
    "Thank you for your help.",
    "Huh? I don't understand.",
    "Could you provide a news update regarding electric vehicle usage in the UAE"
]


# Copy with the backup file so we can restart from the original place in each section
shutil.copy(backup_file, db)


thread_id = str(uuid.uuid4())
configjson = {
    "configurable": {
        "passenger_id": "3952 666242",
        "thread_id": thread_id,
        "flight_id": "",
        "ticket_no":""

    },
}

_printed = set()
for question in tutorial_questions:
    thread_id = str(uuid.uuid4())
    configjson["configurable"]["thread_id"] = thread_id
    events = part_1_graph.stream(
        {"messages": ("user", question)}, configjson, stream_mode="values"
    )

    for event in events:
      _print_event(event, _printed)

Description

Langchain_Evaluate_Gemini_SA_on_Flight_Booking,_RAG_and_Chat_Task_All_Together (1).zip
I’m getting an error in the booking tool. Could you please help me with it? I’ve attached the full notebook for your reference.

System Info

.