Update app.py

app.py

@@ -1,137 +1,121 @@
 # learning_with_fun_app.py
 
+import os
+import tempfile
 import streamlit as st
-from langchain.vectorstores import FAISS
-from langchain.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain_community.document_loaders import PyMuPDFLoader, Docx2txtLoader, UnstructuredImageLoader
+from langchain_community.embeddings import HuggingFaceEmbeddings
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.docstore.document import Document
-from langchain.document_loaders import PyPDFLoader, Docx2txtLoader, UnstructuredImageLoader
+from langchain.schema import Document
 from gtts import gTTS
-import os
-import tempfile
 import base64
-import requests
+import shutil
+
+# ----------------------------- UI SETUP --------------------------------------
+st.set_page_config(page_title="Learning with Fun", layout="wide")
+st.title("📚 Learning with Fun - Educational Q&A for Kids")
+
+# ----------------------------- USER INPUT -----------------------------------
+grade = st.selectbox("Select your Grade", ["Grade 5", "Grade 6"])
+subject = st.selectbox("Select Subject", ["Science", "Math", "English"])
+
+uploaded_files = st.file_uploader("Upload textbook files (PDF, DOCX, JPEG)", type=["pdf", "docx", "jpg", "jpeg"], accept_multiple_files=True)
+question = st.text_input("Ask your question in English or Urdu")
 
-# -------------------------------
-# 1. Load documents
-# -------------------------------
+# ------------------------- SETUP TEMP FOLDER -------------------------------
+temp_dir = tempfile.mkdtemp()
+
+# ------------------------- UTILITY FUNCTIONS -------------------------------
 def load_documents(uploaded_files):
+    """Load various file types into LangChain Document format."""
     docs = []
-    for uploaded_file in uploaded_files:
-        file_path = os.path.join(tempfile.gettempdir(), uploaded_file.name)
-        with open(file_path, "wb") as f:
-            f.write(uploaded_file.getbuffer())
-
-        if uploaded_file.name.endswith(".pdf"):
-            loader = PyPDFLoader(file_path)
-        elif uploaded_file.name.endswith(".docx"):
-            loader = Docx2txtLoader(file_path)
-        elif uploaded_file.name.endswith(('.jpg', '.jpeg', '.png')):
-            loader = UnstructuredImageLoader(file_path)
+    for file in uploaded_files:
+        ext = file.name.split(".")[-1].lower()
+        path = os.path.join(temp_dir, file.name)
+        with open(path, "wb") as f:
+            f.write(file.read())
+
+        if ext == "pdf":
+            loader = PyMuPDFLoader(path)
+        elif ext == "docx":
+            loader = Docx2txtLoader(path)
+        elif ext in ["jpg", "jpeg"]:
+            loader = UnstructuredImageLoader(path)
         else:
-            st.warning("Unsupported file format")
             continue
-
         docs.extend(loader.load())
     return docs
 
-# -------------------------------
-# 2. Chunking documents
-# -------------------------------
-def chunk_documents(docs):
+def split_documents(documents):
+    """Split documents into smaller chunks."""
     splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
-    return splitter.split_documents(docs)
-
-# -------------------------------
-# 3. Create embeddings
-# -------------------------------
-def create_embeddings():
-    return HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-
-# -------------------------------
-# 4. Create and save FAISS index
-# -------------------------------
-def create_faiss_index(chunks, embedding):
-    vectorstore = FAISS.from_documents(chunks, embedding)
-    return vectorstore
-
-# -------------------------------
-# 5. Query vectorstore and generate answers
-# -------------------------------
-def query_faiss(vectorstore, question, embedding, grade, subject):
-    relevant_docs = vectorstore.similarity_search(question, k=3)
-    context = "\n".join([doc.page_content for doc in relevant_docs])
-    return generate_answers(context, question)
-
-# -------------------------------
-# 6. Generate answer using GROQ + LLaMA 3
-# -------------------------------
-def generate_answers(context, question):
-    prompt = f"""
-    You are a helpful teacher. Use the context below to answer the question in two formats:
+    return splitter.split_documents(documents)
+
+def create_vector_store(chunks):
+    """Create FAISS vector DB from text chunks."""
+    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    return FAISS.from_documents(chunks, embeddings)
 
-    1. Beginner explanation (Urdu + English mix)
-    2. Storytelling style (Urdu-English mix with a fun tone)
+def retrieve_docs(query, vector_store):
+    """Search FAISS for relevant chunks."""
+    return vector_store.similarity_search(query, k=3)
 
+def query_llm_groq(context, query):
+    """Send query with context to GROQ LLaMA 3 model and return formatted answers."""
+    from openai import OpenAI
+    import os
+
+    client = OpenAI(api_key=os.getenv("GROQ_API_KEY"), base_url="https://api.groq.com/openai/v1")
+
+    prompt = f"""
     Context:
     {context}
 
     Question:
