File size: 25,440 Bytes
68e80f1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
178fbcb
68e80f1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
749a8d2
a6ea608
 
68e80f1
 
 
 
 
749a8d2
68e80f1
 
 
 
 
 
 
 
 
 
 
 
 
a6ea608
68e80f1
 
 
 
 
a6ea608
68e80f1
 
 
749a8d2
68e80f1
749a8d2
 
68e80f1
 
749a8d2
 
 
 
 
68e80f1
 
749a8d2
 
 
 
 
68e80f1
 
749a8d2
178fbcb
68e80f1
 
 
 
749a8d2
 
 
 
 
 
 
178fbcb
749a8d2
 
 
68e80f1
749a8d2
68e80f1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
178fbcb
68e80f1
 
 
 
 
749a8d2
 
 
 
68e80f1
 
 
4336a60
 
68e80f1
 
 
 
 
 
 
749a8d2
 
68e80f1
 
178fbcb
68e80f1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
749a8d2
68e80f1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
749a8d2
68e80f1
 
 
 
 
 
 
 
 
 
 
 
 
 
749a8d2
68e80f1
 
 
178fbcb
68e80f1
 
 
178fbcb
68e80f1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3277fe6
68e80f1
 
 
 
 
 
 
 
 
 
 
 
 
178fbcb
68e80f1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643

######################## WRITE YOUR CODE HERE  #########################
# Import libraries
import os
import chromadb
from dotenv import load_dotenv
import json

# LangChain imports
from langchain_core.documents import Document
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain.prompts import ChatPromptTemplate
from langchain.chains.query_constructor.base import AttributeInfo
from langchain.retrievers.self_query.base import SelfQueryRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor, CrossEncoderReranker
from langchain.retrievers import ContextualCompressionRetriever

# LangChain community & experimental imports
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFDirectoryLoader, PyPDFLoader
from langchain_community.cross_encoders import HuggingFaceCrossEncoder
from langchain_experimental.text_splitter import SemanticChunker
from langchain.text_splitter import (
    CharacterTextSplitter,
    RecursiveCharacterTextSplitter
)
from langchain_core.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

# LangChain OpenAI imports
from langchain_openai import AzureOpenAIEmbeddings, AzureChatOpenAI
from langchain.memory import ConversationSummaryBufferMemory

from langchain_openai import ChatOpenAI
from langchain_community.embeddings import OpenAIEmbeddings
from langchain_openai import OpenAIEmbeddings
from langchain_community.embeddings.sentence_transformer import SentenceTransformerEmbeddings
from langchain_community.vectorstores import Chroma


from langchain_community.utilities.sql_database import SQLDatabase
from langchain_community.agent_toolkits import create_sql_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor

# LlamaParse & LlamaIndex imports
from llama_parse import LlamaParse
from llama_index.core import Settings, SimpleDirectoryReader

# LangGraph import
from langgraph.graph import StateGraph, END, START

# Pydantic import
from pydantic import BaseModel

# Typing imports
from typing import Dict, List, Tuple, Any, TypedDict

# Other utilities
import numpy as np
from groq import Groq
from mem0 import MemoryClient
import streamlit as st
from datetime import datetime

#====================================SETUP=====================================#
# Fetch secrets from Hugging Face Spaces
api_key = os.environ["API_KEY"]
endpoint = os.environ["OPENAI_API_BASE"]
llama_api_key = os.environ['LLAMA_API_KEY']
#mem0_api_key = os.environ['mem0']

# Initializing the OpenAI embedding function for Chroma
embedding_function = chromadb.utils.embedding_functions.OpenAIEmbeddingFunction(
    api_base=endpoint, # Complete the code to define the API base endpoint
    api_key=api_key, # Complete the code to define the API key
    model_name='text-embedding-ada-002' # This is a fixed value and does not need modification
)


# Initializing the OpenAI Embeddings
embedding_model = OpenAIEmbeddings(
    openai_api_base=endpoint,
    openai_api_key=api_key,
    model='text-embedding-ada-002'
)


# Initializing the Chat OpenAI model
llm = ChatOpenAI(
    openai_api_base=endpoint,
    openai_api_key=api_key,
    model="gpt-4o-mini",
    streaming=False
)

# set the LLM and embedding model in the LlamaIndex settings.
Settings.llm = llm # Complete the code to define the LLM model
Settings.embedding = embedding_model # Complete the code to define the embedding model

#================================Creating Langgraph agent======================#

