Upload 2 files

app.py

@@ -0,0 +1,292 @@
+import streamlit as st
+from langchain_community.document_loaders import PDFPlumberLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_core.vectorstores import InMemoryVectorStore
+from langchain_ollama import OllamaEmbeddings
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_ollama.llms import OllamaLLM
+from typing import List
+import os
+
+# Initialize session state
+def init_session_state():
+    if 'messages' not in st.session_state:
+        st.session_state['messages'] = []
+    if 'vector_store' not in st.session_state:
+        st.session_state['vector_store'] = None
+    if 'diet_preference' not in st.session_state:
+        st.session_state['diet_preference'] = 'All'
+    if 'meal_time' not in st.session_state:
+        st.session_state['meal_time'] = 'Any'
+
+# Constants and configurations
+PDF_STORAGE_PATH = 'Data/'
+EMBEDDING_MODEL = OllamaEmbeddings(model="llama3.1")
+LANGUAGE_MODEL = OllamaLLM(model="llama3.1")
+
+MENU_RELATED_KEYWORDS = [
+    'menu', 'food', 'dish', 'meal', 'eat', 'drink', 'recommend', 'suggestion',
+    'order', 'specialty', 'cuisine', 'appetite', 'hungry', 'restaurant',
+    'vegetarian', 'vegan', 'spicy', 'dessert', 'appetizer', 'main course',
+    'dinner', 'lunch', 'breakfast', 'serve', 'portion', 'price', 'cost'
+]
+
+MENU_ANALYSIS_PROMPT = """
+You are an expert restaurant assistant with deep knowledge of cuisine and dietary preferences. 
+Use the provided menu context to help customers make informed dining choices.
+
+Current user preferences:
+🍽️ Dietary preference: {diet_preference}
+⏰ Meal time: {meal_time}
+
+Previous conversation:
+{chat_history}
+
+Current menu context: {context}
+
+User query: {question}
+
+Please provide recommendations based on the following guidelines:
+1. Consider the user's dietary preferences (vegetarian/non-vegetarian)
+2. Focus on menu items appropriate for the selected meal time
+3. Suggest complementary dishes when appropriate
+4. Highlight special or popular items from the menu
+5. Explain key ingredients or preparation methods if relevant
+6. Consider portion sizes and meal combinations
+
+Response:
+"""
+
+CASUAL_CHAT_PROMPT = """
+You are a friendly restaurant assistant engaging in casual conversation. 
+Respond naturally to the user's message without analyzing the menu.
+
+Current user preferences:
+🍽️ Dietary preference: {diet_preference}
+⏰ Meal time: {meal_time}
+
+Previous conversation:
+{chat_history}
+
+User message: {question}
+
+Respond in a friendly, conversational manner while maintaining context of the previous discussion.
+"""
+
+# File handling functions
+def save_uploaded_files(uploaded_files) -> List[str]:
+    """Save multiple uploaded files and return their paths"""
+    file_paths = []
+    for uploaded_file in uploaded_files:
+        file_path = os.path.join(PDF_STORAGE_PATH, uploaded_file.name)
+        with open(file_path, "wb") as file:
+            file.write(uploaded_file.getbuffer())
+        file_paths.append(file_path)
+    return file_paths
+
+def load_multiple_pdfs(file_paths: List[str]):
+    """Load multiple PDF documents"""
+    documents = []
+    for file_path in file_paths:
+        document_loader = PDFPlumberLoader(file_path)
+        documents.extend(document_loader.load())
+    return documents
+
+def chunk_documents(raw_documents):
+    """Split documents into chunks"""
+    text_processor = RecursiveCharacterTextSplitter(
+        chunk_size=1000,
+        chunk_overlap=200,
+        add_start_index=True
+    )
+    return text_processor.split_documents(raw_documents)
+
+# Vector store operations
+def index_documents(document_chunks):
+    """Create vector store from document chunks"""
+    vector_store = InMemoryVectorStore(embedding=EMBEDDING_MODEL)
+    vector_store.add_documents(document_chunks)
+    st.session_state['vector_store'] = vector_store
+
+def find_related_documents(query: str):
+    """Find relevant documents for a query"""
+    if st.session_state['vector_store'] is None:
+        return []
+    return st.session_state['vector_store'].similarity_search(query)
+
+# Text processing functions
+def combine_documents(docs: list) -> str:
+    """Combine multiple documents into a single string"""
+    return "\n\n".join([doc.page_content for doc in docs])
+
+def format_chat_history(messages: List[dict]) -> str:
+    """Format chat history for prompt context"""
+    formatted_history = []
+    for msg in messages:
+        role = msg["role"]
+        content = msg["content"]
+        formatted_history.append(f"{role}: {content}")
+    return "\n".join(formatted_history[-6:])
+
+def should_analyze_menu(query: str) -> bool:
+    """Determine if the query requires menu analysis"""
+    query_lower = query.lower()
+    return any(keyword in query_lower for keyword in MENU_RELATED_KEYWORDS)
+
+# Response generation functions
+def generate_casual_response(user_query: str) -> str:
+    """Generate a casual response without menu analysis"""
+    chat_history = format_chat_history(st.session_state['messages'])
+    prompt = ChatPromptTemplate.from_template(CASUAL_CHAT_PROMPT)
+    chain = prompt | LANGUAGE_MODEL
+    
+    return chain.invoke({
+        "chat_history": chat_history,
+        "question": user_query,
+        "diet_preference": st.session_state['diet_preference'],
+        "meal_time": st.session_state['meal_time']
+    })
+
+def generate_menu_response(user_query: str, context_documents: list) -> str:
+    """Generate a response with menu analysis"""
+    chat_history = format_chat_history(st.session_state['messages'])
+    prompt = ChatPromptTemplate.from_template(MENU_ANALYSIS_PROMPT)
+    chain = prompt | LANGUAGE_MODEL
+    
+    return chain.invoke({
+        "chat_history": chat_history,
+        "context": combine_documents(context_documents),
+        "question": user_query,
+        "diet_preference": st.session_state['diet_preference'],
+        "meal_time": st.session_state['meal_time']
+    })
+
+def generate_answer(user_query: str, context_documents: list) -> str:
+    """Generate appropriate response based on query type"""
+    if should_analyze_menu(user_query):
+        return generate_menu_response(user_query, context_documents)
+    else:
+        return generate_casual_response(user_query)
+
+# Main UI function
+def main():
+    # Initialize session state
+    init_session_state()
+    
+    # UI Configuration
+    st.set_page_config(
+        page_title="Smart Menu Assistant",
+        page_icon="🍽️",
+        layout="wide"
+    )
+    
+    # Main title with emojis
+    st.title("🍽️ Smart Menu Assistant 🤖")
+    st.markdown("### 👨‍🍳 Your Personal Restaurant Guide 🌟")
+    st.markdown("---")
+    
+    # Sidebar with enhanced emojis
+    with st.sidebar:
+        st.markdown("### 🎯 Your Dining Journey")
+        
+        # Welcome message
+        st.markdown("""
+        👋 Welcome, food lover! 
+        
+        Let me help you discover 
+        the perfect dining options! 🌟
+        
+        Use these filters to create your 
+        perfect dining experience! ✨
+        """)
+        
+        # Diet preference section
+        st.markdown("#### 🥗 Dietary Preference")
+        diet_choice = st.radio(
+            "What's your food preference? 🍴",
+            ["All 🍽️", "Vegetarian 🥬", "Non-Vegetarian 🍗"],
+            help="Choose your dietary preference to get personalized recommendations",
+            key="diet_radio"
+        )
+        st.session_state['diet_preference'] = diet_choice.split()[0]  # Remove emoji from choice
+        
+        # Meal time section
+        st.markdown("#### ⏰ Meal Time")
+        meal_time = st.selectbox(
+            "When are you planning to eat? 🕐",
+            ["Any ⏰", "Breakfast 🌅", "Lunch 🌞", "Dinner 🌙"],
+            help="Select a meal time for specific menu suggestions",
+            key="meal_select"
+        )
+        st.session_state['meal_time'] = meal_time.split()[0]  # Remove emoji from choice
+        
+        # Helpful tips
+        st.markdown("---")
+        st.markdown("""
+        💡 **Pro Tips:**
+        
+        1. 📑 Upload multiple menus to compare options
+        2. 🔍 Use filters to find perfect matches
+        3. 💬 Ask specific questions about dishes
+        4. ⭐ Look for chef's recommendations
+        """)
+        
+        # Clear chat button at bottom
+        st.markdown("---")
+        if st.button("🗑️ Clear Chat History", help="Remove all previous messages"):
+            st.session_state['messages'] = []
+            st.session_state['vector_store'] = None
+            st.rerun()
+    
+    # File Upload Section with emojis
+    uploaded_pdfs = st.file_uploader(
+        "📤 Upload Restaurant Menus (PDF)",
+        type="pdf",
+        help="Select one or more restaurant menus in PDF format",
+        accept_multiple_files=True
+    )
+
+    if uploaded_pdfs:
+        try:
+            with st.spinner("🔄 Processing your menus..."):
+                saved_paths = save_uploaded_files(uploaded_pdfs)
+                raw_docs = load_multiple_pdfs(saved_paths)
+                processed_chunks = chunk_documents(raw_docs)
+                index_documents(processed_chunks)
+                st.success(f"✅ Successfully processed {len(uploaded_pdfs)} menu(s)! 🎉\n\n💭 Ask me anything about the menu!")
+        except Exception as e:
+            st.error(f"❌ Error processing menus: {str(e)}")
+
+    # Add a separator before chat
+    st.markdown("---")
+    st.markdown("### 💬 Chat with Your Menu Assistant")
+
+    # Display chat history with enhanced styling
+    for message in st.session_state['messages']:
+        with st.chat_message(message["role"], avatar="👤" if message["role"] == "user" else "👨‍🍳"):
+            st.write(message["content"])
+
+    # Chat input with emoji
+    user_input = st.chat_input("🤔 How can I assist you with the menu today?")
+
+    if user_input:
+        # Add user message to chat history
+        st.session_state['messages'].append({"role": "user", "content": user_input})
+        with st.chat_message("user", avatar="👤"):
+            st.write(user_input)
+        
+        try:
+            with st.spinner("🧠 Thinking..."):
+                # Only fetch relevant docs if menu analysis is needed
+                relevant_docs = find_related_documents(user_input) if should_analyze_menu(user_input) else []
+                ai_response = generate_answer(user_input, relevant_docs)
+                
+            # Add assistant response to chat history
+            st.session_state['messages'].append({"role": "assistant", "content": ai_response})
+            with st.chat_message("assistant", avatar="👨‍🍳"):
+                st.write(ai_response)
+        except Exception as e:
+            st.error(f"❌ Error generating response: {str(e)}")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+langchain_core
+langchain_community
+langchain_ollama
+pdfplumber
+gdown