-    {question}
+    {query}
 
-    Answer:
+    Provide two outputs:
+    1. A simple, educational explanation in English + Urdu.
+    2. A creative storytelling version mixing English and Urdu.
     """
-    headers = {"Authorization": f"Bearer YOUR_GROQ_API_KEY"}
-    payload = {
-        "model": "llama3-8b-8192",
-        "messages": [{"role": "user", "content": prompt}],
-        "temperature": 0.7
-    }
-    response = requests.post("https://api.groq.com/openai/v1/chat/completions", headers=headers, json=payload)
-    result = response.json()
-    return result["choices"][0]["message"]["content"]
-
-# -------------------------------
-# 7. Convert storytelling to voice
-# -------------------------------
-def text_to_speech(text):
-    tts = gTTS(text=text, lang='ur')
-    file_path = os.path.join(tempfile.gettempdir(), "story.mp3")
-    tts.save(file_path)
-    return file_path
-
-# -------------------------------
-# Streamlit UI
-# -------------------------------
-def main():
-    st.set_page_config(page_title="Learning with Fun")
-    st.title("📚 Learning with Fun - Ask Questions & Hear Stories!")
-
-    grade = st.selectbox("Select Grade:", ["Grade 5", "Grade 6"])
-    subject = st.selectbox("Select Subject:", ["Science", "Math", "English"])
-
-    uploaded_files = st.file_uploader("Upload Book Files (PDF, DOCX, Images)", accept_multiple_files=True)
-
-    question = st.text_input("Ask a Question (English or Urdu):")
-
-    if st.button("Generate Answer") and uploaded_files and question:
-        with st.spinner("Processing documents and generating answer..."):
-            docs = load_documents(uploaded_files)
-            chunks = chunk_documents(docs)
-            embedding = create_embeddings()
-            vectorstore = create_faiss_index(chunks, embedding)
-            answer = query_faiss(vectorstore, question, embedding, grade, subject)
-
-            st.markdown("### 📘 Answer:")
-            parts = answer.split("2. Storytelling style")
-            st.markdown(f"**1. Explanation:**\n\n{parts[0]}")
-            if len(parts) > 1:
-                story_text = parts[1].strip()
-                st.markdown(f"**2. Storytelling Style:**\n\n{story_text}")
-
-                audio_file = text_to_speech(story_text)
-                audio_bytes = open(audio_file, 'rb').read()
-                st.audio(audio_bytes, format='audio/mp3')
-
-if __name__ == "__main__":
-    main()
+    response = client.chat.completions.create(
+        model="llama3-8b-8192",
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content
+
+def generate_audio(text, lang='ur'):
+    """Convert text to audio using gTTS and return playable audio HTML."""
+    tts = gTTS(text, lang=lang)
+    audio_path = os.path.join(temp_dir, "response.mp3")
+    tts.save(audio_path)
+    with open(audio_path, "rb") as audio_file:
+        audio_bytes = audio_file.read()
+    b64 = base64.b64encode(audio_bytes).decode()
+    audio_html = f'<audio autoplay controls><source src="data:audio/mp3;base64,{b64}" type="audio/mp3"></audio>'
+    return audio_html
+
+# ----------------------------- MAIN LOGIC ----------------------------------
+if question and uploaded_files:
+    with st.spinner("Processing your documents..."):
+        documents = load_documents(uploaded_files)
+        chunks = split_documents(documents)
+        vector_db = create_vector_store(chunks)
+
+        results = retrieve_docs(question, vector_db)
+        context_text = "\n".join([doc.page_content for doc in results])
+        answer = query_llm_groq(context_text, question)
+
+    st.markdown("### 📘 Answer")
+    parts = answer.split("2.")
+    if len(parts) == 2:
+        st.markdown(f"**Explanation:**\n{parts[0]}")
+        st.markdown(f"**Storytelling:**\n{parts[1]}")
+        st.markdown(generate_audio(parts[1]), unsafe_allow_html=True)
+    else:
+        st.markdown(answer)
+
+# ----------------------------- CLEANUP --------------------------------------
+if os.path.exists(temp_dir):
+    shutil.rmtree(temp_dir)