Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+domain_index_sec.faiss filter=lfs diff=lfs merge=lfs -text

domain_index_sec.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5e2bda09d5e81a04ddefa8442ec2ed3e664aab2a570290298ca1867dde66b80
+size 528429

mydomain_agent.py

@@ -0,0 +1,650 @@
+from langchain_core.tools import tool
+from langgraph.graph import StateGraph, START, END
+# from llm_initializer import initialize_llm, generate_prompt_phi4
+from langgraph.graph import MessagesState
+from langchain_core.messages import ToolMessage, HumanMessage, SystemMessage
+from typing_extensions import Literal, TypedDict
+from IPython.display import Image, display
+from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, validator
+from typing import List, Optional, Dict, Any, TypedDict,Generic, TypeVar
+from abc import ABC
+import uuid
+import io
+import os
+import PyPDF2
+import re
+import logging
+import time
+from docx import Document as dx
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import (
+    DirectoryLoader,
+    PyPDFLoader,
+    TextLoader
+)
+import tempfile
+import faiss
+from langchain_community.docstore.in_memory import InMemoryDocstore
+from langchain_community.vectorstores import FAISS
+from langchain_core.prompts import PromptTemplate
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langchain_huggingface import HuggingFaceEmbeddings
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph, END
+from sqlalchemy import create_engine, Column, String, Integer, DateTime, ForeignKey, Text
+from sqlalchemy.dialects.sqlite import JSON as SQLiteJSON
+# from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship
+from sentence_transformers import SentenceTransformer
+from huggingface_hub import login
+from langchain_google_genai import ChatGoogleGenerativeAI
+import datetime
+from enum import Enum as PyEnum
+from sqlalchemy.orm import DeclarativeBase
+# from config import Config
+from functools import lru_cache
+from dotenv import load_dotenv
+
+load_dotenv()
+hf_token = os.getenv("hf_user_token")
+login(hf_token)
+
+T = TypeVar("T")
+# --- 1. Database Setup ---
+DATABASE_URL = "sqlite:///Db_domain_agent.db"
+engine = create_engine(DATABASE_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+class Base(DeclarativeBase):
+    pass
+
+class FeedbackScore(PyEnum):
+    POSITIVE = 1
+    NEGATIVE = -1
+
+class Telemetry(Base):
+    __tablename__ = "telemetry_table"
+    transaction_id = Column(String, primary_key=True)
+    session_id = Column(String)
+    user_question = Column(Text)
+    response = Column(Text)
+    context = Column(Text)
+    model_name = Column(String)
+    input_tokens = Column(Integer)
+    output_tokens = Column(Integer)
+    total_tokens = Column(Integer)
+    latency = Column(Integer)
+    dtcreatedon = Column(DateTime)
+    
+    feedback = relationship("Feedback", back_populates="telemetry_entry", uselist=False)
+
+class Feedback(Base):
+    __tablename__ = "feedback_table"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    telemetry_entry_id = Column(String, ForeignKey("telemetry_table.transaction_id"), nullable=False, unique=True)
+    feedback_score = Column(Integer, nullable=False)
+    feedback_text = Column(Text, nullable=True)
+    user_query = Column(Text, nullable=False)
+    llm_response = Column(Text, nullable=False)
+    timestamp = Column(DateTime, default=datetime.datetime.now)
+    
+    telemetry_entry = relationship("Telemetry", back_populates="feedback")
+
+class ConversationHistory(Base):
+    __tablename__ = "conversation_history"
+    session_id = Column(String, primary_key=True)
+    messages = Column(SQLiteJSON, nullable=False)
+    last_updated = Column(DateTime, default=datetime.datetime.now)
+
+Base.metadata.create_all(bind=engine)
+# --- 2. Initialize LLM and Embeddings ---
+gak = os.getenv("Gapi_key")
+llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash-lite",google_api_key=gak)
+# embedding_model = SentenceTransformer("ibm-granite/granite-embedding-english-r2")
+
+# my_model_name = "gemma3:1b-it-qat"
+# llm = ChatOllama(model=my_model_name)
+embedding_model = HuggingFaceEmbeddings(
+    model_name="ibm-granite/granite-embedding-english-r2",
+    model_kwargs={'device': 'cpu'},
+    encode_kwargs={'normalize_embeddings': False}
+)
+
+# --- 3. LangGraph State and Workflow ---
+class GraphState(TypedDict):
+    chat_history: List[Dict[str, Any]]
+    retrieved_documents: List[str]
+    user_question: str
+    decision:str
+    session_id: str
+    telemetry_id: Optional[str] = None
+
+class Route(BaseModel):
+    step: Literal['HR Agent','Finance Agent','Legal Compliance Agent'] = Field(
+        None, description="The next step in routing process"
+    )
+router = llm.with_structured_output(Route)
+
+# class State(TypedDict):
+#     input:str
+#     decision:str
+#     output:str
+
+chathistory = {}
+
+def retrieve_documents(state: GraphState):
+    # global vectorstore_retriever
+    # upload_documents()
+    saved_vectorstore_index = FAISS.load_local('domain_index', embedding_model,allow_dangerous_deserialization=True)
+    user_question = state["user_question"]
+    # meta_filter = {'Domain':'HR'}
+    if saved_vectorstore_index is None:
+        raise ValueError("Knowledge base not loaded.")
+    retrieved_docs = saved_vectorstore_index.as_retriever(search_type="mmr", search_kwargs={"k": 5})
+    top_docs = retrieved_docs.invoke(user_question)
+    print("Top Docs: ", top_docs)
+    retrieved_docs_content = [doc.page_content if doc.page_content else doc for doc in top_docs]
+    print("retrieved_documents List: ", retrieved_docs_content)
+    return {"retrieved_documents": retrieved_docs_content}
+
+def generate_response(user_question, retrieved_documents):
+    print("Inside generate_response--------------")
+    global llm
+    global chathistory
+    global agent_name
+    # user_question = state["user_question"]
+    # retrieved_documents = state["retrieved_documents"]
+    
+    formatted_chat_history = []
+    for msg in chathistory["chat_history"]:
+        if msg['role'] == 'user':
+            formatted_chat_history.append(HumanMessage(content=msg['content']))
+        elif msg['role'] == 'assistant':
+            formatted_chat_history.append(AIMessage(content=msg['content']))
+    
+    if not retrieved_documents:
+        response_content = "I couldn't find any relevant information in the uploaded documents for your question. Can you please rephrase or provide more context?"
+        response_obj = AIMessage(content=response_content)
+    else:
+        context = "\n\n".join(retrieved_documents)
+        template = """
+            You are a helpful AI assistant. Answer the user's question based on the provided context {context} and the conversation history {chat_history}.
+            If the answer is not in the context, state that you don't have enough information.
+            Do not make up answers. Only use the given context and chat_history.
+            Remove unwanted words like 'Response:' or 'Answer:' from answers.
+            \n\nHere is the Question:\n{user_question}
+        """
+        rag_prompt = PromptTemplate(
+            input_variables=["context", "chat_history", "user_question"],
+            template=template
+        )
+        rag_chain = rag_prompt | llm
+        time.sleep(3)
+        response_obj = rag_chain.invoke({
+            "context": [SystemMessage(content=context)],
+            "chat_history": formatted_chat_history,
+            "user_question": [HumanMessage(content=user_question)]
+        })
+    
+    telemetry_data = response_obj.model_dump()
+    input_tokens = telemetry_data.get('usage_metadata', {}).get('input_tokens', 0)
+    output_tokens = telemetry_data.get('usage_metadata', {}).get('output_tokens', 0)
+    total_tokens = telemetry_data.get('usage_metadata', {}).get('total_tokens', 0)
+    model_name = telemetry_data.get('response_metadata', {}).get('model', 'unknown')
+    total_duration = telemetry_data.get('response_metadata', {}).get('total_duration', 0)
+    
+    db = SessionLocal()
+    transaction_id = str(uuid.uuid4())
+    try:
+        telemetry_record = Telemetry(
+            transaction_id=transaction_id,
+            session_id=chathistory.get("session_id"),
+            user_question=user_question,
+            response=response_obj.content,
+            context="\n\n".join(retrieved_documents) if retrieved_documents else "No documents retrieved",
+            model_name=model_name,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=total_tokens,
+            latency=total_duration,
+            dtcreatedon=datetime.datetime.now()
+        )
+        db.add(telemetry_record)
+        
+        new_messages = chathistory["chat_history"] + [
+            {"role": "user", "content": user_question}, 
+            {"role": "assistant", "content": response_obj.content, "telemetry_id": transaction_id}
+        ]
+        
+        # --- FIX: Refactored Database Save Logic ---
+        print(f"Saving conversation for session_id: {chathistory.get('session_id')}")
+        conversation_entry = db.query(ConversationHistory).filter_by(session_id=chathistory.get("session_id")).first()
+        if conversation_entry:
+            print(f"Updating existing conversation for session_id: {chathistory.get('session_id')}")
+            conversation_entry.messages = new_messages
+            conversation_entry.last_updated = datetime.datetime.now()
+        else:
+            print(f"Creating new conversation for session_id: {chathistory.get('session_id')}")
+            new_conversation_entry = ConversationHistory(
+                session_id=chathistory.get("session_id"),
+                messages=new_messages,
+                last_updated=datetime.datetime.now()
+            )
+            db.add(new_conversation_entry)
+        
+        db.commit()
+        print(f"Successfully saved conversation for session_id: {chathistory.get('session_id')}")
+
+    except Exception as e:
+        db.rollback()
+        print(f"***CRITICAL ERROR***: Failed to save data to database. Error: {e}")
+    finally:
+        db.close()
+    
+    return {
+        "chat_history": new_messages,
+        "telemetry_id": transaction_id,
+        "agent_name": agent_name
+    }
+
+agent_name = ""
+def hr_agent(state:GraphState):
+    """Answer the user question based on Human Resource(HR)"""
+    global agent_name
+    user_question = state["user_question"]
+    retrieved_documents = state["retrieved_documents"]
+    print("HR Agent")
+    agent_name = "HR Agent"
+    result = generate_response(user_question,retrieved_documents)
+    # return {"output":result}
+    return result
+
+def finance_agent(state:GraphState):
+    """Answer the user question based on Finance and Bank"""
+    global agent_name
+    user_question = state["user_question"]
+    retrieved_documents = state["retrieved_documents"]
+    print("Finance Agent")
+    agent_name = "Finance Agent"
+    result = generate_response(user_question,retrieved_documents)
+    return result
+
+def legals_agent(state:GraphState):
+    """Answer the user question based on Legal Compliance"""
+    global agent_name
+    user_question = state["user_question"]
+    retrieved_documents = state["retrieved_documents"]
+    print("LC agent")
+    agent_name = "Legal Compliance Agent"
+    result = generate_response(user_question,retrieved_documents)
+    # return {"output":result}
+    return result
+
+def llm_call_router(state:GraphState):
+    decision = router.invoke(
+        [
+            SystemMessage(
+                content="Route the user_question to HR Agent, Finance Agent, Legal Compliance Agent based on the user's request"
+            ),
+            HumanMessage(
+                content=state['user_question']
+            ),
+        ]
+    )
+    return {"decision":decision.step}
+
+def route_decision(state:GraphState):
+    
+    if state['decision'] == 'HR Agent':
+        return "hr_agent"
+    elif state['decision'] == 'Finance Agent':
+        return "finance_agent"
+    elif state['decision'] == 'Legal Compliance Agent':
+        return "legals_agent"
+    
+router_builder = StateGraph(GraphState)
+
+router_builder.add_node("retrieve", retrieve_documents)
+router_builder.add_node("hr_agent", hr_agent)
+router_builder.add_node("finance_agent", finance_agent)
+router_builder.add_node("legals_agent", legals_agent)
+router_builder.add_node("llm_call_router", llm_call_router)
+
+# router_builder.add_node("generate", generate_response)
+# router_builder.set_entry_point("retrieve")
+# router_builder.add_edge("retrieve", "generate")
+# router_builder.add_edge("generate", END)
+# compiled_app = workflow.compile(checkpointer=memory)
+
+
+router_builder.add_edge(START, "llm_call_router")
+router_builder.add_conditional_edges(
+    "llm_call_router",
+    route_decision,
+    {
+        "hr_agent":"hr_agent",
+        "finance_agent":"finance_agent",
+        "legals_agent":"legals_agent",
+    },
+)
+router_builder.set_entry_point("retrieve")
+router_builder.add_edge("retrieve","llm_call_router")
+router_builder.add_edge("hr_agent",END)
+router_builder.add_edge("finance_agent",END)
+router_builder.add_edge("legals_agent",END)
+
+route_workflow = router_builder.compile()
+
+# state = route_workflow.invoke({'input': "Write a poem about a wicked cat"})
+# print(state['output'])
+
+
+
+vectorstore_retriever = None
+compiled_app = None
+memory = MemorySaver()
+
+# --- 4. LangGraph Nodes ---
+# def load_documents(state:GraphState):
+#     global selected_domain
+
+
+
+
+
+
+
+# --- 5. API Models ---
+class ChatHistoryEntry(BaseModel):
+    role: str
+    content: str
+    telemetry_id: Optional[str] = None
+
+class ChatRequest(BaseModel):
+    user_question: str
+    session_id: str
+    chat_history: Optional[List[ChatHistoryEntry]] = Field(default_factory=list)
+
+    @validator('user_question')
+    def validate_prompt(cls, v):
+        v = v.strip()
+        if not v:
+            raise ValueError('Question cannot be empty')
+        return v
+
+class ChatResponse(BaseModel):
+    ai_response: str
+    updated_chat_history: List[ChatHistoryEntry]
+    telemetry_entry_id: str
+    is_restricted: bool = False
+    moderation_reason: Optional[str] = None
+
+class FeedbackRequest(BaseModel):
+    session_id: str
+    telemetry_entry_id: str
+    feedback_score: int
+    feedback_text: Optional[str] = None
+
+class ConversationSummary(BaseModel):
+    session_id: str
+    title: str
+
+
+@lru_cache(maxsize=5)
+def process_text(file):
+    string_data = (file.read()).decode("utf-8")
+    return string_data
+    
+@lru_cache(maxsize=5)
+def process_pdf(file):
+    pdf_bytes = io.BytesIO(file.read())
+    reader = PyPDF2.PdfReader(pdf_bytes)
+    pdf_text = "".join([page.extract_text() + "\n" for page in reader.pages])
+    return pdf_text
+    
+@lru_cache(maxsize=5)
+def process_docx(file):
+    docx_bytes = io.BytesIO(file.read())
+    docx_docs = dx(docx_bytes)
+    docx_content = "\n".join([para.text for para in docx_docs.paragraphs])
+    return docx_content
+    
+
+# @app.post("/upload-documents")
+# def upload_documents(files):
+def upload_documents():
+    global vectorstore_retriever
+    # saved_vectorstore_index = FAISS.load_local('domain_index', embedding_model,allow_dangerous_deserialization=True)
+    try:
+        saved_vectorstore_index = faiss.read_index("domain_index_sec.faiss")
+        if saved_vectorstore_index:
+            vectorstore_retriever = saved_vectorstore_index
+
+            msg = f"Successfully loaded the knowledge base."
+            return msg, True
+    except Exception as e:
+        print("unable to find index...", e)
+        print("Creating new index.....")
+        all_documents = []
+        hr_loader = PyPDFLoader("D:\Pdf_data\Developments_in_HR_management_in_QAAs.pdf").load()
+        hr_finance = PyPDFLoader("D:\Pdf_data\White Paper_QA Practice.pdf").load()
+        hr_legal = PyPDFLoader("D:\Pdf_data\Legal-Aspects-Compliances.pdf").load()
+
+        for doc in hr_loader:
+            doc.metadata['Domain'] = 'HR'
+            all_documents.append(doc)
+        for doc in hr_finance:
+            doc.metadata['Domain'] = 'Finance'
+            all_documents.append(doc)
+        for doc in hr_legal:
+            doc.metadata['Domain'] = 'Legal'
+            all_documents.append(doc)
+        # for uploaded_file in files:
+            # doc_loader = PyPDFLoader(uploaded_file)
+            # all_documents.extend(doc_loader.load())
+        
+        if not all_documents:
+            raise Exception(status_code=400, detail="No supported documents uploaded.")
+
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+        text_chunks = text_splitter.split_documents(all_documents)
+        print("text_chucks: ", text_chunks[:100])
+
+        # processed_chunks_with_ids = []
+        # for i, chunk in enumerate(text_chunks):
+        #     # Generate a unique ID for each chunk
+        #     # Option 1 (Recommended): Using UUID for global uniqueness
+        #     # chunk_id = str(uuid.uuid4())
+            
+        #     # Option 2 (Alternative): Combining source file path with chunk index
+        #     # This is good if you want IDs to be deterministic based on file/chunk.
+        #     # You might need to make the file path more robust (e.g., hash it or normalize it).
+        #     file_source = chunk.metadata.get('source', 'unknown_source')
+        #     chunk_id = f"{file_source.replace('.','_')}_chunk_{i}"
+
+        #     # Add the unique ID to the chunk's metadata
+        #     # It's good practice to keep original metadata and just add your custom ID.
+        #     chunk.metadata['doc_id'] = chunk_id
+            
+            
+        #     processed_chunks_with_ids.append(chunk)
+        # embeddings = [embedding_model.encode(doc_chunks.page_content, convert_to_numpy=True) for doc_chunks in processed_chunks_with_ids]
+        
+        print(f"Split {len(text_chunks)} chunks.")
+        print(f"Assigned unique 'doc_id' to each chunk in metadata.")
+        # dimension = 768
+        # # hnsw_m = 32
+        # # index = faiss.IndexHNSWFlat(dimension, hnsw_m, faiss.METRIC_INNER_PRODUCT)
+        # index = faiss.IndexFlatL2(dimension)
+        # vector_store = FAISS(
+        #     embedding_function=embedding_model.embed_query,
+        #     index=index,
+        #     docstore= InMemoryDocstore(),
+        #     index_to_docstore_id={}
+        # )
+        vectorstore = FAISS.from_documents(documents=text_chunks, embedding=embedding_model)
+        # vectorstore.add_documents(text_chunks, ids = [cid.metadata['doc_id'] for cid in text_chunks])
+        vectorstore.add_documents(text_chunks)
+        # vectorstore_retriever = vectorstore.as_retriever(search_kwargs={'k': 5})
+        faiss.write_index(vectorstore.index, "domain_index_sec.faiss")
+        # vectorstore.save_local("domain_index")
+        vectorstore_retriever = vectorstore
+        if vectorstore:
+            msg = f"Successfully loaded the knowledge base."
+            return msg, True
+        else:
+            msg = f"Failed to process documents."
+            return msg, False
+
+# @app.post("/chat", response_model=ChatResponse)
+def chat_with_rag(chatdata):
+    global compiled_app
+    global vectorstore_retriever
+    global chathistory
+    if vectorstore_retriever is None:
+        raise Exception(status_code=400, detail="Knowledge base not loaded. Please upload documents first.")
+    print(f"Received request: {chatdata}")
+    # moderation_result = moderator.moderate_content(request.user_question)
+    # if moderation_result["is_restricted"]:
+    #     # Get appropriate response based on restriction type
+    #     response_type = moderation_result.get("response_type", "general")
+    #     response_text = Config.RESTRICTED_RESPONSES.get(
+    #         response_type, 
+    #         Config.RESTRICTED_RESPONSES["general"]
+    #     )
+        
+    #     logger.warning(
+    #         f"Restricted query: {request.prompt[:100]}... "
+    #         f"Reason: {moderation_result['reason']}"
+    #     )
+        
+    #     return ChatResponse(
+    #         ai_response=response_text,
+    #         updated_chat_history=[],
+    #         telemetry_entry_id=request.session_id,
+    #         is_restricted=True,
+    #         moderation_reason=moderation_result["reason"],
+    #     )
+    print("✅ Question passed the RAI check.........")
+    print("Received data from UI: ", chatdata)
+    chathistory = chatdata
+    initial_state = {
+        # "chat_history": [msg.model_dump() for msg in chatdata.get('chat_history')],
+        "chat_history": [msg for msg in chatdata.get('chat_history')],
+        "retrieved_documents": [],
+        "user_question": chatdata.get('user_question'),
+        "session_id": chatdata.get('session_id')
+    }
+
+    try:
+        config = {"configurable": {"thread_id": chatdata.get('session_id')}}
+        final_state = route_workflow.invoke(initial_state, config=config)
+
+        # chathistory = final_state
+        print("chathistory inside chat_with_rag-----------------")
+        print("Final State--- : ", final_state)
+
+        ai_response_message = final_state["chat_history"][-1]["content"]
+        updated_chat_history_dicts = final_state["chat_history"]
+        agent_name = final_state.get("decision","No Agent")
+
+        response_chat = ChatResponse(
+            ai_response=ai_response_message,
+            updated_chat_history=updated_chat_history_dicts,
+            telemetry_entry_id=final_state.get("telemetry_id"),
+            is_restricted=False,
+        )
+        
+        return agent_name,response_chat.dict()
+    except Exception as e:
+        print(f"Internal Server Error: {e}")
+        raise Exception(status_code=500, detail=f"An error occurred during chat processing: {e}")
+
+
+def submit_feedback(feedbackdata):
+    db = SessionLocal()
+    try:
+        telemetry_record = db.query(Telemetry).filter(
+            Telemetry.transaction_id == feedbackdata['telemetry_entry_id'],
+            Telemetry.session_id == feedbackdata['session_id']
+        ).first()
+
+        if not telemetry_record:
+            raise Exception(status_code=404, detail="Telemetry entry not found or session ID mismatch.")
+
+        existing_feedback = db.query(Feedback).filter(
+            Feedback.telemetry_entry_id == feedbackdata['telemetry_entry_id']
+        ).first()
+
+        if existing_feedback:
+            existing_feedback.feedback_score = feedbackdata['feedback_score']
+            existing_feedback.feedback_text = feedbackdata['feedback_text']
+            existing_feedback.timestamp = datetime.datetime.now()
+        else:
+            feedback_record = Feedback(
+                telemetry_entry_id=feedbackdata['telemetry_entry_id'],
+                feedback_score=feedbackdata['feedback_score'],
+                feedback_text=feedbackdata['feedback_text'],
+                user_query=telemetry_record.user_question,
+                llm_response=telemetry_record.response,
+                timestamp=datetime.datetime.now()
+            )
+            db.add(feedback_record)
+            
+        db.commit()
+
+        return {"message": "Feedback submitted successfully."}
+
+    except Exception as e:
+        raise e
+    except Exception as e:
+        db.rollback()
+        raise Exception(status_code=500, detail=f"An error occurred: {str(e)}")
+    finally:
+        db.close()
+
+# @app.get("/conversations", response_model=List[ConversationSummary])
+def get_conversations():
+    db = SessionLocal()
+    try:
+        conversations = db.query(ConversationHistory).order_by(ConversationHistory.last_updated.desc()).all()
+        summaries = []
+        for conv in conversations:
+            for msg in conv.messages:
+                print(msg)
+            first_user_message = next((msg for msg in conv.messages if msg["role"] == "user"), None)
+            title = first_user_message.get("content") if first_user_message else "New Conversation"
+            summaries.append({"session_id":conv.session_id, "title":title[:30] + "..." if len(title) > 30 else title})
+        return summaries
+    finally:
+        db.close()
+
+# @app.get("/conversations/{session_id}", response_model=List[ChatHistoryEntry])
+def get_conversation_history(session_id: str):
+    db = SessionLocal()
+    try:
+        conversation = db.query(ConversationHistory).filter(ConversationHistory.session_id == session_id).first()
+        if not conversation:
+            raise Exception(status_code=404, detail="Conversation not found.")
+        return conversation.messages
+    finally:
+        db.close()
+
+
+
+
+# if 'selected_model' not in st.session_state:
+#     st.session_state.selected_model = ""
+# @st.dialog("Choose a domain")
+# def domain_modal():
+#     domain = st.selectbox("Select a domain",["HR","Finance","Legal"])
+#     st.session_state.selected_model = domain
+#     if st.button("submit"):
+#         st.rerun()
+
+# domain_modal()
+# print("Selected Domain: ",st.session_state['selected_model'])
+
+# llm = initialize_llm()
+

requirements.txt

@@ -1,3 +1,24 @@
-altair
-pandas
-streamlit
+transformers
+torch
+streamlit
+requests
+SQLAlchemy
+sentence-transformers
+python-docx
+requests
+PyMuPDF
+pypdf
+PyPDF2
+langgraph
+langchain-unstructured
+faiss-cpu
+huggingface-hub
+langchain
+langchain-community
+langchain-core
+langchain-huggingface
+langchain-openai
+langchain-text-splitters
+langchain-google-genai
+pandas
+python-multipart

streamlitapp.py

@@ -0,0 +1,276 @@
+import streamlit as st
+import uuid
+import hashlib
+from typing import List, Optional, Dict, Any, TypedDict,Generic, TypeVar
+from huggingface_hub import login
+import logging
+import time
+import os
+from dotenv import load_dotenv
+from mydomain_agent import upload_documents, submit_feedback, get_conversations,get_conversation_history, chat_with_rag
+
+load_dotenv()
+
+# --- 2. Streamlit UI Components and State Management ---
+st.set_page_config(page_title="Agentic WorkFlow", layout="wide")
+st.title("💬 Domain-Aware AI Agent")
+st.caption("Your expert assistant across HR, Finance, and Legal Compliance.")
+
+# Initialize session state for conversations, messages, and the current session ID
+if "conversations" not in st.session_state:
+    st.session_state.conversations = []
+if "session_id" not in st.session_state:
+    st.session_state.session_id = str(uuid.uuid4())
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+if "retriever_ready" not in st.session_state:
+    st.session_state.retriever_ready = False
+if "feedback_given" not in st.session_state:
+    st.session_state.feedback_given = {}
+# New state variable to handle negative feedback comments
+if "negative_feedback_for" not in st.session_state:
+    st.session_state.negative_feedback_for = None
+
+# Initialize session state for storing uploaded file hashes
+if 'uploaded_file_hashes' not in st.session_state:
+    st.session_state.uploaded_file_hashes = set()
+if 'uploaded_files_info' not in st.session_state:
+    st.session_state.uploaded_files_info = []
+
+def get_file_hash(file):
+    """Generates a unique hash for a file using its name, size, and content."""
+    hasher = hashlib.sha256()
+    # Read a small chunk of the file to ensure content-based uniqueness
+    # Combine with file name and size for a robust identifier
+    file_content = file.getvalue()
+    hasher.update(file.name.encode('utf-8'))
+    hasher.update(str(file.size).encode('utf-8'))
+    hasher.update(file_content[:1024])  # Use first 1KB of content
+    return hasher.hexdigest()
+# --- 3. Helper Functions for Backend Communication ---
+# def send_documents_to_backend(uploaded_files):
+#     try:
+#         for file in uploaded_files:
+#             process_status = upload_documents(file)
+#         return process_status
+#     except Exception as e:
+#         st.error(f"Error processing documents: {e}")
+#         return None
+
+def send_chat_message_to_backend(prompt: str, chat_history: List[Dict[str, Any]]):
+    """Sends a chat message to the FastAPI backend and handles the response."""
+    if not prompt.strip():
+        return {"empty":"Invalid Question"}
+    history_for_api = [
+        {"role": msg.get("role"), "content": msg.get("content")} 
+        for msg in chat_history
+    ]
+    
+    payload = {
+        "user_question": str(prompt),
+        "session_id": st.session_state.session_id,
+        "chat_history": history_for_api,
+    }
+    print(f"Sending payload: {payload}")  # Debug print
+    agent_name,response_dict = chat_with_rag(payload)
+    try:
+        return agent_name,response_dict
+    except Exception as e:
+        st.error(f"Error communicating with the backend")
+        print(f"Error communicating with the backend: {e}")
+        return None
+
+def send_feedback_to_backend(telemetry_entry_id: str, feedback_score: int, feedback_text: Optional[str] = None):
+    """Sends feedback to the FastAPI backend."""
+    payload = {
+        "session_id": st.session_state.session_id,
+        "telemetry_entry_id": telemetry_entry_id,
+        "feedback_score": feedback_score,
+        "feedback_text": feedback_text
+    }
+    try:
+        # response = requests.post(f"{API_URL}/feedback", json=payload)
+        response = submit_feedback(payload)
+        # response.raise_for_status()
+        st.toast("Feedback submitted! Thank you.")
+    except Exception as e:
+        st.error(f"Error submitting feedback: {e}")
+
+def get_conversations_from_backend() -> list:
+    """Fetches a list of all conversations from the backend."""
+    try:
+        # response = requests.get(f"{API_URL}/conversations")
+        response = get_conversations()
+        # response.raise_for_status()
+        return response
+    except Exception as e:
+        st.sidebar.error(f"Error fetching conversations: {e}")
+        return []
+
+def get_conversation_history_from_backend(session_id: str):
+    """Fetches the messages for a specific conversation ID."""
+    try:
+        # response = requests.get(f"{API_URL}/conversations/{session_id}")
+
+        response = get_conversation_history(session_id)
+        return response
+    except Exception as e:
+        st.error(f"Error loading conversation history: {e}")
+        return None
+
+def handle_positive_feedback(telemetry_id):
+    """Handles positive feedback submission."""
+    send_feedback_to_backend(telemetry_id, 1)
+    st.session_state.feedback_given[telemetry_id] = True
+
+
+def handle_negative_feedback_comment_submit(telemetry_id, comment_text):
+    """Handles the negative feedback comment submission."""
+    send_feedback_to_backend(telemetry_id, -1, comment_text)
+    st.session_state.feedback_given[telemetry_id] = True
+    st.session_state.negative_feedback_for = None
+
+
+def refresh_conversations():
+    """Refreshes the conversation list in the sidebar."""
+    st.session_state.conversations = get_conversations_from_backend()
+
+# --- 4. Sidebar for Document Upload and Conversation History ---
+with st.sidebar:
+    st.header("Load Documents")
+    if st.button("Process Documents", key="process_docs_button"):
+        newmsg, status = upload_documents()
+        if status:
+            st.session_state.retriever_ready = True
+                        # st.success(response_data.get("message", "Documents processed and knowledge base ready!"))
+            st.success(newmsg)
+            st.session_state.messages = []
+            refresh_conversations() # sql query need to be added here
+        else:
+            st.session_state.retriever_ready = False
+            st.error(newmsg)
+    else:
+        st.warning("Please Load Document.")
+
+    st.markdown("---")
+    st.header("Conversations")
+    if st.button("➕ New Chat", key="new_chat_button", use_container_width=True, type="primary"):
+        st.session_state.session_id = str(uuid.uuid4())
+        st.session_state.messages = []
+        st.session_state.feedback_given = {}
+        st.session_state.negative_feedback_for = None
+        refresh_conversations()
+        st.rerun()
+    
+    refresh_conversations()
+    
+    if st.session_state.conversations:
+        for conv in st.session_state.conversations:
+            if st.button(
+                conv["title"], 
+                key=f"conv_{conv['session_id']}",
+                use_container_width=True
+            ):
+                if st.session_state.session_id != conv["session_id"]:
+                    st.session_state.session_id = conv["session_id"]
+                    history = get_conversation_history_from_backend(conv["session_id"])
+                    if history != [] or history != None:
+                        st.session_state.messages = history
+                        st.session_state.feedback_given = {msg.get("telemetry_id"): True for msg in history if msg.get("telemetry_id")}
+                    else:
+                        st.session_state.messages = []
+                    st.session_state.negative_feedback_for = None
+                    st.rerun()
+
+# --- 5. Main Chat Interface ---
+# Display chat messages from history on app rerun
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+        
+    # Display feedback buttons for the last AI response
+    if message["role"] == "assistant" and message.get("telemetry_id") and not st.session_state.feedback_given.get(message["telemetry_id"], False):
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("👍", key=f"positive_{message['telemetry_id']}", on_click=handle_positive_feedback, args=(message['telemetry_id'],)):
+                pass
+        with col2:
+            if st.button("👎", key=f"negative_{message['telemetry_id']}"):
+                st.session_state.negative_feedback_for = message['telemetry_id']
+                st.rerun()
+        
+        # --- NEW LOGIC FOR NEGATIVE FEEDBACK COMMENT ---
+        # Only render the comment input if this is the message the user clicked thumbs down on
+        if st.session_state.negative_feedback_for == message['telemetry_id']:
+            with st.container():
+                comment = st.text_area(
+                    "Please provide some details (optional):", 
+                    key=f"feedback_text_{message['telemetry_id']}"
+                )
+                if st.button("Submit Comment", key=f"submit_feedback_button_{message['telemetry_id']}"):
+                    handle_negative_feedback_comment_submit(message['telemetry_id'], comment)
+
+# Chat input for new questions
+if st.session_state.retriever_ready:
+    if prompt := st.chat_input("Ask me anything about the uploaded documents..."):
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        with st.chat_message("assistant"):
+            with st.spinner("Thinking..."):
+                agent_name,response_data = send_chat_message_to_backend(prompt, st.session_state.messages)
+                if response_data:
+                    if response_data.get("is_restricted"):
+                        ai_response = response_data.get("ai_response", "Sorry, I couldn't generate a response.")
+                        reason = response_data.get("moderation_reason")
+                        st.markdown(ai_response)
+                        st.markdown(reason)
+                    elif response_data.get("empty"):
+                        st.markdown(response_data.get("empty"))
+                        
+                    ai_response = response_data.get("ai_response", "Sorry, I couldn't generate a response.")
+                    telemetry_id = response_data.get("telemetry_entry_id")
+
+                    st.markdown(ai_response)
+                    st.caption(agent_name)
+                    
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": ai_response,
+                        "telemetry_id": telemetry_id
+                    })
+                    
+                    refresh_conversations()
+                    
+                    if telemetry_id:
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            if st.button("👍", key=f"positive_{telemetry_id}", on_click=handle_positive_feedback, args=(telemetry_id,)):
+                                pass
+                        with col2:
+                            if st.button("👎", key=f"negative_{telemetry_id}"):
+                                st.session_state.negative_feedback_for = telemetry_id
+                                st.rerun()
+                else:
+                    st.markdown("An error occurred.")
+else:
+    st.info("Please upload and process documents to start chatting.")
+
+
+
+
+
+# import streamlit as st
+
+# if 'selected_model' not in st.session_state:
+#     st.session_state.selected_model = ""
+# @st.dialog("Choose a domain")
+# def domain_modal():
+#     domain = st.selectbox("Select a domain",["HR","Finance","Legal"])
+#     st.session_state.selected_model = domain
+#     if st.button("submit"):
+#         st.rerun()
+
+# domain_modal()
+# print("Selected Domain: ",st.session_state['selected_model'])