class AgentState(TypedDict):
    query: str  # The current user query
    expanded_query: str  # The expanded version of the user query
    context: List[Dict[str, Any]]  # Retrieved documents (content and metadata)
    response: str  # The generated response to the user query
    precision_score: float  # The precision score of the response
    #groundedness_score: float  # The groundedness score of the response
    #groundedness_loop_count: int  # Counter for groundedness refinement loops
    precision_loop_count: int  # Counter for precision refinement loops
    feedback: str
    query_feedback: str
    #groundedness_check: bool
    loop_max_iter: int

def expand_query(state: AgentState) -> AgentState:
    """
    Expands the user query to improve retrieval of information using few-shot prompting.

    Args:
        state (Dict): The current state of the workflow, containing the user query.

    Returns:
        Dict: The updated state with the expanded query.
    """
    system_message = '''Perform query expansion on the query received. If there are multiple common ways of phrasing a user query \
or common synonyms for key words in the query, make sure to return multiple versions \
of the query with the different phrasings.

If the query has multiple parts, split them into separate simpler queries. This is the only case where you can generate more than 3 queries.

If there are acronyms or words you are not familiar with, do not try to rephrase them.

Return only 3 versions of the query as a list.
Generate only a list of queries. Do not mention anything before or after the list.

Question:
{query}'''

    expand_prompt = ChatPromptTemplate.from_messages([
        ("system", system_message),
        ("user", "{query}")
    ])

    chain = expand_prompt | llm | StrOutputParser()
    state['expanded_query'] = chain.invoke({"query": state['query']})
    return state


# Initialize the Chroma vector store for retrieving documents
vectorstore = Chroma(
    collection_name="haspit1",
    persist_directory="./haspit1_db",
    embedding_function=embedding_model

)

# Create a retriever from the vector store
retriever = vectorstore.as_retriever(
    search_type='similarity',
    search_kwargs={'k': 5}
)

def retrieve_documents(query: str):
    retrieved_documents = []
    retrieved_documents = retriever.invoke("Fetch at most 5 documents to answer"+str(query))
    retrieved_documents.extend(retriever.invoke("Fetch at most 5 tables to answer "+ str(query)))
    return retrieved_documents


def retrieve_context(state: AgentState) -> AgentState:
    """
    Retrieves documents from the vector store using the expanded or original query.

    Args:
        state (Dict): The current state of the workflow, containing the query and expanded query.

    Returns:
        Dict: The updated state with the retrieved documents.
    """
    query = state['expanded_query']
    #print("Query used for retrieval:", query)  # Debugging: Print the query

    # Retrieve documents from the vector store
    #docs = retriever.invoke(query)
    context_list = []
    #for query in state['expanded_query']:
        #print("Query used for retrieval:", query)  # Debugging: Print the query
    retrieved = retrieve_documents(query)
    #print("Retrieved documents:", retrieved)
    #docs = retriever.invoke(query)
    context_list.extend(retrieved)
    #print(context_list)
    #print("Retrieved documents:", retrieved)
    #return only unique docs
    unique_context_dict = {doc.metadata['source'].split("/")[-1]: doc for doc in context_list}
    unique_context_list = list(unique_context_dict.values())
    #print(unique_context_list)
    updated_state = state.copy()  # Create a shallow copy to avoid modifying the original
    updated_state['context'] = unique_context_list
    #state['context'] = unique_context_list
    #print("Unique documents retrieved")
    #print("Unique documents retrieved", unique_context_list)

    #return unique_context_list
    #print("Retrieved documents:", docs)  # Debugging: Print the raw docs object
    # Extract both page_content and metadata from each document
    #print("Document: ", doc.metadata['source'].split("/")[-1])
    #context= [
         #{
            #"Document": doc.metadata['source'].split("/")[-1],
            #"page": doc.metadata['page'],  # The page number or other metadata
            #"content": doc.page_content  # The actual content of the document
            #"metadata": doc.metadata  # The metadata (e.g., source, page number, etc.)
        #}

        #for doc in docs
    #]
    #state['context'] = context
    #print(updated_state['context'])  # Debugging: Print the extracted context
    return updated_state


def check_precision(state: Dict) -> Dict:
    """
    Checks whether the context precisely addresses the user’s query.

    Args:
        state (Dict): The current state of the workflow, containing the query and response.

    Returns:
        Dict: The updated state with the precision score.
    """
    #print("---------check_precision---------")
    system_message = '''Given the query and context verify if the context was useful in arriving at the answer.
    Give precision score of "1" if useful and "0" if it was not useful.
    '''

    precision_prompt = ChatPromptTemplate.from_messages([
        ("system", system_message),
        ("user", "Query: {query}\nResponse: {context}\n\nPrecision score:")
    ])

    chain = precision_prompt | llm | StrOutputParser()
    precision_score = float(chain.invoke({
        "query": state['query'],
        "context": state['context']
    }))
    state['precision_score'] = precision_score
    #print("precision_score:", precision_score)
    state['precision_loop_count'] += 1
    #print("#########Precision Incremented###########")
    return state



