initial code for front end

app.py

@@ -1,4 +1,4 @@
-from pinecone_utilis import create_pinecone_vectorstore,load_and_split_document, index_document_to_pinecone
+from backend.pinecone_utilis import create_pinecone_vectorstore,load_and_split_document, index_document_to_pinecone
 
 file_path="InternTaskGenAI.pdf"
 

langchain_utils.py → backend/langchain_utils.py

@@ -7,7 +7,7 @@ from typing import List
 from typing_extensions import List, TypedDict
 from langchain_core.documents import Document
 import os
-from pinecone_utilis import vectorstore
+from backend.pinecone_utilis import vectorstore
 from dotenv import load_dotenv
 load_dotenv()
 OPENAI_API_KEY=os.getenv("OPENAI_API_KEY")

backend/main.py

@@ -0,0 +1,161 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from backend.pydantic_models import QueryInput, QueryResponse, DocumentInfo, DeleteFileRequest, ChallengeRequest, EvaluateAnswer
+from backend.langchain_utils import generate_response, retrieve
+from backend.db_utils import insert_application_logs, get_chat_history, get_all_documents, insert_document_record, delete_document_record, get_file_content
+from backend.pinecone_utilis import index_document_to_pinecone, delete_doc_from_pinecone, load_and_split_document
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.messages import SystemMessage, AIMessage, HumanMessage
+import os
+import uuid
+import logging
+import shutil
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+
+# Set up logging
+logging.basicConfig(filename='app.log', level=logging.INFO)
+
+# Initialize FastAPI app
+app = FastAPI()
+
+@app.post("/chat", response_model=QueryResponse)
+def chat(query_input: QueryInput):
+    session_id = query_input.session_id or str(uuid.uuid4())
+    logging.info(f"Session ID: {session_id}, User Query: {query_input.question}, Model: {query_input.model.value}")
+    chat_history = get_chat_history(session_id)
+    print(chat_history)
+    state={"messages":[]} # test
+    messages_state = generate_response(query=query_input.question, state=state)
+    answer=messages_state["messages"][-1].content
+
+    insert_application_logs(session_id, query_input.question, answer, query_input.model.value)
+    logging.info(f"Session ID: {session_id}, AI Response: {answer}")
+    return QueryResponse(answer=answer, session_id=session_id, model=query_input.model)
+
+@app.post('/challenge-me', response_model=list[str])
+def challenge_me(request: ChallengeRequest):
+    file_id = request.file_id
+    
+    content = get_file_content(file_id)
+    if content is None:
+        raise HTTPException(status_code=404, detail="Document not found")
+
+    
+    llm = ChatOpenAI(
+        model='gpt-4.1',
+        api_key=OPENAI_API_KEY
+    )
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are a helpful AI assistant. Generate three logic-based or comprehension-focused questions about the following document. Each question should require understanding or reasoning about the document content, not just simple recall. Provide each question on a new line."),
+        ("human", "Document: {context}\n\nQuestions:")
+    ])
+    chain = prompt | llm | StrOutputParser()
+    questions_str = chain.invoke({"context": content})
+    questions = [q.strip() for q in questions_str.split('\n') if q.strip()][:3]
+
+    return questions
+
+
+
+@app.post('/evaluate-response')
+def evaluate_response(request: EvaluateAnswer):
+    # get the file ralated to answers
+    file_id = request.file_id
+    question = request.question
+    user_answer=request.user_answer
+
+    # evaluate the useranswer according to the research paper
+
+    llm = ChatOpenAI(
+        model='gpt-4.1',
+        api_key=OPENAI_API_KEY
+    )
+    # get the context from doc
+    retrieved_docs=retrieve(query=question)
+    docs_content = "\n\n".join(doc.page_content for doc in retrieved_docs)
+
+
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are a helpful AI assistant. Your task is to evaluate the user's answer to a question, using ONLY the information below as reference. If the answer is not correct, explain why and provide the correct answer with justification from the document. Do not make up information."),
+        ("system", "Context: {context}"),
+        ("human", "Question: {question}\nUser Answer: {user_answer}\nEvaluation:")
+    ])
+
+    chain = prompt | llm | StrOutputParser()
+    evaluation = chain.invoke({
+        "context": docs_content,
+        "question": question,
+        "user_answer": user_answer
+    })
+
+    return {
+        "feedback": evaluation,
+        "file_id": file_id
+    }
+
+
+
+@app.post("/upload-doc")
+def upload_and_index_document(file: UploadFile = File(...)):
+    allowed_extensions = ['.pdf', '.txt']
+    file_extension = os.path.splitext(file.filename)[1].lower()
+
+    if file_extension not in allowed_extensions:
+        raise HTTPException(status_code=400, detail=f"Unsupported file type. Allowed types are: {', '.join(allowed_extensions)}")
+
+    temp_file_path = f"temp_{file.filename}"
+
+    try:
+        # Save the uploaded file to a temporary file
+        with open(temp_file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        docs = load_and_split_document(temp_file_path)
+        docs_content = "\n\n".join(doc.page_content for doc in docs)
+        file_id = insert_document_record(file.filename, docs_content)
+        success = index_document_to_pinecone(temp_file_path, file_id)
+
+        if success:
+            # generate summary
+
+            llm = ChatOpenAI(
+                model='gpt-4.1',
+                api_key=OPENAI_API_KEY
+            )
+            prompt = ChatPromptTemplate.from_messages([
+                ("system", "You are a helpful assistant. Summarize the following document in no more than 150 words. Focus on the main points and key findings. Do not include information not present in the document."),
+                ("human", "{document}")
+            ])
+            chain = prompt | llm | StrOutputParser()
+            summary = chain.invoke({"document": docs_content})
+            return {
+                "message": f"File {file.filename} has been successfully uploaded and indexed.",
+                "file_id": file_id,
+                "summary": summary
+            }
+        else:
+            delete_document_record(file_id)
+            raise HTTPException(status_code=500, detail=f"Failed to index {file.filename}.")
+    finally:
+        
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+@app.get("/list-docs", response_model=list[DocumentInfo])
+def list_documents():
+    return get_all_documents()
+
+@app.post("/delete-doc")
+def delete_document(request: DeleteFileRequest):
+    pinecone_delete_success = delete_doc_from_pinecone(request.file_id)
+
+    if pinecone_delete_success:
+        db_delete_success = delete_document_record(request.file_id)
+        if db_delete_success:
+            return {"message": f"Successfully deleted document with file_id {request.file_id} from the system."}
+        else:
+            return {"error": f"Deleted from pinecone but failed to delete document with file_id {request.file_id} from the database."}
+    else:
+        return {"error": f"Failed to delete document with file_id {request.file_id} from pinecone."}

backend/utilis.py

@@ -1,57 +0,0 @@
-from langchain.document_loaders import PyPDFLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from pinecone import Pinecone, ServerlessSpec
-from langchain_core.prompts import PromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-from operator import itemgetter
-
-class RAG:
-    def load_split_file(self, file_path):
-        loader = PyPDFLoader(file_path)
-        pages = loader.load_and_split()
-        text_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=10)
-        docs = text_splitter.split_documents(pages)
-        return docs
-
-    def create_index(self, index_name, PINECONE_API_KEY):
-        pc = Pinecone(api_key=PINECONE_API_KEY)
-        if index_name in pc.list_indexes().names():
-            pc.delete_index(index_name)  # To avoid any conflicts in retrieval
-        pc.create_index(
-            name=index_name,
-            dimension=384,
-            metric='cosine',
-            spec=ServerlessSpec(
-                cloud="aws",
-                region="us-east-1"
-            )
-        )
-        return index_name
-
-    def final_response(self, index, question, model):
-        retriever = index.as_retriever()
-        parser = StrOutputParser()
-        template = """
-        You must provide an answer based strictly on the context below. 
-        The answer is highly likely to be found within the given context, so analyze it thoroughly before responding. 
-        Only if there is absolutely no relevant information, respond with "I don't know".
-        Do not make things up.
-
-        Context: {context}
-
-        Question: {question}
-        """
-        prompt = PromptTemplate.from_template(template)
-        prompt.format(context="Here is some context", question="Here is a question")
-
-        chain = (
-            {
-                "context": itemgetter("question") | retriever,
-                "question": itemgetter("question"),
-            }
-            | prompt
-            | model
-            | parser
-        )
-        matching_results = index.similarity_search(question, k=2)
-        return f"Answer: {chain.invoke({'question': question})}", matching_results

