Upload 9 files

.env

@@ -0,0 +1,9 @@
+AWS_ACCESS_KEY_ID="AKIAZC2PGOX2MMJQNJ5H"
+AWS_SECRET_ACCESS_KEY="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"
+AWS_BUCKET_NAME="youdata-akshansh"
+MONGO_URI="mongodb+srv://eagle-dev:[email protected]/"
+DB_NAME="MoSPI"
+COLLECTION_NAME="files"
+COMPANY_COLLECTION_NAME="about_company"
+FLASH_API="AIzaSyANNRKfEb-YnVIBaSAq6hQ38XpxxGwvaws"
+

app.py

@@ -0,0 +1,67 @@
+import streamlit as st
+from upload_main import upload_main_page
+from upload_image_page import upload
+from view_images import view_images
+from search_page import search
+from upload_pdf_page import upload_pdf
+from view_pdf import view_pdfs
+st.set_page_config(layout='wide',page_title="MoSPI", page_icon="📄")
+
+if "page" not in st.session_state:
+    st.session_state.page = "home"
+
+if st.session_state.page == "home":
+    # Title and Header
+    st.title("Welcome to AI Assistant! Your Intelligent Search Partner.",)
+
+    # Message paragraph
+    st.write("""
+    We bring you AI-innovated smart search, which supports multilingual and voice search to streamline your searches.
+    """)
+
+    st.subheader("Key Features")
+    st.markdown("""
+    - **Semantic search** across PDFs, images, and official documents.
+    - **Quick, relevant responses** with document page highlights.
+    - **Multilingual and voice-based search** capabilities.
+    - **Integration with company’s data systems** for high relevance.
+    """)
+
+    st.markdown("<hr>", unsafe_allow_html=True)
+    # Buttons for Search and Upload
+    col1, col2 = st.columns([1,7])
+
+    with col1:
+        if st.button("Search",help="Smart Search"):
+            st.session_state.page = "search"
+            st.rerun()
+
+    with col2:
+        if st.button("Upload PDF/Images",help="Upload PDFs and Images"):
+            st.session_state.page = "upload_main"
+            st.rerun()
+
+
+elif st.session_state.page == "upload_main":
+    upload_main_page()
+
+
+elif st.session_state.page == "upload_image":
+    upload()  # Render the image upload function
+
+elif st.session_state.page=="view_image":
+    view_images()
+
+elif st.session_state.page=="search":
+    search()
+
+
+elif st.session_state.page=="upload_pdf":
+    upload_pdf()
+
+elif st.session_state.page=="view_pdf":
+    view_pdfs()
+
+
+
+

search_page.py