def refine_query(state: Dict) -> Dict:
    """
    Suggests improvements for the expanded query.

    Args:
        state (Dict): The current state of the workflow, containing the query and expanded query.

    Returns:
        Dict: The updated state with query refinement suggestions.
    """
    #print("---------refine_query---------")
    system_message = '''Your task is to refine the expanded query to improve the precision of the context retrieved based on the feedback provided.'''

    refine_query_prompt = ChatPromptTemplate.from_messages([
        ("system", system_message),
        ("user", "Original Query: {query}\nExpanded Query: {expanded_query}\n\n"
                 "What improvements can be made for a better search?")
    ])

    chain = refine_query_prompt | llm | StrOutputParser()

    # Store refinement suggestions without modifying the original expanded query
    query_feedback = f"Previous Expanded Query: {state['expanded_query']}\nSuggestions: {chain.invoke({'query': state['query'], 'expanded_query': state['expanded_query']})}"
    #print("query_feedback: ", query_feedback)
    #print(f"Groundedness loop count: {state['groundedness_loop_count']}")
    state['query_feedback'] = query_feedback
    return state


def should_continue_precision(state: Dict) -> str:
    """Decides if precision is sufficient or needs improvement."""
    #print("---------should_continue_precision---------")
    #print("precision loop count: ", state['precision_loop_count'])
    if state['precision_score']>=1:  # Threshold for precision
        return "pass"  # Complete the workflow
    else:
        if state['precision_loop_count']> state['loop_max_iter']:  # Maximum allowed loops
            return "max_iterations_reached"
        else:
            #print(f"---------Precision Score Threshold Not met. Refining Query-----------")  # Debugging
            return "refine_query"  # Refine the query



def max_iterations_reached(state: AgentState) -> AgentState:
    """Handles the case where max iterations are reached."""
    state['response'] = "We need additional information to search for relevant documents."
    return state


from langgraph.graph import END, StateGraph, START

def create_workflow() -> StateGraph:
    """Creates the updated workflow for the AI agent."""
    workflow = StateGraph(AgentState)

    # Add processing nodes
    workflow.add_node("expand_query", expand_query)         # Step 1: Expand user query.
    workflow.add_node("retrieve_context", retrieve_context)     # Step 2: Retrieve relevant documents.
    #workflow.add_node("craft_response", craft_response)       # Step 3: Generate a response based on retrieved data.
    #workflow.add_node("score_groundedness", score_groundedness)   # Step 4: Evaluate response grounding.
    #workflow.add_node("refine_response", refine_response)      # Step 5: Improve response if it's weakly grounded.
    workflow.add_node("check_precision", check_precision)      # Step 6: Evaluate response precision.
    workflow.add_node("refine_query",refine_query )         # Step 7: Improve query if response lacks precision. Complete with the function to refine the query
    workflow.add_node("max_iterations_reached", max_iterations_reached)  # Step 8: Handle max iterations.

    # Main flow edges
    workflow.add_edge(START, "expand_query")
    workflow.add_edge("expand_query", "retrieve_context")
    workflow.add_edge("retrieve_context", "check_precision")
    #workflow.add_edge("craft_response", "score_groundedness")

    # Conditional edges based on groundedness check
    #workflow.add_conditional_edges(
        #"score_groundedness",
        #should_continue_groundedness,  # Use the conditional function
        #{
            #"check_precision": "check_precision",  # If well-grounded, proceed to precision check.
            #"refine_response": "refine_response",  # If not, refine the response.
            #"max_iterations_reached": "max_iterations_reached"  # If max loops reached, exit.
        #}
    #)

    #workflow.add_edge("refine_response", "craft_response")  # Refined responses are reprocessed.

    # Conditional edges based on precision check
    workflow.add_conditional_edges(
        "check_precision",
        should_continue_precision,  # Use the conditional function
        {
            "pass": END,              # If precise, complete the workflow.
            "refine_query": "refine_query",  # If imprecise, refine the query.
            "max_iterations_reached": "max_iterations_reached"  # If max loops reached, exit.
        }
    )

    workflow.add_edge("refine_query", "expand_query")  # Refined queries go through expansion again.
    workflow.add_edge("max_iterations_reached", END)

    return workflow