frontend/app.py

@@ -0,0 +1,160 @@
+import streamlit as st
+import requests
+import uuid
+from datetime import datetime
+
+# Backend URL configuration
+BACKEND_URL = "http://localhost:8000"  
+
+# Initialize session state
+if "session_id" not in st.session_state:
+    st.session_state.session_id = str(uuid.uuid4())
+if "current_file" not in st.session_state:
+    st.session_state.current_file = None
+if "challenge_questions" not in st.session_state:
+    st.session_state.challenge_questions = []
+if "user_answers" not in st.session_state:
+    st.session_state.user_answers = {}
+if "feedback" not in st.session_state:
+    st.session_state.feedback = {}
+
+# Page setup
+st.set_page_config(page_title="Research Assistant", layout="wide")
+st.title("📚 Smart Research Assistant")
+
+# Document management sidebar
+with st.sidebar:
+    st.header("Document Management")
+    
+    # Document upload
+    uploaded_file = st.file_uploader("Upload Document (PDF/TXT)", type=["pdf", "txt"])
+    if uploaded_file:
+        if st.button("Upload Document"):
+            response = requests.post(
+                f"{BACKEND_URL}/upload-doc",
+                files={"file": (uploaded_file.name, uploaded_file, "application/octet-stream")}
+            )
+            if response.status_code == 200:
+                data = response.json()
+                st.session_state.current_file = data["file_id"]
+                st.success(f"Document uploaded successfully! ID: {data['file_id']}")
+                with st.expander("Document Summary"):
+                    st.write(data["summary"])
+            else:
+                st.error("Failed to upload document")
+    
+    # List documents
+    st.subheader("Uploaded Documents")
+    try:
+        documents = requests.get(f"{BACKEND_URL}/list-docs").json()
+        for doc in documents:
+            doc_id = doc["id"]
+            with st.container(border=True):
+                st.write(f"**{doc['filename']}**")
+                st.caption(f"Uploaded: {datetime.fromisoformat(doc['upload_timestamp']).strftime('%Y-%m-%d %H:%M')}")
+                st.caption(f"ID: {doc_id}")
+                
+                # Document selection
+                if st.button(f"Select", key=f"select_{doc_id}"):
+                    st.session_state.current_file = doc_id
+                
+                # Document deletion
+                if st.button(f"Delete", key=f"del_{doc_id}"):
+                    del_response = requests.post(
+                        f"{BACKEND_URL}/delete-doc",
+                        json={"file_id": doc_id}
+                    )
+                    if del_response.status_code == 200:
+                        st.rerun()
+                    else:
+                        st.error("Deletion failed")
+    except:
+        st.warning("No documents available")
+
+# Main interaction tabs
+ask_tab, challenge_tab = st.tabs(["Ask Anything", "Challenge Me"])
+
+with ask_tab:
+    st.subheader("Document Q&A")
+    
+    if st.session_state.current_file:
+        # Chat interface
+        user_question = st.text_input("Ask a question about the document:")
+        
+        if user_question:
+            response = requests.post(
+                f"{BACKEND_URL}/chat",
+                json={
+                    "question": user_question,
+                    "session_id": st.session_state.session_id,
+                    "model": "gpt-4o-mini"
+                }
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                st.divider()
+                st.subheader("Answer")
+                st.write(data["answer"])
+                st.caption(f"Session ID: {data['session_id']}")
+            else:
+                st.error("Failed to get response")
+    else:
+        st.warning("Please select a document first")
+
+with challenge_tab:
+    st.subheader("Document Comprehension Challenge")
+    
+    if st.session_state.current_file:
+        # Generate questions
+        if st.button("Generate Challenge Questions"):
+            response = requests.post(
+                f"{BACKEND_URL}/challenge-me",
+                json={"file_id": st.session_state.current_file}
+            )
+            if response.status_code == 200:
+                st.session_state.challenge_questions = response.json()
+            else:
+                st.error("Failed to generate questions")
+        
+        # Display questions and answer inputs
+        if st.session_state.challenge_questions:
+            for i, question in enumerate(st.session_state.challenge_questions):
+                st.subheader(f"Question {i+1}")
+                st.write(question)
+                
+                user_answer = st.text_input(
+                    f"Your answer for question {i+1}:",
+                    key=f"answer_{i}"
+                )
+                
+                # Store answers
+                st.session_state.user_answers[i] = user_answer
+                
+                # Evaluate answer
+                if st.button(f"Evaluate Answer {i+1}", key=f"eval_{i}"):
+                    response = requests.post(
+                        f"{BACKEND_URL}/evaluate-response",
+                        json={
+                            "file_id": st.session_state.current_file,
+                            "question": question,
+                            "user_answer": user_answer
+                        }
+                    )
+                    if response.status_code == 200:
+                        feedback = response.json()
+                        st.session_state.feedback[i] = feedback
+                        st.success("Answer evaluated!")
+                    else:
+                        st.error("Evaluation failed")
+                
+                # Show feedback
+                if i in st.session_state.feedback:
+                    with st.expander(f"Feedback for Question {i+1}"):
+                        st.write(st.session_state.feedback[i]["feedback"])
+    else:
+        st.warning("Please select a document first")
+
+# Session info
+st.sidebar.divider()
+st.sidebar.caption(f"Session ID: `{st.session_state.session_id}`")

main.py

@@ -1,160 +0,0 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException
-from pydantic_models import QueryInput, QueryResponse, DocumentInfo, DeleteFileRequest, ChallengeRequest, EvaluateAnswer
-from langchain_utils import generate_response, retrieve
-from db_utils import insert_application_logs, get_chat_history, get_all_documents, insert_document_record, delete_document_record, get_file_content
-from pinecone_utilis import index_document_to_pinecone, delete_doc_from_pinecone, load_and_split_document
-from langchain_openai import ChatOpenAI
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.messages import SystemMessage, AIMessage, HumanMessage
-import os
-import uuid
-import logging
-import shutil
-
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-
-
-# Set up logging
-logging.basicConfig(filename='app.log', level=logging.INFO)
-
-# Initialize FastAPI app
-app = FastAPI()
-
-@app.post("/chat", response_model=QueryResponse)
-def chat(query_input: QueryInput):
-    session_id = query_input.session_id or str(uuid.uuid4())
-    logging.info(f"Session ID: {session_id}, User Query: {query_input.question}, Model: {query_input.model.value}")
-    chat_history = get_chat_history(session_id)
-    state={"messages":[]} # test
-    messages_state = generate_response(query=query_input.question, state=state)
-    answer=messages_state["messages"][-1].content
-
-    insert_application_logs(session_id, query_input.question, answer, query_input.model.value)
-    logging.info(f"Session ID: {session_id}, AI Response: {answer}")
-    return QueryResponse(answer=answer, session_id=session_id, model=query_input.model)
-
-@app.post('/challenge-me', response_model=list[str])
-def challenge_me(request: ChallengeRequest):
-    file_id = request.file_id
-    
-    content = get_file_content(file_id)
-    if content is None:
-        raise HTTPException(status_code=404, detail="Document not found")
-
-    
-    llm = ChatOpenAI(
-        model='gpt-4.1',
-        api_key=OPENAI_API_KEY
-    )
-    prompt = ChatPromptTemplate.from_messages([
-        ("system", "You are a helpful AI assistant. Generate three logic-based or comprehension-focused questions about the following document. Each question should require understanding or reasoning about the document content, not just simple recall. Provide each question on a new line."),
-        ("human", "Document: {context}\n\nQuestions:")
-    ])
-    chain = prompt | llm | StrOutputParser()
-    questions_str = chain.invoke({"context": content})
-    questions = [q.strip() for q in questions_str.split('\n') if q.strip()][:3]
-
-    return questions
-
-
-
-@app.post('/evaluate-response')
-def evaluate_response(request: EvaluateAnswer):
-    # get the file ralated to answers
-    file_id = request.file_id
-    question = request.question
-    user_answer=request.user_answer
-
-    # evaluate the useranswer according to the research paper
-
-    llm = ChatOpenAI(
-        model='gpt-4.1',
-        api_key=OPENAI_API_KEY
-    )
-    # get the context from doc
-    retrieved_docs=retrieve(query=question)
-    docs_content = "\n\n".join(doc.page_content for doc in retrieved_docs)
-
-
-    prompt = ChatPromptTemplate.from_messages([
-        ("system", "You are a helpful AI assistant. Your task is to evaluate the user's answer to a question, using ONLY the information below as reference. If the answer is not correct, explain why and provide the correct answer with justification from the document. Do not make up information."),
-        ("system", "Context: {context}"),
-        ("human", "Question: {question}\nUser Answer: {user_answer}\nEvaluation:")
-    ])
-
-    chain = prompt | llm | StrOutputParser()
-    evaluation = chain.invoke({
-        "context": docs_content,
-        "question": question,
-        "user_answer": user_answer
-    })
-
-    return {
-        "feedback": evaluation,
-        "file_id": file_id
-    }
-
-
-
-@app.post("/upload-doc")
-def upload_and_index_document(file: UploadFile = File(...)):
-    allowed_extensions = ['.pdf', '.txt']
-    file_extension = os.path.splitext(file.filename)[1].lower()
-
-    if file_extension not in allowed_extensions:
-        raise HTTPException(status_code=400, detail=f"Unsupported file type. Allowed types are: {', '.join(allowed_extensions)}")
-
-    temp_file_path = f"temp_{file.filename}"
-
-    try:
-        # Save the uploaded file to a temporary file
-        with open(temp_file_path, "wb") as buffer:
-            shutil.copyfileobj(file.file, buffer)
-        docs = load_and_split_document(temp_file_path)
-        docs_content = "\n\n".join(doc.page_content for doc in docs)
-        file_id = insert_document_record(file.filename, docs_content)
-        success = index_document_to_pinecone(temp_file_path, file_id)
-
-        if success:
-            # generate summary
-
-            llm = ChatOpenAI(
-                model='gpt-4.1',
-                api_key=OPENAI_API_KEY
-            )
-            prompt = ChatPromptTemplate.from_messages([
-                ("system", "You are a helpful assistant. Summarize the following document in no more than 150 words. Focus on the main points and key findings. Do not include information not present in the document."),
-                ("human", "{document}")
-            ])
-            chain = prompt | llm | StrOutputParser()
-            summary = chain.invoke({"document": docs_content})
-            return {
-                "message": f"File {file.filename} has been successfully uploaded and indexed.",
-                "file_id": file_id,
-                "summary": summary
-            }
-        else:
-            delete_document_record(file_id)
-            raise HTTPException(status_code=500, detail=f"Failed to index {file.filename}.")
-    finally:
-        
-        if os.path.exists(temp_file_path):
-            os.remove(temp_file_path)
-
-@app.get("/list-docs", response_model=list[DocumentInfo])
-def list_documents():
-    return get_all_documents()
-
-@app.post("/delete-doc")
-def delete_document(request: DeleteFileRequest):
-    pinecone_delete_success = delete_doc_from_pinecone(request.file_id)
-
-    if pinecone_delete_success:
-        db_delete_success = delete_document_record(request.file_id)
-        if db_delete_success:
-            return {"message": f"Successfully deleted document with file_id {request.file_id} from the system."}
-        else:
-            return {"error": f"Deleted from pinecone but failed to delete document with file_id {request.file_id} from the database."}
-    else:
-        return {"error": f"Failed to delete document with file_id {request.file_id} from pinecone."}

ui.py → test.py

@@ -7,8 +7,8 @@ BASE_URL = "http://localhost:8000"
 
 # with open("neural computing cwsi.pdf", "rb") as f:
 #     files = {"file": ("neural computing cwsi.pdf", f, "text/plain")}
-#     upload_response = requests.post(f"{BASE_URL}/chat", files=files)
-# print("Upload Response:", upload_response.json())
+#     upload_response = requests.post(f"{BASE_URL}/upload-doc", files=files)
+# # print("Upload Response:", upload_response.json())
 
 # file_id = upload_response.json().get("summary")