Update app.py

app.py

@@ -283,7 +283,7 @@ PROMPTS:
         inputs = tokenizer(prompt, return_tensors="pt", truncation=True)
         outputs = model.generate(
             **inputs,
-            max_new_tokens=min(max_tokens,512),
+            max_new_tokens=512,
             temperature=0.3,
             do_sample=False,
             pad_token_id=tokenizer.eos_token_id
@@ -474,146 +474,314 @@ def gate_ui():
         if st.button("Forgot?"):
             st.info("Contact the admin to reset the APP_PASSWORD secret.")
     return False
+# ===== RETRIEVAL SETTINGS SIDEBAR =====
+def retrieval_settings():
+    st.sidebar.header("Retrieval Settings")
+    k_value = st.sidebar.slider("How many chunks to retrieve (k)", 5, 40, 20, 1)
+    min_score = st.sidebar.slider("Minimum relevance score", 0.0, 1.0, 0.0, 0.01)
+    topics_str = st.sidebar.text_input("Optional: Focus on specific topics (comma-separated)", "")
+    topic_score = st.sidebar.slider("Topic relevance score", 0.0, 1.0, 0.0, 0.01)
+
+    st.sidebar.header("Generation Settings")
+    max_tokens = st.sidebar.number_input("Max tokens in response", 100, 1500, 700, 50)
+    use_openai = st.sidebar.checkbox("Use OpenAI (Costs Tokens)", value=False)
+
+    topics = [t.strip() for t in topics_str.split(",") if t.strip()]
+    return {
+        "k": k_value,
+        "min_score": min_score,
+        "topics": topics,
+        "topic_score": topic_score,
+        "max_tokens": max_tokens,
+        "use_openai": use_openai
+    }
+def parse_topics_field(val):
+    if not val:
+        return[]
+    if isinstance(val,list):
+        return [str(t).strip() for t in val if str(t).strip()]
+    return [t.strip() for t in str(val).split(",") if t.strip()]
+def resolve_item_settings(item, defaults):
+    """
+    Merge per-item overrides with UI defaults.
+    item: dict from JSON
+    defaults: dict from sidebar (k, max_tokens, use_openai, topics, topic_score)
+    """
+    return {
+        "use_openai": bool(item.get("use_openai", defaults["use_openai"])),
+        "k": int(item.get("k", defaults["k"])),
+        "max_tokens": int(item.get("max_tokens", defaults["max_tokens"])),
+        # rerank controls:
+        "topics": parse_topics_field(item.get("topics", defaults.get("topics", []))),
+        "topic_score": float(item.get("topic_weight", defaults.get("topic_score", 0.0))),
+    }
+def run_query(query: str,
+              manual_context: str,
+              vectorstore,
+              use_openai: bool,
+              k: int = 10,
+              topic_list: list[str] | None = None,
+              topic_alpha: float = 0.2,
+              max_tokens: int = 700):
+    pre_k = max(1, k * 4)
+    docs = vectorstore.similarity_search(query=query, k=pre_k)
+
+    if topic_list and topic_alpha > 0:
+        try:
+            docs = rerank_with_topics(docs, topic_list, alpha=topic_alpha)
+        except Exception as e:
+            st.warning(f"Topic rerank skipped: {e}")
+
+    docs = docs[:k]
+
+    rag_chain = get_rag_chain(retriever=None, use_openai=use_openai, max_tokens=max_tokens)
+    combined_manual = (manual_context or "").strip()
+    out = rag_chain.invoke({"question": query, "manual_context": combined_manual, "context_docs": docs})
+
+    return {"answer": out.get("answer", ""), "tokens": out.get("tokens", {}), "docs": docs}
 
+# ===== MAIN =====
 def main():
-    if not gate_ui():
+    if not password_gate():
         return
-    # st.set_page_config(page_title="Grant Buddy RAG", page_icon="🤖")
-    st.title("🤖 Grant Buddy: Grant-Writing Assistant")
-    USE_OPENAI = st.sidebar.checkbox("Use OpenAI (Costs Tokens)", value=False)
-    st.sidebar.markdown("### Retrieval Settings")
-
-    k_value = st.sidebar.slider("How many chunks to retrieve (k)", min_value=5, max_value=40, step=5, value=10)
-    score_threshold = st.sidebar.slider("Minimum relevance score", min_value=0.0, max_value=1.0, step=0.05, value=0.75)
-    topic_input=st.sidebar.text_input("Optional: Focus on specific topics (comma-separated)")
-    topics=[t.strip() for t in topic_input.split(",") if t.strip()]
-    topic_weight= st.sidebar.slider("Topic relevance score", min_value=0.0, max_value=1.0, step=0.05, value=0.2)
-    st.sidebar.markdown("### Generation Settings")
-    max_tokens = st.sidebar.number_input("Max tokens in response", min_value=100, max_value=1500, value=700, step=50)
-
-    if "generated_queries" not in st.session_state:
-        st.session_state.generated_queries = {}
-    
-    manual_context = st.text_area("📝 Optional: Add your own context (e.g., mission, goals)", height=150)
-    
-    # # retriever = init_vector_search().as_retriever(search_kwargs={"k": k_value, "score_threshold": score_threshold})
-    retriever = init_vector_search().as_retriever()
-    vectorstore = init_vector_search()  
-
-    # pre_k = k_value*4  # Retrieve more chunks first
-    # context_docs = retriever.get_relevant_documents(query, k=pre_k)
-    # if topics:
-    #     context_docs = rerank_with_topics(context_docs, topics, alpha=topic_weight)
-    # context_docs = context_docs[:k_value]  # Final top-k used in RAG
-    rag_chain = get_rag_chain(retriever, use_openai=USE_OPENAI, max_tokens=max_tokens)
-
-    uploaded_file = st.file_uploader("Upload PDF or TXT for extra context (optional)", type=["pdf", "txt"])
-    uploaded_text = ""
-
-    if uploaded_file:
-        with st.spinner("📄 Processing uploaded file..."):
+
+    st.title("🤖 Grant Buddy — Manual / JSON Mode")
+    settings = retrieval_settings()
+
+    tab_manual, tab_batch = st.tabs(["✍️ Manual Mode", "🧩 JSON Batch Mode"])
+
+    # ---- Manual Mode ----
+    with tab_manual:
+        st.subheader("Manual Query")
+        uploaded_file = st.file_uploader("Upload PDF/TXT (optional)", type=["pdf", "txt"])
+        uploaded_text = ""
+        if uploaded_file:
             if uploaded_file.name.endswith(".pdf"):
                 reader = PdfReader(uploaded_file)
-                uploaded_text = "\n".join([page.extract_text() for page in reader.pages if page.extract_text()])
-            elif uploaded_file.name.endswith(".txt"):
+                uploaded_text = "\n".join(
+                    p.extract_text() for p in reader.pages if p.extract_text()
+                )
+            else:
                 uploaded_text = uploaded_file.read().decode("utf-8")
+        
+        query = st.text_input("Enter your question")
+        if st.button("Run Manual Query"):
+            st.write("### Retrieval Settings Used:")
+            st.json(settings)
+            st.write("Running query:", query)
+            st.write("Uploaded context length:", len(uploaded_text))
+            # 🔹 Call your retrieval + generation pipeline here
+
+    # ---- JSON Batch Mode ----
+    with tab_batch:
+        st.subheader("Batch from JSON")
+        json_file = st.file_uploader("Upload JSON config", type=["json"])
+        if json_file:
+            cfg = json.load(json_file)
+            st.json(cfg)
+    
+            if st.button("Run Batch"):
+                results = []
+                # Sidebar defaults (what you already collect)
+                defaults = {
+                    "k": settings["k"],
+                    "max_tokens": settings["max_tokens"],
+                    "use_openai": settings["use_openai"],
+                    "topics": settings["topics"],
+                    "topic_score": settings["topic_score"],
+                }
+    
+                queries = cfg.get("queries", [])
+                if not queries:
+                    st.warning("No 'queries' found in JSON.")
+                for i, item in enumerate(queries, start=1):
+                    q = (item.get("query") or "").strip()
+                    if not q:
+                        st.warning(f"Item {i} missing 'query'; skipping.")
+                        continue
+    
+                    item_settings = resolve_item_settings(item, defaults)
+    
+                    result = run_query(
+                        query=q,
+                        manual_context=manual_context,   # global context
+                        vectorstore=vectorstore,
+                        use_openai=item_settings["use_openai"],
+                        k=item_settings["k"],
+                        topic_list=item_settings["topics"],
+                        topic_alpha=item_settings["topic_score"],
+                        max_tokens=item_settings["max_tokens"],
+                    )
+    
+                    st.markdown(f"## 🧩 Query {i}")
+                    st.markdown(f"**Prompt:** {q}")
+                    st.caption(
+                        f"Settings → use_openai={item_settings['use_openai']}, "
+                        f"k={item_settings['k']}, max_tokens={item_settings['max_tokens']}, "
+                        f"topic_weight={item_settings['topic_score']}, topics={item_settings['topics']}"
+                    )
+                    st.markdown(result["answer"])
+                    if result["tokens"]:
+                        t = result["tokens"]
+                        st.caption(f"Tokens — prompt: {t.get('prompt')}, completion: {t.get('completion')}, total: {t.get('total')}")
+                    show_chunks(result["docs"])
+    
+                    results.append({
+                        "query": q,
+                        "settings": item_settings,
+                        "answer": result["answer"],
+                        "tokens": result["tokens"]
+                    })
+    
+                st.download_button(
+                    "💾 Download results JSON",
+                    data=json.dumps({"results": results}, indent=2),
+                    file_name="grantbuddy_results.json",
+                    mime="application/json"
+                )
+
+
+if __name__ == "__main__":
+    main()
+# def main():
+#     if not gate_ui():
+#         return
+#     # st.set_page_config(page_title="Grant Buddy RAG", page_icon="🤖")
+#     st.title("🤖 Grant Buddy: Grant-Writing Assistant")
+#     USE_OPENAI = st.sidebar.checkbox("Use OpenAI (Costs Tokens)", value=False)
+#     st.sidebar.markdown("### Retrieval Settings")
 
-        # extract qs and headers using llms
-        questions = extract_with_llm_local(uploaded_text, use_openai=USE_OPENAI)
-
-        # filter out irrelevant text
-        def is_meaningful_prompt(text: str) -> bool:
-            too_short = len(text.strip()) < 10
-            banned_keywords = ["phone", "email", "fax", "address", "date", "contact", "website"]
-            contains_bad_word = any(word in text.lower() for word in banned_keywords)
-            is_just_punctuation = all(c in ":.*- " for c in text.strip())
-            return not (too_short or contains_bad_word or is_just_punctuation)
-
-        filtered_questions = [q for q in questions if is_meaningful_prompt(q)]
-        with st.form("question_selection_form"):
-            st.subheader("Choose prompts to answer:")
-            selected_questions=[]
-            for i,q in enumerate(filtered_questions):
-                if st.checkbox(q, key=f"q_{i}", value=True):
-                    selected_questions.append(q)
-            submit_button = st.form_submit_button("Submit")
+#     k_value = st.sidebar.slider("How many chunks to retrieve (k)", min_value=5, max_value=40, step=5, value=10)
+#     score_threshold = st.sidebar.slider("Minimum relevance score", min_value=0.0, max_value=1.0, step=0.05, value=0.75)
+#     topic_input=st.sidebar.text_input("Optional: Focus on specific topics (comma-separated)")
+#     topics=[t.strip() for t in topic_input.split(",") if t.strip()]
+#     topic_weight= st.sidebar.slider("Topic relevance score", min_value=0.0, max_value=1.0, step=0.05, value=0.2)
+#     st.sidebar.markdown("### Generation Settings")
+#     max_tokens = st.sidebar.number_input("Max tokens in response", min_value=100, max_value=1500, value=700, step=50)
+
+#     if "generated_queries" not in st.session_state:
+#         st.session_state.generated_queries = {}
+    
+#     manual_context = st.text_area("📝 Optional: Add your own context (e.g., mission, goals)", height=150)
+    
+#     # # retriever = init_vector_search().as_retriever(search_kwargs={"k": k_value, "score_threshold": score_threshold})
+#     retriever = init_vector_search().as_retriever()
+#     vectorstore = init_vector_search()  
+
+#     # pre_k = k_value*4  # Retrieve more chunks first
+#     # context_docs = retriever.get_relevant_documents(query, k=pre_k)
+#     # if topics:
+#     #     context_docs = rerank_with_topics(context_docs, topics, alpha=topic_weight)
+#     # context_docs = context_docs[:k_value]  # Final top-k used in RAG
+#     rag_chain = get_rag_chain(retriever, use_openai=USE_OPENAI, max_tokens=max_tokens)
+
+#     uploaded_file = st.file_uploader("Upload PDF or TXT for extra context (optional)", type=["pdf", "txt"])
+#     uploaded_text = ""
+
+#     if uploaded_file:
+#         with st.spinner("📄 Processing uploaded file..."):
+#             if uploaded_file.name.endswith(".pdf"):
+#                 reader = PdfReader(uploaded_file)
+#                 uploaded_text = "\n".join([page.extract_text() for page in reader.pages if page.extract_text()])
+#             elif uploaded_file.name.endswith(".txt"):
+#                 uploaded_text = uploaded_file.read().decode("utf-8")
+
+#         # extract qs and headers using llms
+#         questions = extract_with_llm_local(uploaded_text, use_openai=USE_OPENAI)
+
+#         # filter out irrelevant text
+#         def is_meaningful_prompt(text: str) -> bool:
+#             too_short = len(text.strip()) < 10
+#             banned_keywords = ["phone", "email", "fax", "address", "date", "contact", "website"]
+#             contains_bad_word = any(word in text.lower() for word in banned_keywords)
+#             is_just_punctuation = all(c in ":.*- " for c in text.strip())
+#             return not (too_short or contains_bad_word or is_just_punctuation)
+
+#         filtered_questions = [q for q in questions if is_meaningful_prompt(q)]
+#         with st.form("question_selection_form"):
+#             st.subheader("Choose prompts to answer:")
+#             selected_questions=[]
+#             for i,q in enumerate(filtered_questions):
+#                 if st.checkbox(q, key=f"q_{i}", value=True):
+#                     selected_questions.append(q)
+#             submit_button = st.form_submit_button("Submit")
             
-        #Multi-Select Question
-        if 'submit_button' in locals() and submit_button:
-            if selected_questions:
-                with st.spinner("💡 Generating answers..."):
-                    answers = []
-                    for q in selected_questions:
-                        combined_context = "\n\n".join(filter(None, [manual_context.strip(), uploaded_text.strip()]))
-                        pre_k=k_value*4
-                        context_docs=retriever.get_relevant_documents(q, k=pre_k)
-                        if topics:
-                            context_docs=rerank_with_topics(context_docs,topics,alpha=topic_weight)
-                        context_docs=context_docs[:k_value]
-                        # full_query = f"{q}\n\nAdditional context:\n{uploaded_text}"
+#         #Multi-Select Question
+#         if 'submit_button' in locals() and submit_button:
+#             if selected_questions:
+#                 with st.spinner("💡 Generating answers..."):
+#                     answers = []
+#                     for q in selected_questions:
+#                         combined_context = "\n\n".join(filter(None, [manual_context.strip(), uploaded_text.strip()]))
+#                         pre_k=k_value*4
+#                         context_docs=retriever.get_relevant_documents(q, k=pre_k)
+#                         if topics:
+#                             context_docs=rerank_with_topics(context_docs,topics,alpha=topic_weight)
+#                         context_docs=context_docs[:k_value]
+#                         # full_query = f"{q}\n\nAdditional context:\n{uploaded_text}"
                        
-                        if q in st.session_state.generated_queries:
-                            response = st.session_state.generated_queries[q]
-                        else:
-                            response = rag_chain.invoke({
-                                "question": q,
-                                "manual_context": combined_context,
-                                "context_docs": context_docs
-                            })
-                            st.session_state.generated_queries[q] = response
-                        answers.append({"question": q, "answer": response})
-                for item in answers:
-                    st.markdown(f"### ❓ {item['question']}")
-                    st.markdown(f"💬 {item['answer']['answer']}")
-                    tokens = item['answer'].get("tokens", {})
-                    if tokens:
-                        st.markdown(f"🧮 **Token Usage:** Prompt = {tokens.get('prompt')}, "
-                        f"Completion = {tokens.get('completion')}, Total = {tokens.get('total')}")
+#                         if q in st.session_state.generated_queries:
+#                             response = st.session_state.generated_queries[q]
+#                         else:
+#                             response = rag_chain.invoke({
+#                                 "question": q,
+#                                 "manual_context": combined_context,
+#                                 "context_docs": context_docs
+#                             })
+#                             st.session_state.generated_queries[q] = response
+#                         answers.append({"question": q, "answer": response})
+#                 for item in answers:
+#                     st.markdown(f"### ❓ {item['question']}")
+#                     st.markdown(f"💬 {item['answer']['answer']}")
+#                     tokens = item['answer'].get("tokens", {})
+#                     if tokens:
+#                         st.markdown(f"🧮 **Token Usage:** Prompt = {tokens.get('prompt')}, "
+#                         f"Completion = {tokens.get('completion')}, Total = {tokens.get('total')}")
                     
-            else:
-                st.info("No prompts selected for answering.")
+#             else:
+#                 st.info("No prompts selected for answering.")
 
             
-    # ✍️ Manual single-question input
-    query = st.text_input("Ask a grant-related question")
-    if st.button("Submit"):
-        if not query:
-            st.warning("Please enter a question.")
-            return
-
-        # full_query = f"{query}\n\nAdditional context:\n{uploaded_text}" if uploaded_text else query
-        pre_k = k_value * 4
-        context_docs=retriever.get_relevant_documents(query, k=pre_k)
-        if topics:
-            context_docs=rerank_with_topics(context_docs, topics, alpha=topic_weight)
-        context_docs = context_docs[:k_value]
-        combined_context = "\n\n".join(filter(None, [manual_context.strip(), uploaded_text.strip()]))
-        with st.spinner("🤖 Thinking..."):
-            # response = rag_chain.invoke(full_query)
-            response = rag_chain.invoke({"question":query,"manual_context": combined_context, "context_docs": context_docs})
-            st.text_area("Grant Buddy says:", value=response["answer"], height=250, disabled=True)
-            tokens=response.get("tokens",{})
-            if tokens:
-                 st.markdown(f"🧮 **Token Usage:** Prompt = {tokens.get('prompt')}, "
-                 f"Completion = {tokens.get('completion')}, Total = {tokens.get('total')}")
+#     # ✍️ Manual single-question input
+#     query = st.text_input("Ask a grant-related question")
+#     if st.button("Submit"):
+#         if not query:
+#             st.warning("Please enter a question.")
+#             return
+
+#         # full_query = f"{query}\n\nAdditional context:\n{uploaded_text}" if uploaded_text else query
+#         pre_k = k_value * 4
+#         context_docs=retriever.get_relevant_documents(query, k=pre_k)
+#         if topics:
+#             context_docs=rerank_with_topics(context_docs, topics, alpha=topic_weight)
+#         context_docs = context_docs[:k_value]
+#         combined_context = "\n\n".join(filter(None, [manual_context.strip(), uploaded_text.strip()]))
+#         with st.spinner("🤖 Thinking..."):
+#             # response = rag_chain.invoke(full_query)
+#             response = rag_chain.invoke({"question":query,"manual_context": combined_context, "context_docs": context_docs})
+#             st.text_area("Grant Buddy says:", value=response["answer"], height=250, disabled=True)
+#             tokens=response.get("tokens",{})
+#             if tokens:
+#                  st.markdown(f"🧮 **Token Usage:** Prompt = {tokens.get('prompt')}, "
+#                  f"Completion = {tokens.get('completion')}, Total = {tokens.get('total')}")
                 
-        with st.expander("🔍 Retrieved Chunks"):
-            # context_docs = retriever.get_relevant_documents(query)
-            for doc in context_docs:
-                # st.json(doc.metadata)
-                st.markdown(f"**Chunk ID:** {doc.metadata.get('chunk_id', 'unknown')} | **Title:** {doc.metadata['metadata'].get('title', 'unknown')}")
-                st.markdown(doc.page_content[:700] + "...")
-                if topics:
-                    matched_topics=set(doc.metadata['metadata'].get('topics',[])).intersection(topics)
-                    st.markdown(f"**Matched Topics** {','.join(matched_topics)}")
-                st.markdown("---")
+#         with st.expander("🔍 Retrieved Chunks"):
+#             # context_docs = retriever.get_relevant_documents(query)
+#             for doc in context_docs:
+#                 # st.json(doc.metadata)
+#                 st.markdown(f"**Chunk ID:** {doc.metadata.get('chunk_id', 'unknown')} | **Title:** {doc.metadata['metadata'].get('title', 'unknown')}")
+#                 st.markdown(doc.page_content[:700] + "...")
+#                 if topics:
+#                     matched_topics=set(doc.metadata['metadata'].get('topics',[])).intersection(topics)
+#                     st.markdown(f"**Matched Topics** {','.join(matched_topics)}")
+#                 st.markdown("---")
 
 
 
 
 
-if __name__ == "__main__":
-    main()
+# if __name__ == "__main__":
+#     main()