#=========================== Defining the agentic rag tool ====================#
WORKFLOW_APP = create_workflow().compile()
@tool
def agentic_rag(query: str):
    """
    Runs the RAG-based agent with conversation history for context-aware responses.

    Args:
        query (str): The current user query.

    Returns:
        Dict: The retireved response.
    """
    # Initialize state with necessary parameters
    inputs = {
        "query": query,
        "expanded_query": "",
        "context": [],
        "response": "",
        "precision_score": 0,
        #"groundedness_score":0,
        #"groundedness_loop_count": 5,
        "precision_loop_count": 0,
        "feedback": "",
        "query_feedback": "",
        "loop_max_iter": 5
    }

    output = WORKFLOW_APP.invoke(inputs)

    return output['context']


#================================ Guardrails ===========================#
llama_guard_client = Groq(api_key=llama_api_key)
# Function to filter user input with Llama Guard
def filter_input_with_llama_guard(user_input, model="llama-guard-3-8b"):
    """
    Filters user input using Llama Guard to ensure it is safe.

    Parameters:
    - user_input: The input provided by the user.
    - model: The Llama Guard model to be used for filtering (default is "llama-guard-3-8b").

    Returns:
    - The filtered and safe input.
    """
    try:
        # Create a request to Llama Guard to filter the user input
        response = llama_guard_client.chat.completions.create(
            messages=[{"role": "user", "content": user_input}],
            model=model,
        )
        # Return the filtered input
        return response.choices[0].message.content.strip()
    except Exception as e:
        print(f"Error with Llama Guard: {e}")
        return None


#============================= Adding Memory to the agent using mem0 ===============================#
class HaspitBot:
    def __init__(self):
        """
        Initialize the SemanticBot class, setting up memory, the LLM client, tools, and the agent executor.
        """

        # Initialize a memory client to store and retrieve customer interactions
        #self.memory = MemoryClient(api_key=userdata.get("mem0"))
        #self.memory = MemoryClient(userdata.get(api_key="mem0_api_key"))  # Complete the code to define the memory client API key

        # Initialize the OpenAI client using the provided credentials
        self.client = ChatOpenAI(
            model_name="gpt-4o-mini",  # Specify the model to use (e.g., GPT-4 optimized version)
            api_key= os.environ["API_KEY"],  # API key for authentication
            openai_api_base = os.environ["OPENAI_API_BASE"],
            temperature=0  # Controls randomness in responses; 0 ensures deterministic results
        )

        # Define tools available to the chatbot, such as web search
        tools = [agentic_rag]

        # Define the system prompt to set the behavior of the chatbot
        system_prompt = """
                          You are a knowledgeable agent, specializing in retrieving relevant documents.
                          Guidelines for Interaction:
                          Always use the agentic_rag tool to retrieve up-to-date documents.

        """

        # Build the prompt template for the agent
        prompt = ChatPromptTemplate.from_messages([
            ("system", system_prompt),  # System instructions
            ("human", "{input}"),  # Placeholder for human input
            ("placeholder", "{agent_scratchpad}")  # Placeholder for intermediate reasoning steps
        ])

        # Create an agent capable of interacting with tools and executing tasks
        agent = create_tool_calling_agent(self.client, tools, prompt)

        # Wrap the agent in an executor to manage tool interactions and execution flow
        self.agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)


    #def store_customer_interaction(self, user_id: str, message: str, response: str, metadata: Dict = None):
        #"""
        #Store customer interaction in memory for future reference.

        #Args:
            #user_id (str): Unique identifier for the customer.
            #message (str): Customer's query or message.
            #response (str): Chatbot's response.
            #metadata (Dict, optional): Additional metadata for the interaction.
        #"""
        #if metadata is None:
            #metadata = {}

        # Add a timestamp to the metadata for tracking purposes
        #metadata["timestamp"] = datetime.now().isoformat()

        # Format the conversation for storage
        #conversation = [
            #{"role": "user", "content": message},
            #{"role": "assistant", "content": response}
        #]

        # Store the interaction in the memory client
        #self.memory.add(
            #conversation,
            #user_id=user_id,
            #output_format="v1.1",
            #metadata=metadata
        #)


    #def get_relevant_history(self, user_id: str, query: str) -> List[Dict]:
        #"""
        #Retrieve past interactions relevant to the current query.

        #Args:
            #user_id (str): Unique identifier for the customer.
            #query (str): The customer's current query.

        #Returns:
            #List[Dict]: A list of relevant past interactions.
        #"""
        #return self.memory.search(
            #query=query,  # Search for interactions related to the query
            #user_id=user_id,  # Restrict search to the specific user
            #limit=5  # Complete the code to define the limit for retrieved interactions
        #)


    def handle_customer_query(self, query: str) -> str:
        """
        Process a customer's query and provide a response, taking into account past interactions.

        Args:
            query (str): Customer's query.

        Returns:
            str: Chatbot's response.
        """

        # Retrieve relevant past interactions for context
        #relevant_history = self.get_relevant_history(user_id, query)

        # Build a context string from the relevant history
        #context = "Previous relevant interactions:\n"
        #for memory in relevant_history:
            #context += f"Customer: {memory['memory']}\n"  # Customer's past messages
            #context += f"Support: {memory['memory']}\n"  # Chatbot's past responses
            #context += "---\n"

        # Print context for debugging purposes
        #print("Context: ", context)

        # Prepare a prompt combining past context and the current query
        prompt = f"""

        Current customer query: {query}

        Retrieve relevant documents that match the customer query.
        """

        # Generate a response using the agent
        response = self.agent_executor.invoke({"input": prompt})

        # Store the current interaction for future reference
        #self.store_customer_interaction(
            #user_id=user_id,
            #message=query,
            #response=response["output"],
            #metadata={"type": "support_query"}
        #)

        # Return the chatbot's response
        return response['output']


