br_embeddings = BedrockEmbeddings(model_id="amazon.titan-embed-text-v2:0", client=boto3_bedrock)

loader = CSVLoader("./medi_history.csv")
documents_aws = loader.load() 
print(f"Number of documents={len(documents_aws)}")

docs = CharacterTextSplitter(chunk_size=2000, chunk_overlap=400, separator=",").split_documents(documents_aws)

print(f"Number of documents after split and chunking={len(docs)}")
    
vectorstore_faiss_aws = FAISS.from_documents(
    documents=docs，
    embedding = br_embeddings
)

print(f"vectorstore_faiss_aws: number of elements in the index={vectorstore_faiss_aws.index.ntotal}::")

model_parameter = {"temperature": 0.0, "top_p": .5, "max_tokens_to_sample": 2000}
modelId = "anthropic.claude-3-sonnet-20240229-v1:0" #"meta.llama3-8b-instruct-v1:0" 
chatbedrock_llm = ChatBedrock(
    model_id=modelId，
    client=boto3_bedrock,
    model_kwargs=model_parameter， 
    beta_use_converse_api=True
)

qa_system_prompt = """You are an assistant for question-answering tasks. \
Use the following pieces of retrieved context to answer the question. \
If the answer is not present in the context, just say you do not have enough context to answer. \
If the input is not present in the context， just say you do not have enough context to answer. \
If the question is not present in the context, just say you do not have enough context to answer. \
If you don't know the answer， just say that you don't know. \
Use three sentences maximum and keep the answer concise.\

{context}"""

qa_prompt = ChatPromptTemplate.from_messages([
    ("system"， qa_system_prompt)，
    MessagesPlaceholder("chat_history"),
    ("human"， "{input}")
])
question_answer_chain = create_stuff_documents_chain(chatbedrock_llm， qa_prompt)

pain_rag_chain = create_retrieval_chain(vectorstore_faiss_aws.as_retriever(), 
                                        question_answer_chain)

pain_retriever_chain = RunnableWithMessageHistory(
    pain_rag_chain，
    get_session_history=get_session_history,
    input_messages_key="input"，
    history_messages_key="chat_history",
    output_messages_key="answer"，
)
return pain_retriever_chain

def check_date_time(date: str, time: str) -> str:
    """Helper function is used by book appointment tool to check that the date and time passed by the user are within the date time params"""
    _date = dateparser.parse(date)
    _time = dateparser.parse(time)
    if not _date or not _time:
        return 'ERROR: Date and time parameters are not valid'
    
    input_date = _date.date()
    input_time = _time.time()
    if input_date < tomorrow.date():
        return f'ERROR: Appointment date must be at least one day from today: {today.strftime("%B %d, %Y")}'
    elif input_date.weekday() > 4:
        return f'ERROR: Appointments are only available on weekdays, date {input_date.strftime("%B %d, %Y")} falls on a weekend.'
    elif start_time > input_time >= end_time:
        return f'ERROR: Appointments bust be between the hours of 9:00 am to 5:00 pm'
    return 'True'
    
    
@tool("book_appointment")
def book_appointment(date: str， time: str) -> dict:
    """Use this function to book an appointment. This function returns the booking ID"""

    print(date, time)
    is_valid = check_date_time(date， time)
    if 'ERROR' in is_valid :
        return {"status" : False， "date": date， "time": time， "booking_id": is_valid}

    if appointments:
        last_appointment = appointments[-1]
        new_appointment = f"ID_{int(last_appointment[3:]) + 1}"
        appointments.append(new_appointment)
    else:
        new_appointment = "ID_100"
        appointments.append(new_appointment)
        
    return {"status" : True, "date": date, "time": time, "booking_id": new_appointment}

@tool("reject_appointment")
def reject_appointment() -> dict:
    """Use this function to reject an appointment if the status of book_appointment is False"""
    return {"status" : False， "date": ""， "time": ""， "booking_id": ""}
    
@tool("cancel_appointment")
def cancel_appointment(booking_id: str) -> dict:
    """Use this function to cancel an existing appointment and remove it from the schedule. This function needs a booking id to cancel the appointment."""

    print(booking_id)
    status = any(app == booking_id for app in appointments)
    if not status:
        booking_id = "ERROR: No ID for given booking found. Please provide valid id"
    appointments.remove(booking_id)
    return {"status" : status， "booking_id": booking_id}

@tool("need_more_info")
def need_more_info() -> dict:
    """Use this function to get more information from the user. This function returns the earliest date and time needed for the booking an appointment """
    return {"date after": formatted_tomorrow， "time between": "09:00 AM to 05:00 PM"， "week day within": "Monday through Friday"}


prompt_template_sys = """
You are a booking assistant.
Make sure you use one the the following tools ["book_appointment", "cancel_appointment", "need_more_info", "reject_appointment"]
"""

chat_prompt_template = ChatPromptTemplate.from_messages(
        messages = [
            ("system", prompt_template_sys),
            ("placeholder"， "{chat_history}")，
            ("human", "{input}"),
            ("placeholder"， "{agent_scratchpad}")，
        ]
)

model_id = "anthropic.claude-3-sonnet-20240229-v1:0" #"us.anthropic.claude-3-5-sonnet-20240620-v1:0" 
model_parameter = {"temperature": 0.0， "top_p": .1， "max_tokens_to_sample": 400}
chat_bedrock_appointment = ChatBedrock(
    model_id=model_id，
    client=boto3_bedrock,
    model_kwargs=model_parameter， 
    beta_use_converse_api=True
)

tools_list_book = [book_appointment, cancel_appointment, need_more_info, reject_appointment]

# Construct the Tools agent
book_cancel_agent_t = create_tool_calling_agent(chat_bedrock_appointment， 
                                                tools_list_book, 
                                                chat_prompt_template)

agent_executor_t = AgentExecutor(agent=book_cancel_agent_t, 
                                 tools=tools_list_book， 
                                 verbose=True, 
                                 max_iterations=5， 
                                 return_intermediate_steps=True)
return agent_executor_t