@@ -0,0 +1,534 @@
+from datetime import datetime
+from pymongo import MongoClient
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.prompts import ChatPromptTemplate
+import re
+import json
+import streamlit as st
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+import os
+import pinecone
+from dotenv import load_dotenv
+from bson import ObjectId
+import google.generativeai as genai
+
+load_dotenv()
+MONGO_URI = os.getenv("MONGO_URI")
+DB_NAME = os.getenv("DB_NAME")
+COLLECTION_NAME = os.getenv("COLLECTION_NAME")
+FLASH_API = os.getenv("FLASH_API")
+mongo_client = MongoClient(MONGO_URI)
+db = mongo_client[DB_NAME]
+collection = db[COLLECTION_NAME]
+collection2=db['about_company']
+genai.configure(api_key=FLASH_API)
+
+embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001", google_api_key=FLASH_API)
+model = ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0, max_tokens=None, google_api_key=FLASH_API)
+model2 = genai.GenerativeModel('models/gemini-1.5-flash')
+pc = pinecone.Pinecone(
+    api_key="4a80f293-ae6d-489a-a7d8-33ea3fcdd26b"  # Your Pinecone API key
+)
+index_name = "mospi"
+index = pc.Index(index_name)
+
+temp_audio_folder = "temp-audio"
+os.makedirs(temp_audio_folder, exist_ok=True)
+
+about_company_doc=collection2.find_one({"type":"about_company"})
+if about_company_doc:
+    about_company=about_company_doc.get('company_description','')
+def process_user_query(user_query, about_company=""):
+    try:
+        # No f-string here, so we avoid additional formatting complications
+        prompt_template = ChatPromptTemplate.from_template("""
+Given is a user query. Your task is to first translate the user query from any other language to English if not already in English.
+Then you have to reformulate that translated query such that it is contextually rich and consistent.Do not add too much extra information in the query.
+Also extract important keywords from this query. Return the result in the format given below.
+
+Expected output format:
+{{'query':'String',
+'keywords':['String']
+}}
+Given below is the user query which is related to a company about which is given below, but this company information is just to understand what the query might be related to, until explicitly asked you do not need to include company information in query:
+"About Company": {about_company}
+"Query":
+{user_query}
+""")
+
+        # Chain the prompt with LLM for response generation
+        chain = prompt_template | model
+        result = chain.invoke({
+            "about_company": about_company,
+            "user_query": user_query
+        })
+        print(f"Model response for reformulated query is {result.content}")
+
+        # Use non-greedy regex and handle multiline content
+        match = re.search(r"\{[\s\S]*?\}", result.content.strip())
+        if match:
+            json_data = match.group(0)  # Extract JSON-like content as a string
+            json_data = json_data.replace("'", '"')
+            data = json.loads(json_data)
+            enhanced_query = data.get('query', '')
+            keywords = data.get('keywords', [])
+            return enhanced_query, keywords
+        else:
+            print("No JSON data found in the model response.")
+            return None, None
+
+    except Exception as e:
+        print(f"Error occurred while processing query using LLM: {e}")
+        return None, None
+
+
+
+
+def filter_chunks_by_keywords_images(chunks, keywords):
+    keywords_set = set(kw.strip().lower() for kw in keywords)
+    chunks_with_keyword_counts = []
+
+    for chunk in chunks:
+        chunk_text = chunk['metadata'].get('description', '').lower()
+        keyword_count = sum(1 for kw in keywords_set if kw in chunk_text)
+        chunks_with_keyword_counts.append({
+            'chunk': chunk,
+            'keyword_count': keyword_count
+        })
+
+    # Sort chunks based on keyword count and similarity score
+    sorted_chunks = sorted(
+        chunks_with_keyword_counts,
+        key=lambda x: (x['keyword_count'], x['chunk']['score']),
+        reverse=True
+    )
+
+    # Filter chunks that have at least one keyword match
+    chunks_with_keywords = [item for item in sorted_chunks if item['keyword_count'] > 0]
+
+    if len(chunks_with_keywords) >= 3:
+        # If 3 or more chunks have keyword matches, return the top 3 of those
+        return chunks_with_keywords[:3]
+    elif len(chunks_with_keywords) > 0:
+        # If fewer than 3 chunks have keyword matches, return all that have matches
+        return chunks_with_keywords
+    else:
+        # If no chunks have keyword matches, return the top 3 by similarity score alone
+        sorted_by_similarity = sorted(
+            chunks_with_keyword_counts,
+            key=lambda x: x['chunk']['score'],
+            reverse=True
+        )
+        return sorted_by_similarity[:3]
+
+def filter_chunks_by_keywords_pdf(chunks, keywords):
+    keywords_set = set(kw.strip().lower() for kw in keywords)
+    pdf_chunk_map = {}
+
+    # Step 1: Calculate keyword count and similarity for each chunk, grouped by PDF URL
+    for chunk in chunks:
+        chunk_text = chunk['metadata'].get('description', '').lower()
+        pdf_url = chunk['metadata'].get('url')  # Unique identifier for each PDF
+        keyword_count = sum(1 for kw in keywords_set if kw in chunk_text)
+
+        # Structure each chunk with its metadata and computed values
+        chunk_data = {
+            'chunk': chunk,
+            'keyword_count': keyword_count,
+            'similarity_score': chunk['score']
+        }
+
+        # Group chunks by PDF URL, keeping only the most relevant chunk per PDF
+        if pdf_url not in pdf_chunk_map:
+            pdf_chunk_map[pdf_url] = chunk_data
+        else:
+            existing_chunk = pdf_chunk_map[pdf_url]
+            # Keep the chunk with higher relevance (more keywords or higher similarity)
+            if (chunk_data['keyword_count'], chunk_data['similarity_score']) > (existing_chunk['keyword_count'], existing_chunk['similarity_score']):
+                pdf_chunk_map[pdf_url] = chunk_data
+
+    # Step 2: Collect the top chunk from each PDF, sort by keyword count and similarity score
+    sorted_chunks = sorted(
+        pdf_chunk_map.values(),
+        key=lambda x: (x['keyword_count'], x['similarity_score']),
+        reverse=True
+    )
+
+    # Step 3: Select the top 3 chunks from different PDFs
+    top_chunks = sorted_chunks[:3] if len(sorted_chunks) >= 3 else sorted_chunks
+
+    return top_chunks
+
+
+def get_images_from_chunks(chunks):
+    images = []
+    for item in chunks:
+        chunk = item['chunk']
+        mongo_id_str = chunk['metadata'].get('mongo_id')
+        if mongo_id_str:
+
+            mongo_id = ObjectId(mongo_id_str)
+            image = collection.find_one({"_id": mongo_id})
+            if image:
+                images.append({
+                    'image': image,
+                    'similarity_score': chunk['score']
+                })
+    return images
+
+def get_pdfs_from_chunks(chunks):
+    pdfs = []
+    for item in chunks:
+        chunk = item['chunk']
+        mongo_id_str = chunk['metadata'].get('mongo_id')
+        page_number=chunk['metadata'].get('page_number')
+        if mongo_id_str:
+
+            mongo_id = ObjectId(mongo_id_str)
+            pdf = collection.find_one({"_id": mongo_id})
+            if pdf:
+                pdfs.append({
+                    'pdf': pdf,
+                    'similarity_score': chunk['score'],
+                    'page_number':page_number
+
+                })
+    return pdfs
+
+
+def format_date(timestamp):
+    """Convert timestamp to a readable date format."""
+    return datetime.fromtimestamp(timestamp).strftime("%B %d, %Y")
+
+# def display_images(images):
+#     images = sorted(images, key=lambda x: x['similarity_score'], reverse=True)
+#     num_images = len(images)
+#     if num_images == 0:
+#         st.write("No images to display.")
+#         return
+#
+#     # Iterate over the images in steps of 3 to create rows
+#     st.write("Here are the matching images for your query")
+#     for start_idx in range(0, num_images, 3):
+#         # Determine the number of columns for this row (could be less than 3 in the last row)
+#         num_cols = min(3, num_images - start_idx)
+#         cols = st.columns(num_cols)
+#
+#         # Display images in the current row
+#         for idx in range(num_cols):
+#             img_info = images[start_idx + idx]
+#             col = cols[idx]
+#             with col:
+#                 image_data = img_info['image']
+#                 similarity_score = img_info['similarity_score']
+#
+#                 # Display the image using object_url directly with consistent sizing
+#                 st.markdown(
+#                     f"""
+#                     <div style='text-align: center;'>
+#                         <img src='{image_data['object_url']}' alt='Image' style='width:250px; height:250px; object-fit: cover; border-radius: 8px;' />
+#                         <p><strong>Similarity Score:</strong> {similarity_score:.4f}</p>
+#                     </div>
+#                     """,
+#                     unsafe_allow_html=True
+#                 )
+#
+#                 # Expander for image details
+#                 with st.expander("View Image Details"):
+#                     st.write(f"**File Name:** {image_data.get('name', 'N/A')}")
+#                     st.write(f"**Date Uploaded:** {format_date(image_data.get('upload_date', datetime.now().timestamp()))}")
+#                     st.write(f"**Description:** {image_data.get('description', 'No description available')}")
+#
+#                     # Display tags if available
+#                     tags = ", ".join(image_data.get("tags", []))
+#                     st.write(f"**Tags:** {tags if tags else 'No tags'}")
+#
+#                     # Display categories if available
+#                     categories = ", ".join(image_data.get("categories", []))
+#                     st.write(f"**Categories:** {categories if categories else 'No categories'}")
+#
+#                     # Download link
+#                     st.markdown(
+#                         f"<a href='{image_data['object_url']}' class='download-link' download>Download Image</a>",
+#                         unsafe_allow_html=True
+#                     )
+
+def display_results(images, pdfs):
+    # Display Images Section
+    images = sorted(images, key=lambda x: x['similarity_score'], reverse=True)
+    num_images = len(images)
+
+    if num_images > 0:
+        st.write("### Here are the matching images for your query")
+        for start_idx in range(0, num_images, 3):
+            num_cols = min(3, num_images - start_idx)
+            cols = st.columns(num_cols)
+
+            # Display images in the current row
+            for idx in range(num_cols):
+                img_info = images[start_idx + idx]
+                col = cols[idx]
+                with col:
+                    image_data = img_info['image']
+                    similarity_score = img_info['similarity_score']
+
+                    st.markdown(
+                        f"""
+                        <div style='text-align: center;'>
+                            <img src='{image_data['object_url']}' alt='Image' style='width:250px; height:250px; object-fit: cover; border-radius: 8px;' />
+                            <p><strong>Similarity Score:</strong> {similarity_score:.4f}</p>
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+
+                    with st.expander("View Image Details"):
+                        st.write(f"**File Name:** {image_data.get('name', 'N/A')}")
+                        st.write(
+                            f"**Date Uploaded:** {format_date(image_data.get('upload_date', datetime.now().timestamp()))}")
+                        st.write(f"**Description:** {image_data.get('description', 'No description available')}")
+
+                        tags = ", ".join(image_data.get("tags", []))
+                        st.write(f"**Tags:** {tags if tags else 'No tags'}")
+
+                        categories = ", ".join(image_data.get("categories", []))
+                        st.write(f"**Categories:** {categories if categories else 'No categories'}")
+
+                        st.markdown(
+                            f"<a href='{image_data['object_url']}' class='download-link' download>Download Image</a>",
+                            unsafe_allow_html=True
+                        )
+    else:
+        st.write("No images to display.")
+
+    # Display PDFs Section in rows of three columns
+    pdfs = sorted(pdfs, key=lambda x: x['similarity_score'], reverse=True)
+    num_pdfs = len(pdfs)
+
+    if num_pdfs > 0:
+        st.write("### Here are the matching PDFs for your query")
+
+        for start_idx in range(0, num_pdfs, 3):
+            num_cols = min(3, num_pdfs - start_idx)
+            cols = st.columns(num_cols)
+
+            for idx in range(num_cols):
+                pdf_info = pdfs[start_idx + idx]
+                col = cols[idx]
+                with col:
+                    pdf_data = pdf_info['pdf']
+                    similarity_score = pdf_info['similarity_score']
+
+
+                    # Expander for each PDF in a column
+                    with st.expander(f"{pdf_data.get('name', 'PDF Document')}"):
+                        st.write(f"**File Name:** {pdf_data.get('name', 'N/A')}")
+                        st.write(f"**Page Number:** {int(pdf_info['page_number'])}")
+                        st.write(
+                            f"**Date Uploaded:** {format_date(pdf_data.get('upload_date', datetime.now().timestamp()))}")
+                        tags = ", ".join(pdf_data.get("tags", []))
+                        st.write(f"**Tags:** {tags if tags else 'No tags'}")
+
+                        categories = ", ".join(pdf_data.get("categories", []))
+                        st.write(f"**Categories:** {categories if categories else 'No categories'}")
+
+                        st.markdown(
+                            f"<a href='{pdf_data['object_url']}' class='download-link' download>Download PDF</a>",
+                            unsafe_allow_html=True
+                        )
+
+                    st.markdown(
+                        f"""<div style='text-align: center;'>
+                             <p><strong>Similarity Score:</strong> {similarity_score:.4f}</p></div>""",
+                        unsafe_allow_html=True
+                    )
+    else:
+        st.write("No PDFs to display.")
+
+
+def upload_audio_google(audio_path):
+    try:
+        audio_file = genai.upload_file(path=audio_path, display_name="Query Audio")
+        print(f"Uploaded file '{audio_file.display_name}' as: {audio_file.uri}")
+        return audio_file
+
+    except Exception as e:
+        print(f"error occured while uploading audio to google : {e}")
+        return None
+
+def extract_query_from_audio(audio_file):
+
+    try:
+
+        prompt=f""" Given is a user query related to a company in form of audio, your task is to understand the user query and convert it to text. If the audio is not in english then transalte it to english textual query. Make sure the generated query is consistent and contextual.Also extract important keywords from the query.
+        For the context I am providing with company information {about_company}
+        Expected output format : {{
+        "query":"String",
+        "keywords":["String"]
+        }}
+        
+         """
+        response = model2.generate_content(
+            [prompt, audio_file]
+        )
+
+        if response:
+            print(response.text)
+            match = re.search(r"\{[\s\S]*?\}", response.text)
+            if match:
+                json_data = match.group(0)  # Extract JSON-like content as a string
+                json_data = json_data.replace("'", '"')
+                data = json.loads(json_data)
+                enhanced_query = data.get('query', '')
+                keywords = data.get('keywords', [])
+                return enhanced_query, keywords
+
+            else:
+                print("No JSON data found in the model response.")
+                return None,None
+
+    except Exception as e:
+        print(f"error occured in extracting query from audio {e}")
+        return None,None
+
+
+
+
+def search_pinecone(k,filetype,query_embedding):
+    search_results = index.query(
+        vector=query_embedding,
+        top_k=k,
+        include_metadata=True,
+        filter={"tag": filetype}
+    )
+
+    return search_results
+
+
+def search():
+    if st.button("Back",key="back_button"):
+        st.session_state.page="home"
+        st.rerun()
+
+
+    st.title("AI Inspired Smart Search Engine")
+    st.subheader("Multilingual text search 🖊️")
+    user_query = st.text_input("Enter your search query:")
+
+    if user_query and st.button("submit query",key="submit_query"):
+        with st.spinner("Processing your query, please wait"):
+
+            enhanced_query,keywords=process_user_query(user_query,about_company)
+
+            if enhanced_query and keywords:
+                query_embedding = embeddings.embed_query(enhanced_query)
+                search_results_image = search_pinecone(5,"Image",query_embedding)
+                search_result_pdfs = search_pinecone(20, "PDF", query_embedding)
+
+                matches_pdf = search_result_pdfs['matches']
+                matches_image = search_results_image['matches']
+                images=[]
+                pdfs=[]
+                if not matches_image and not matches_pdf:
+                    print(f"No matching PDFs and Images found for your query")
+                    st.write(f"No matching PDFs and Images found for your query")
+                else:
+                    if matches_image:
+                        top_chunks_images = filter_chunks_by_keywords_images(matches_image, keywords)
+
+                        if top_chunks_images:
+                            # Step 5: Retrieve images from MongoDB
+                            images = get_images_from_chunks(top_chunks_images)
+
+                    if matches_pdf:
+                        top_chunks_pdf=filter_chunks_by_keywords_pdf(matches_pdf,keywords)
+                        if top_chunks_pdf:
+                            pdfs=get_pdfs_from_chunks(top_chunks_pdf)
+
+
+                    display_results(images,pdfs)
+
+
+
+
+            else:
+                st.error(f"Sorry could not process your request, please try again later!")
+
+    st.markdown("<hr>", unsafe_allow_html=True)
+
+    st.subheader("Multilingual Audio Search 🗣️")
+    audio_value = st.audio_input("Record your query")
+    if audio_value and st.button("Submit Audio",key="audio-button"):
+        with st.spinner("Processing your query, please wait"):
+            timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+            audio_file_path = os.path.join(temp_audio_folder, f"audio_query_{timestamp}.wav")
+
+            # Save the audio input to the file
+            with open(audio_file_path, "wb") as f:
+                f.write(audio_value.getvalue())
+
+            print(f"Audio saved to {audio_file_path}")
+
+            audio_file=upload_audio_google(audio_file_path)
+            if audio_file:
+                audio_query,audio_keywords=extract_query_from_audio(audio_file)
+
+                if audio_query and audio_keywords:
+                    query_embedding = embeddings.embed_query(audio_query)
+                    search_results_image = search_pinecone(5, "Image", query_embedding)
+                    search_result_pdfs = search_pinecone(20, "PDF", query_embedding)
+
+                    matches_pdf = search_result_pdfs['matches']
+                    matches_image = search_results_image['matches']
+                    images = []
+                    pdfs = []
+                    if not matches_image and not matches_pdf:
+                        print(f"No matching PDFs and Images found for your query")
+                        st.write(f"No matching PDFs and Images found for your query")
+                    else:
+                        if matches_image:
+                            top_chunks_images = filter_chunks_by_keywords_images(matches_image, audio_keywords)
+
+                            if not top_chunks_images:
+                                st.write("No chunks matched the keywords.")
+                            else:
+                                # Step 5: Retrieve images from MongoDB
+                                images = get_images_from_chunks(top_chunks_images)
+
+                        if matches_pdf:
+                            top_chunks_pdf = filter_chunks_by_keywords_pdf(matches_pdf, audio_keywords)
+                            if top_chunks_pdf:
+                                pdfs = get_pdfs_from_chunks(top_chunks_pdf)
+
+                        display_results(images,pdfs)
+
+                else:
+                    st.error(f"Sorry could not process your request, please try again later!")
+
+                #deleting the audio file from google
+                try:
+                    genai.delete_file(audio_file.name)
+                    print(f"deleted audio file from google storage")
+                except Exception as e:
+                    print(f"failed to delete audio file from google storage")
+                #delete files inside temp directory
+                for filename in os.listdir(temp_audio_folder):
+                    file_path = os.path.join(temp_audio_folder, filename)
+                    try:
+                        if os.path.isfile(file_path) or os.path.islink(file_path):
+                            os.unlink(file_path)  # Remove the file
+                            print(f"Deleted file: {file_path}")
+                    except Exception as e:
+                        print(f"Failed to delete {file_path}. Reason: {e}")
+
+
+
+
+
+
+
+
+
+
+
+

upload_image_page.py

@@ -0,0 +1,88 @@
+import streamlit as st
+from pymongo import MongoClient
+import os
+from dotenv import load_dotenv
+from helper.upload_file_to_s3 import upload_file
+from helper.process_image import process_image_using_llm
+from helper.create_embeddings import create_embedding
+import time
+
+# Load environment variables
+load_dotenv()
+AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
+AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
+AWS_BUCKET_NAME = os.getenv("AWS_BUCKET_NAME")
+MONGO_URI = os.getenv("MONGO_URI")
+DB_NAME = os.getenv("DB_NAME")
+COLLECTION_NAME = os.getenv("COLLECTION_NAME")
+COLLECTION_NAME2=os.getenv("COMPANY_COLLECTION_NAME")
+
+mongo_client = MongoClient(MONGO_URI)
+db = mongo_client[DB_NAME]
+collection = db[COLLECTION_NAME]
+collection2=db[COLLECTION_NAME2]
+
+def upload():
+    if st.button("Back"):
+        st.session_state.page = "upload_main"
+        st.rerun()
+
+    # File uploader (image files only)
+    uploaded_image = st.file_uploader("Choose an image file to upload", type=["png", "jpg", "jpeg"],
+                                      accept_multiple_files=False)
+
+    # Fetch tags and categories from MongoDB
+    tags_doc = collection2.find_one({"type": "tags"})
+    categories_doc = collection2.find_one({"type": "categories"})
+
+    tags_options = tags_doc["tags"] if tags_doc and "tags" in tags_doc else []
+    categories_options = categories_doc["categories"] if categories_doc and "categories" in categories_doc else []
+
+    # Multi-select dropdowns for tags and categories
+    selected_tags = st.multiselect("Select Tags", options=tags_options)
+    selected_categories = st.multiselect("Select Categories", options=categories_options)
+
+    if uploaded_image and selected_tags and selected_categories:
+        flag=False
+        if st.button("Submit"):
+
+            with st.spinner(text="Uploading and Processing Image"):
+                # Upload file to S3
+                metadata = upload_file(uploaded_image,"Image")
+                if metadata:
+                    object_url = metadata.get("object_url")
+                    filename = metadata.get("name")
+
+                    # Process image with LLM for description
+                    llm_processed = process_image_using_llm(object_url)
+                    if llm_processed:
+                        # Create embedding with tags and categories in metadata
+                        embedding_created = create_embedding(
+                            object_url,
+                            selected_tags,
+                            selected_categories
+                        )
+                        if embedding_created:
+                            # Save tags and categories to MongoDB document for the uploaded image
+                            collection.update_one(
+                                {"object_url": object_url},
+                                {"$set": {
+                                    "tags": selected_tags,
+                                    "categories": selected_categories
+                                }}
+                            )
+                            st.success("Image has been successfully uploaded and processed.")
+                            flag=True
+                        else:
+                            st.error("Could not create embedding. Please try again.")
+                    else:
+                        st.error("Could not process the image description. Please try again.")
+                else:
+                    st.error("Could not upload the image. Please try again.")
+
+
+            if flag:
+                st.write("Redirecting to View Page to view all uploaded images")
+                time.sleep(2)
+                st.session_state.page = "view_image"
+                st.rerun()

upload_main.py

@@ -0,0 +1,180 @@
+import streamlit as st
+from pymongo import MongoClient
+import os
+from dotenv import load_dotenv
+load_dotenv()
+import time
+
+AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
+AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
+AWS_BUCKET_NAME = os.getenv("AWS_BUCKET_NAME")
+MONGO_URI = os.getenv("MONGO_URI")
+DB_NAME = os.getenv("DB_NAME")
+COLLECTION_NAME = os.getenv("COMPANY_COLLECTION_NAME")
+
+mongo_client = MongoClient(MONGO_URI)
+db = mongo_client[DB_NAME]
+collection = db[COLLECTION_NAME]
+
+
+
+def upload_main_page():
+    #
+    if st.button("Back",key="Back_button"):
+        st.session_state.page = "home"
+        st.rerun()
+
+    st.markdown("---")
+    col1, col2 = st.columns([1,6])
+    with col1:
+        if st.button("Upload Image",key="upload_image_button"):
+            st.session_state.page="upload_image"
+            st.rerun()
+
+              # Placeholder for image upload function
+    with col2:
+        if st.button("View Images",key="view_image_button"):
+            st.session_state.page = "view_image"
+            st.rerun()
+
+    # Row 2: Buttons for PDF actions
+    col3, col4 = st.columns([1,6])
+    with col3:
+        if st.button("Upload PDF",key="upload_pdf_button"):
+            st.session_state.page="upload_pdf"
+            st.rerun()
+    with col4:
+        if st.button("View PDFs",key="view_pdf_button"):
+              st.session_state.page="view_pdf"
+              st.rerun()
+
+    # Line break
+    st.markdown("---")
+
+    # Section for company description
+    st.subheader("Tell us about your company in a few lines")
+
+    # Fetch the "about_company" document from MongoDB
+    about_company_doc = collection.find_one({"type": "about_company"})
+
+    if about_company_doc and "company_description" in about_company_doc:
+        # If company_description exists, show it and allow for updates
+        st.write("### Current Description")
+        st.write(about_company_doc["company_description"])  # Display current description (non-editable)
+
+        # Show an empty text box for new input
+        new_description = st.text_area("Enter new description to update", "")
+        if st.button("Update",key="update_company"):
+            # Update the company description in MongoDB
+            collection.update_one(
+                {"_id": about_company_doc["_id"]},
+                {"$set": {"company_description": new_description}}
+            )
+            st.success("Company description updated successfully.")
+            time.sleep(3)
+            st.rerun()
+    else:
+        # If company_description does not exist, show an empty text box for initial input
+        new_description = st.text_area("Enter company description", "")
+        if st.button("Save",key="save_description"):
+            # Insert a new company description field in MongoDB
+            if about_company_doc:
+                # Update the existing document
+                collection.update_one(
+                    {"_id": about_company_doc["_id"]},
+                    {"$set": {"company_description": new_description}}
+                )
+            else:
+                # Insert a new document if it doesn't exist
+                collection.insert_one({"type": "about_company", "company_description": new_description})
+            st.success("Company description saved successfully.")
+
+    st.markdown("---")
+
+    # Section for adding and displaying tags
+    st.subheader("Manage Tags and Categories")
+
+    # Part 1: Tags
+    st.write("#### Add Tags")
+
+    # Fetch tags document
+    tags_doc = collection.find_one({"type": "tags"})
+    current_tags = tags_doc["tags"] if tags_doc and "tags" in tags_doc else []
+
+    # Display current tags with horizontal alignment and black-blue text color
+    if current_tags:
+        st.write("Current Tags:")
+        tag_html = " ".join([
+            f"<span style='display: inline-block; padding: 5px 10px; margin: 5px; border-radius: 15px; background-color: #e0e0e0; color: #0000FF;'>{tag}</span>"
+            for tag in current_tags
+        ])
+        st.markdown(tag_html, unsafe_allow_html=True)
+    else:
+        st.write("No tags available.")
+
+    # Input box to add new tags
+    new_tags = st.text_input("Enter new tags separated by commas", "")
+    if st.button("Add Tags",key="add_tags"):
+        # Split the input tags by commas, strip whitespace, and remove any duplicates
+        tags_to_add = list(set([tag.strip() for tag in new_tags.split(",") if tag.strip()]))
+
+        # Update the MongoDB document with new tags
+        if tags_doc:
+            # Update the existing tags document
+            collection.update_one(
+                {"_id": tags_doc["_id"]},
+                {"$addToSet": {"tags": {"$each": tags_to_add}}}
+            )
+        else:
+            # Insert a new tags document if it doesn't exist
+            collection.insert_one({"type": "tags", "tags": tags_to_add})
+
+        st.success("Tags added successfully.")
+        st.rerun()  # Refresh the page to display updated tags
+
+    # Part 2: Categories
+    st.write("#### Add Categories")
+
+    # Fetch categories document
+    categories_doc = collection.find_one({"type": "categories"})
+    current_categories = categories_doc["categories"] if categories_doc and "categories" in categories_doc else []
+
+    # Display current categories with horizontal alignment and black-blue text color
+    if current_categories:
+        st.write("Current Categories:")
+        category_html = " ".join([
+            f"<span style='display: inline-block; padding: 5px 10px; margin: 5px; border-radius: 15px; background-color: #e0e0e0; color: #0000FF;'>{category}</span>"
+            for category in current_categories
+        ])
+        st.markdown(category_html, unsafe_allow_html=True)
+    else:
+        st.write("No categories available.")
+
+    # Input box to add new categories
+    new_categories = st.text_input("Enter new categories separated by commas", "")
+    if st.button("Add Categories",key="add_categories"):
+        # Split the input categories by commas, strip whitespace, and remove any duplicates
+        categories_to_add = list(set([category.strip() for category in new_categories.split(",") if category.strip()]))
+
+        # Update the MongoDB document with new categories
+        if categories_doc:
+            # Update the existing categories document
+            collection.update_one(
+                {"_id": categories_doc["_id"]},
+                {"$addToSet": {"categories": {"$each": categories_to_add}}}
+            )
+        else:
+            # Insert a new categories document if it doesn't exist
+            collection.insert_one({"type": "categories", "categories": categories_to_add})
+
+        st.success("Categories added successfully.")
+        st.rerun()  # Refresh the page to display updated categories
+
+
+
+
+
+
+
+
+

upload_pdf_page.py

@@ -0,0 +1,85 @@
+import streamlit as st
+from pymongo import MongoClient
+import os
+from dotenv import load_dotenv
+from helper.upload_file_to_s3 import upload_file
+from helper.process_pdf import process_pdf
+import time
+
+# Load environment variables
+load_dotenv()
+AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
+AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
+AWS_BUCKET_NAME = os.getenv("AWS_BUCKET_NAME")
+MONGO_URI = os.getenv("MONGO_URI")
+DB_NAME = os.getenv("DB_NAME")
+COLLECTION_NAME = os.getenv("COLLECTION_NAME")
+COLLECTION_NAME2=os.getenv("COMPANY_COLLECTION_NAME")
+
+mongo_client = MongoClient(MONGO_URI)
+db = mongo_client[DB_NAME]
+collection = db[COLLECTION_NAME]
+collection2=db[COLLECTION_NAME2]
+
+def upload_pdf():
+    if st.button("Back"):
+        st.session_state.page = "upload_main"
+        st.rerun()
+
+    # File uploader (image files only)
+    uploaded_pdf = st.file_uploader("Choose a PDF file to upload", type=["pdf"],
+                                      accept_multiple_files=False)
+
+    # Fetch tags and categories from MongoDB
+    tags_doc = collection2.find_one({"type": "tags"})
+    categories_doc = collection2.find_one({"type": "categories"})
+
+    tags_options = tags_doc["tags"] if tags_doc and "tags" in tags_doc else []
+    categories_options = categories_doc["categories"] if categories_doc and "categories" in categories_doc else []
+
+    # Multi-select dropdowns for tags and categories
+    selected_tags = st.multiselect("Select Tags", options=tags_options)
+    selected_categories = st.multiselect("Select Categories", options=categories_options)
+
+    if uploaded_pdf and selected_tags and selected_categories:
+        flag=False
+        if st.button("Submit"):
+
+            with st.spinner(text="Uploading and Processing Image"):
+                # Upload file to S3
+                metadata = upload_file(uploaded_pdf,"PDF")
+                if metadata:
+                    object_url = metadata.get("object_url")
+                    filename = metadata.get("name")
+
+                    # Process image with LLM for description
+                    pdf_processed = process_pdf(object_url,selected_tags,selected_categories)
+                    if pdf_processed:
+                        collection.update_one(
+                            {"object_url": object_url},
+                            {"$set": {
+                                "tags": selected_tags,
+                                "categories": selected_categories,
+                                "status": "processed"
+                            }}
+                        )
+                        st.success("PDF has been successfully uploaded and processed.")
+                        flag = True
+                    else:
+                        st.error("Could Not Process the PDF. Please try again.")
+                        collection.update_one(
+                            {"object_url": object_url},
+                            {"$set": {
+                                "tags": selected_tags,
+                                "categories": selected_categories,
+                                "status": "failed"
+                            }}
+                        )
+
+
+            if flag:
+                st.write("Redirecting to View Page to view all uploaded pdfs")
+                time.sleep(2)
+                st.session_state.page = "view_pdf"
+                st.rerun()
+

view_images.py

@@ -0,0 +1,84 @@
+import streamlit as st
+from pymongo import MongoClient
+import os
+from dotenv import load_dotenv
+from datetime import datetime
+
+# Load environment variables
+load_dotenv()
+MONGO_URI = os.getenv("MONGO_URI")
+DB_NAME = os.getenv("DB_NAME")
+COLLECTION_NAME = os.getenv("COLLECTION_NAME")
+
+mongo_client = MongoClient(MONGO_URI)
+db = mongo_client[DB_NAME]
+collection = db[COLLECTION_NAME]
+
+def format_date(timestamp):
+    """Convert timestamp to a readable date format."""
+    return datetime.fromtimestamp(timestamp).strftime("%B %d, %Y")
+
+# Custom CSS to control image and expander container width and styling
+
+
+def view_images():
+    if st.button("Back"):
+        st.session_state.page = "upload_main"
+        st.rerun()
+    st.title("Your Uploaded Images")
+
+    # Fetch all uploaded images from MongoDB
+    images = list(collection.find({"type": "Image"}))
+
+    if not images:
+        st.write("You have not uploaded any images yet.")
+        return
+
+    # Display images in a grid (4 images per row)
+    cols = st.columns(4)
+    for idx, image in enumerate(images):
+        col = cols[idx % 4]
+
+        with col:
+            # Container for each image and its expander
+            st.markdown("<div class='image-wrapper'>", unsafe_allow_html=True)
+
+            # Display the image using HTML
+
+            st.markdown(
+                f"""
+                                <div style='text-align: center;'>
+                                    <img src='{image['object_url']}' alt='{image.get('name','Image')}' style='width:250px; height:250px; object-fit: cover; border-radius: 8px;' />
+                                    
+                                </div>
+                                """,
+                unsafe_allow_html=True
+            )
+
+            st.markdown("</div>", unsafe_allow_html=True)  # Close image container
+
+            # Expander for image details
+            with st.expander("View Image Details"):
+                st.write(f"**File Name:** {image.get('name', 'N/A')}")
+                st.write(f"**Date Uploaded:** {format_date(image.get('upload_date', datetime.now().timestamp()))}")
+                st.write(f"**Description:** {image.get('description', 'No description available')}")
+
+                # Display tags if available
+                tags = ", ".join(image.get("tags", []))
+                st.write(f"**Tags:** {tags if tags else 'No tags'}")
+
+                # Display categories if available
+                categories = ", ".join(image.get("categories", []))
+                st.write(f"**Categories:** {categories if categories else 'No categories'}")
+
+                # Download link
+                st.markdown(
+                    f"<a href='{image['object_url']}' class='download-link' download>Download Image</a>",
+                    unsafe_allow_html=True
+                )
+
+        # Move to a new row after every 4 images
+        if (idx + 1) % 4 == 0:
+            st.write("")  # Line break to move to the next row
+
+

view_pdf.py

@@ -0,0 +1,70 @@
+import streamlit as st
+from pymongo import MongoClient
+import os
+from dotenv import load_dotenv
+from datetime import datetime
+
+# Load environment variables
+load_dotenv()
+MONGO_URI = os.getenv("MONGO_URI")
+DB_NAME = os.getenv("DB_NAME")
+COLLECTION_NAME = os.getenv("COLLECTION_NAME")
+
+mongo_client = MongoClient(MONGO_URI)
+db = mongo_client[DB_NAME]
+collection = db[COLLECTION_NAME]
+
+
+def format_date(timestamp):
+    """Convert timestamp to a readable date format."""
+    return datetime.fromtimestamp(timestamp).strftime("%B %d, %Y")
+
+
+# Custom CSS to control image and expander container width and styling
+
+
+def view_pdfs():
+    if st.button("Back"):
+        st.session_state.page = "upload_main"
+        st.rerun()
+    st.title("Your Uploaded PDFs")
+
+    # Fetch all uploaded images from MongoDB
+    pdfs = list(collection.find({"type": "PDF"}))
+
+    if not pdfs:
+        st.write("You have not uploaded any PDFs yet.")
+        return
+
+    # Display images in a grid (4 images per row)
+    cols = st.columns(4)
+    for idx, pdf in enumerate(pdfs):
+        col = cols[idx % 4]
+
+        with col:
+
+            # Expander for image details
+            filename=pdf.get('name','N/A')
+            with st.expander(f"{filename}"):
+                st.write(f"**File Name:** {pdf.get('name', 'N/A')}")
+                st.write(f"**Date Uploaded:** {format_date(pdf.get('upload_date', datetime.now().timestamp()))}")
+
+                # Display tags if available
+                tags = ", ".join(pdf.get("tags", []))
+                st.write(f"**Tags:** {tags if tags else 'No tags'}")
+
+                # Display categories if available
+                categories = ", ".join(pdf.get("categories", []))
+                st.write(f"**Categories:** {categories if categories else 'No categories'}")
+
+                # Download link
+                st.markdown(
+                    f"<a href='{pdf['object_url']}' class='download-link' download>Download PDF</a>",
+                    unsafe_allow_html=True
+                )
+
+        # Move to a new row after every 4 images
+        if (idx + 1) % 4 == 0:
+            st.write("")  # Line break to move to the next row
+
+