#=====================User Interface using streamlit ===========================#
def haspit_search_streamlit():
    """
    A Streamlit-based UI for Semantic Search.
    """
    st.title("Haspit AI Search Bot")
    st.write("Ask me to search for relevant documents on Haspit.")
    #st.write("Type 'exit' to end the conversation.")

    # Initialize session state for chat history and user_id if they don't exist
    if 'chat_history' not in st.session_state:
        st.session_state.chat_history = []
    if 'user_id' not in st.session_state:
        st.session_state.user_id = None

    # Login form: Only if user is not logged in
    if st.session_state.user_id is None:
        with st.form("login_form", clear_on_submit=True):
            user_id = st.text_input("Please enter your name to begin:")
            submit_button = st.form_submit_button("Login")
            if submit_button and user_id:
                st.session_state.user_id = user_id
                st.session_state.chat_history.append({
                    "role": "assistant",
                    "content": f"Welcome, {user_id}! How can I help you with your search today?"
                })
                st.session_state.login_submitted = True  # Set flag to trigger rerun
        if st.session_state.get("login_submitted", False):
            st.session_state.pop("login_submitted")
            st.rerun()
    else:
        # Display chat history
        for message in st.session_state.chat_history:
            with st.chat_message(message["role"]):
                st.write(message["content"])

        # Chat input with custom placeholder text
        user_query = st.chat_input("Type your search here (or exit to end): ", key="chat_input")
        if user_query:
            if user_query.lower() == "exit":
                st.session_state.chat_history.append({"role": "user", "content": "exit"})
                with st.chat_message("user"):
                    st.write("exit")
                goodbye_msg = "Goodbye! Feel free to return if you want to search for content in documents on Haspit."
                st.session_state.chat_history.append({"role": "assistant", "content": goodbye_msg})
                with st.chat_message("assistant"):
                    st.write(goodbye_msg)
                st.session_state.user_id = None
                st.rerun()
                return

            st.session_state.chat_history.append({"role": "user", "content": user_query})
            with st.chat_message("user"):
                st.write(user_query)

            # Filter input using Llama Guard
            filtered_result = filter_input_with_llama_guard(user_query)
            filtered_result = filtered_result.replace("\n", " ")  # Normalize the result

            # Check if input is safe based on allowed statuses
            if filtered_result in ["safe", "unsafe S6", "unsafe S7"]:
                try:
                    if 'chatbot' not in st.session_state:
                        st.session_state.chatbot = HaspitBot()
                    response = st.session_state.chatbot.handle_customer_query(user_query)
                    st.write(response)
                    st.session_state.chat_history.append({"role": "assistant", "content": response})
                except Exception as e:
                    error_msg = f"Sorry, I encountered an error while processing your query. Please try again. Error: {str(e)}"
                    st.write(error_msg)
                    st.session_state.chat_history.append({"role": "assistant", "content": error_msg})
            else:
                inappropriate_msg = "I apologize, but I cannot process that input as it may be inappropriate. Please try again."
                st.write(inappropriate_msg)
                st.session_state.chat_history.append({"role": "assistant", "content": inappropriate_msg})

if __name__ == "__main__":
    haspit_search_streamlit()