Upload 2 files

app (2).py

@@ -0,0 +1,87 @@
+import streamlit as st
+from typing import List, IO
+
+# Import utilities you finalised
+from utils import (
+    get_pdf_text,
+    get_docx_text,
+    get_text_chunks,
+    get_vector_store,
+    user_input,
+)
+
+# ---------------------------------------------------------------------------#
+#  Main Streamlit application
+# ---------------------------------------------------------------------------#
+def main() -> None:
+    # ----- Page configuration ------------------------------------------------
+    st.set_page_config(
+        page_title="Docosphere",
+        page_icon="📄",
+        layout="wide"
+    )
+
+    st.title("📄 Docosphere")
+    st.markdown("*Where Documents Come Alive …*")
+
+    # Two-column layout: Q&A on left, file upload on right
+    col_left, col_right = st.columns([2, 1])
+
+    # --------------------- Right column – document upload -------------------
+    with col_right:
+        st.markdown("### 📁 Document Upload")
+        uploaded_files: List[IO[bytes]] = st.file_uploader(
+            "Upload PDF or Word files",
+            accept_multiple_files=True,
+            type=["pdf", "docx"],
+            help="You can select multiple files at once."
+        )
+
+        if st.button("🚀 Process Documents"):
+            if not uploaded_files:
+                st.warning("📋 Please upload at least one file first.")
+                return
+
+            with st.spinner("🔄 Extracting text & creating vector index…"):
+                combined_text = ""
+
+                pdfs  = [f for f in uploaded_files if f.name.lower().endswith(".pdf")]
+                docs  = [f for f in uploaded_files if f.name.lower().endswith(".docx")]
+
+                if pdfs:
+                    combined_text += get_pdf_text(pdfs)
+                if docs:
+                    combined_text += get_docx_text(docs)
+
+                if combined_text.strip():
+                    chunks = get_text_chunks(combined_text)
+                    get_vector_store(chunks)
+                    st.success("✅ Documents processed! Ask away in the left panel.")
+                else:
+                    st.warning("⚠️ No readable text found in the uploaded files.")
+
+        with st.expander("ℹ️ How to use"):
+            st.markdown(
+                """
+                1. Upload one or more **PDF** or **Word** documents.\n
+                2. Click **Process Documents** to build the knowledge index.\n
+                3. Ask natural-language questions in the input box (left column).\n
+                4. The assistant will either answer from its own model knowledge or
+                   retrieve context from your documents when needed.
+                """
+            )
+
+    # ---------------------- Left column – chat interface --------------------
+    with col_left:
+        st.markdown("### 💬 Ask Your Question")
+        question: str = st.text_input(
+            "",
+            placeholder="Type a question about your documents or general topics…"
+        )
+
+        if question:
+            user_input(question)
+
+# Entry-point guard
+if __name__ == "__main__":
+    main()

utils (1).py

@@ -0,0 +1,108 @@
+import os, tempfile, streamlit as st
+from typing import List, IO, Tuple
+from dotenv import load_dotenv
+from PyPDF2 import PdfReader
+from docx import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.schema import Document as LangchainDocument
+from langchain_community.vectorstores import FAISS
+from langchain_together.chat_models import ChatTogether
+from langchain_together.embeddings import TogetherEmbeddings        # <-- NEW
+from langchain.prompts import PromptTemplate
+
+load_dotenv()
+
+# ---------- Helpers ---------------------------------------------------------
+def get_together_api_key() -> str:
+    key = os.getenv("TOGETHER_API_KEY") or st.secrets.get("TOGETHER_API_KEY", None)
+    if not key:
+        raise EnvironmentError("TOGETHER_API_KEY not found in env or Streamlit secrets.")
+    return key
+
+# ---------- File-reading utilities -----------------------------------------
+def get_pdf_text(pdf_docs: List[IO[bytes]]) -> str:
+    txt = ""
+    for pdf in pdf_docs:
+        for page in PdfReader(pdf).pages:
+            if (t := page.extract_text()):
+                txt += t + "\n"
+    return txt
+
+def get_docx_text(docx_docs: List[IO[bytes]]) -> str:
+    txt = ""
+    for d in docx_docs:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
+            tmp.write(d.getvalue()); tmp.flush()
+        try:
+            doc = Document(tmp.name)
+            txt += "\n".join(p.text for p in doc.paragraphs) + "\n"
+        finally:
+            os.unlink(tmp.name)
+    return txt
+
+def get_text_chunks(text: str) -> List[str]:
+    return RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200).split_text(text)
+
+# ---------- Vector-store build & save --------------------------------------
+def get_vector_store(text_chunks: List[str]) -> None:
+    api_key = get_together_api_key()
+    embeddings = TogetherEmbeddings(model="BAAI/bge-base-en-v1.5", api_key=api_key)
+    vector_store = FAISS.from_texts(text_chunks, embedding=embeddings)
+    vector_store.save_local("faiss_index")
+
+# ---------- QA chain helpers ----------------------------------------------
+def get_conversational_chain() -> Tuple[ChatTogether, PromptTemplate]:
+    api_key = get_together_api_key()
+    llm = ChatTogether(model="meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+                       temperature=0.3, api_key=api_key)
+    prompt = PromptTemplate(
+        template=(
+            "As a professional assistant, provide a detailed and formally written "
+            "answer to the question using the provided context.\n\nContext:\n{context}\n\n"
+            "Question:\n{question}\n\nAnswer:"
+        ),
+        input_variables=["context", "question"]
+    )
+    return llm, prompt
+
+def self_assess(question: str) -> str:
+    api_key = get_together_api_key()
+    llm = ChatTogether(model="meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+                       temperature=0.3, api_key=api_key)
+    msgs = [
+        {"role": "system", "content": "You are an expert assistant…"},
+        {"role": "user",   "content": (
+            "If you can confidently answer the following question from your own "
+            "knowledge, do so; otherwise reply with 'NEED_RETRIEVAL'.\n\n"
+            f"Question: {question}"
+        )}
+    ]
+    return llm.invoke(msgs).content.strip()
+
+def process_docs_for_query(docs: List[LangchainDocument], question: str) -> str:
+    if not docs:
+        return "Sorry, I couldn’t find relevant info in the documents."
+    ctx = "\n\n".join(d.page_content for d in docs)
+    llm, prompt = get_conversational_chain()
+    return llm.invoke(prompt.format(context=ctx, question=question)).content
+
+# ---------- Main user-query orchestrator -----------------------------------
+def user_input(user_question: str) -> None:
+    assessment = self_assess(user_question)
+    need_retrieval = assessment.upper() == "NEED_RETRIEVAL"
+    st.info("🔍 Searching documents…" if need_retrieval else "💡 Using model knowledge…")
+
+    try:
+        if need_retrieval:
+            api_key = get_together_api_key()
+            embeddings = TogetherEmbeddings(model="BAAI/bge-base-en-v1.5", api_key=api_key)
+            vs = FAISS.load_local("faiss_index", embeddings, allow_dangerous_deserialization=True)
+            docs = vs.similarity_search(user_question)
+            answer = process_docs_for_query(docs, user_question)
+        else:
+            answer = assessment
+
+        st.markdown("### Answer")
+        st.markdown(answer)
+    except Exception as e:
+        st.error(f"⚠️ Error: {e}")