Update app.py

app.py

@@ -1,153 +1,400 @@
+# import os
+# from dotenv import load_dotenv
+# load_dotenv()
+
+# from langchain_astradb import AstraDBVectorStore
+# from langchain_google_genai import GoogleGenerativeAIEmbeddings
+# from langchain.prompts import PromptTemplate
+# from langchain.chains import ConversationalRetrievalChain
+# from langchain_google_genai import ChatGoogleGenerativeAI
+# import streamlit as st
+# import time
+# import textwrap
+
+# # embeddings 
+# embeddings = GoogleGenerativeAIEmbeddings(
+#     model = "models/embedding-001",
+#     task_type = "retrieval_document"
+# )
+
+# # llm 
+# llm = ChatGoogleGenerativeAI(
+#     # model = "gemini-1.5-pro",
+#     model = "Gemini 2.0 Flash", 
+#     temperature = 0.7,
+# )
+
+# # Get Info about the Database 
+# vstore = AstraDBVectorStore(
+#     collection_name = "Bhagavad_gita_data",
+#     embedding = embeddings,
+#     token = os.getenv("ASTRA_DB_APPLICATION_TOKEN"),
+#     api_endpoint = os.getenv("ASTRA_DB_API_ENDPOINT"),
+# )
+
+# # Now Retrieve the Documents from Server
+# retriever = vstore.as_retriever(search_kwargs = {"k" : 5})
+
+# prompt_template = """
+# You are a wise counselor drawing from ancient Indian wisdom to offer psychological guidance. Your role is to provide practical, concise advice for modern challenges. 
+# You are going to be used for a psychiatrist assitance who gives advices on the context of bhagvad gita.
+# Follow these guidelines:
+
+# 1. Begin with a brief, relatable insight from timeless teachings.
+
+# 2. Offer 4 to 6 specific, actionable points of advice.
+
+# 3. Each point should start on a new line and be clear and concise.
+
+# 4. Connect each piece of advice to universal principles of success and well-being.
+
+# 5. Use metaphors or examples from ancient texts without explicitly naming them.
+
+# 6. Conclude with an encouraging statement that motivates the user to apply the advice.
+
+# 7. Avoid religious terminology. Use phrases like "ancient wisdom" or "timeless teachings" instead.
+
+# 8. Ensure your response is practical, universally applicable, and inspirational.
+
+# 9. Be strict that if some gives some wrong or useless input which is not relevant to physcological issue or dilema then reply them to enter the proper question
+
+# 10. If possible try to give only Bhagavad Gita Verse related to it at end don't get any other verse from any other book and give verse Translation and number only as many don't know to read sanskrit. 
+
+# 11. If you don't know the verse from Bhagavad Gita just search through the context and then give Answer in Hindi.
+
+# Context: {context}
+# Question: {question}
+# Human: {human_input}
+# Chat History: {chat_history}
+# """
+
+
+# PROMPT = PromptTemplate(
+#     template = prompt_template,
+#     input_variables = ["context", "question", "human_input", "chat_history"]
+# )
+
+# qa_chain = ConversationalRetrievalChain.from_llm(
+#     llm,
+#     retriever = retriever,
+#     combine_docs_chain_kwargs = {"prompt": PROMPT},
+#     return_source_documents = False,
+# )
+
+# # format the output in good format
+# def format_and_wrap_text(text, wrap_length=100):
+#     # Split the text into main points
+#     main_points = text.split('**')
+
+#     formatted_text = ""
+#     for i in range(1, len(main_points), 2):
+#         # Add the main point title
+#         formatted_text += f"{main_points[i]}\n"
+
+#         # Split the subpoints by '* '
+#         subpoints = main_points[i+1].strip().split('* ')
+#         for subpoint in subpoints:
+#             if subpoint.strip():
+#                 # Wrap each subpoint and add a bullet
+#                 wrapped_subpoint = textwrap.fill(subpoint, wrap_length)
+#                 formatted_text += f"{wrapped_subpoint}\n"
+
+#         formatted_text += "\n"
+
+#     print(formatted_text)
+
+# # Streamlit App Design 
+# st.set_page_config(page_title="Arjun AI")
+
+# # app 
+# st.title("Arjun AI")
+# st.write("Get Yourself Help from Krishna's Teaching of Bhagavad Gita")
+
+# # Initialize chat history
+# if "messages" not in st.session_state:
+#     st.session_state.messages = []
+
+# # Display chat messages from history on app rerun
+# for message in st.session_state.messages:
+#     with st.chat_message(message["role"]):
+#         st.markdown(message["content"])
+
+# # React to user input
+# if prompt := st.chat_input("What is your question?"):
+#     # Display user message in chat message container
+#     st.chat_message("user").markdown(prompt)
+#     # Add user message to chat history
+#     st.session_state.messages.append({"role": "user", "content": prompt})
+
+#     with st.chat_message("assistant"):
+#         message_placeholder = st.empty()
+#         full_response = ""
+
+#         # Get response from QA chain
+#         result = qa_chain({
+#             "question": prompt,
+#             "human_input": prompt,
+#             "chat_history": [(msg["role"], msg["content"]) for msg in st.session_state.messages]
+#         })
+#         full_response = result['answer']
+
+#         # Simulate stream of response with milliseconds delay
+#         for chunk in full_response.split():
+#             full_response = f"{full_response}"
+#             time.sleep(0.05)
+#             # Add a blinking cursor to simulate typing
+#             message_placeholder.markdown(full_response)
+        
+#         message_placeholder.markdown(full_response)
+    
+#     # Add assistant response to chat history
+#     st.session_state.messages.append({"role": "assistant", "content": full_response})
+
 import os
+import time
+import textwrap
 from dotenv import load_dotenv
-load_dotenv()
 
-from langchain_astradb import AstraDBVectorStore
-from langchain_google_genai import GoogleGenerativeAIEmbeddings
-from langchain.prompts import PromptTemplate
-from langchain.chains import ConversationalRetrievalChain
-from langchain_google_genai import ChatGoogleGenerativeAI
 import streamlit as st
-import time
-import textwrap
+from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type
 
-# embeddings 
-embeddings = GoogleGenerativeAIEmbeddings(
-    model = "models/embedding-001",
-    task_type = "retrieval_document"
-)
+from langchain.prompts import PromptTemplate
+from langchain.chains import RetrievalQA
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain_community.llms import HuggingFaceHub
 
-# llm 
-llm = ChatGoogleGenerativeAI(
-    # model = "gemini-1.5-pro",
-    model = "Gemini 2.0 Flash", 
-    temperature = 0.7,
-)
+# --- Optional Astra (uncomment if you want Astra) ---
+ASTRA_ENABLED = False
+try:
+    from langchain_astradb import AstraDBVectorStore
+    ASTRA_ENABLED = True
+except Exception:
+    ASTRA_ENABLED = False
 
-# Get Info about the Database 
-vstore = AstraDBVectorStore(
-    collection_name = "Bhagavad_gita_data",
-    embedding = embeddings,
-    token = os.getenv("ASTRA_DB_APPLICATION_TOKEN"),
-    api_endpoint = os.getenv("ASTRA_DB_API_ENDPOINT"),
-)
+# ===================== Setup =====================
 
-# Now Retrieve the Documents from Server
-retriever = vstore.as_retriever(search_kwargs = {"k" : 5})
+load_dotenv()
+
+st.set_page_config(page_title="Arjun AI", page_icon="🧘", layout="wide")
+st.title("Arjun AI")
+st.write("Get Yourself Help from timeless teachings of the Bhagavad Gita (practical, modern, non-religious)")
+
+# Hugging Face (free) model + embeddings
+HF_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN", "")
+if not HF_TOKEN:
+    st.warning("HUGGINGFACEHUB_API_TOKEN is not set. Add it to your .env. (free token from huggingface.co/settings/tokens)")
+
+# Embeddings (free, CPU)
+@st.cache_resource
+def get_embeddings():
+    # all-MiniLM-L6-v2 is light, accurate enough for RAG
+    return HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+# LLM via Hugging Face Inference API (free)
+@st.cache_resource
+def get_llm():
+    # You can swap the repo_id to another free endpoint you like
+    # Good free options: mistralai/Mistral-7B-Instruct-v0.2, google/gemma-2-2b-it
+    return HuggingFaceHub(
+        repo_id="mistralai/Mistral-7B-Instruct-v0.3",
+        model_kwargs={
+            "temperature": 0.7,
+            "max_new_tokens": 800,
+            "top_p": 0.9,
+        },
+        huggingfacehub_api_token=HF_TOKEN
+    )
+
+# Vector store
+@st.cache_resource
+def get_retriever():
+    embeddings = get_embeddings()
+
+    # Prefer Astra if creds present and you actually want it
+    use_astra = (
+        ASTRA_ENABLED
+        and os.getenv("ASTRA_DB_APPLICATION_TOKEN")
+        and os.getenv("ASTRA_DB_API_ENDPOINT")
+    )
+
+    if use_astra:
+        st.info("Using Astra DB Vector Store")
+        vstore = AstraDBVectorStore(
+            collection_name=os.getenv("ASTRA_DB_COLLECTION", "Bhagavad_gita_data"),
+            embedding=embeddings,
+            token=os.getenv("ASTRA_DB_APPLICATION_TOKEN"),
+            api_endpoint=os.getenv("ASTRA_DB_API_ENDPOINT"),
+        )
+        return vstore.as_retriever(search_kwargs={"k": 4})
+
+    # Fallback: local FAISS (first run creates an index from a tiny seed corpus)
+    st.info("Using Local FAISS Vector Store (fallback)")
+    # A tiny starter corpus; replace with your own documents to improve recall.
+    corpus = [
+        {
+            "id": "1",
+            "text": (
+                "When the mind is steady and undisturbed by outcomes, actions become clear and effective. "
+                "Focus on your role and allow results to unfold naturally."
+            ),
+        },
+        {
+            "id": "2",
+            "text": (
+                "Detachment does not mean indifference; it means full effort without anxiety over reward. "
+                "This brings calm strength and frees you from hesitation."
+            ),
+        },
+        {
+            "id": "3",
+            "text": (
+                "Facing doubt with disciplined practice turns fear into clarity. "
+                "Commit to small daily steps and align your choices with your higher duty."
+            ),
+        },
+        {
+            "id": "4",
+            "text": (
+                "Your nature guides you toward purposeful work. "
+                "Refine your skills, serve wholeheartedly, and let integrity be your anchor."
+            ),
+        },
+    ]
+    texts = [c["text"] for c in corpus]
+    metadatas = [{"id": c["id"]} for c in corpus]
+    vs = FAISS.from_texts(texts=texts, embedding=embeddings, metadatas=metadatas)
+    return vs.as_retriever(search_kwargs={"k": 4})
+
+retriever = get_retriever()
+llm = get_llm()
+
+# ===================== Prompt =====================
 
 prompt_template = """
-You are a wise counselor drawing from ancient Indian wisdom to offer psychological guidance. Your role is to provide practical, concise advice for modern challenges. 
-You are going to be used for a psychiatrist assitance who gives advices on the context of bhagvad gita.
+You are a wise counselor drawing from ancient Indian wisdom to offer psychological guidance. Your role is to provide practical, concise advice for modern challenges.
+You are going to be used for a psychiatrist assistance who gives advice in the context of the Bhagavad Gita.
 Follow these guidelines:
-
 1. Begin with a brief, relatable insight from timeless teachings.
-
 2. Offer 4 to 6 specific, actionable points of advice.
-
 3. Each point should start on a new line and be clear and concise.
-
 4. Connect each piece of advice to universal principles of success and well-being.
-
 5. Use metaphors or examples from ancient texts without explicitly naming them.
-
 6. Conclude with an encouraging statement that motivates the user to apply the advice.
-
 7. Avoid religious terminology. Use phrases like "ancient wisdom" or "timeless teachings" instead.
-
 8. Ensure your response is practical, universally applicable, and inspirational.
+9. If the input is not a real psychological dilemma/question, ask the user to enter a proper question.
+10. If possible, give only a relevant Bhagavad Gita verse at the end (Verse number + a short translation in English). Do not cite other books.
+11. If you can't find an exact verse, infer from context and give the Answer in Hindi.
 
-9. Be strict that if some gives some wrong or useless input which is not relevant to physcological issue or dilema then reply them to enter the proper question
-
-10. If possible try to give only Bhagavad Gita Verse related to it at end don't get any other verse from any other book and give verse Translation and number only as many don't know to read sanskrit. 
+Context:
+{context}
 
-11. If you don't know the verse from Bhagavad Gita just search through the context and then give Answer in Hindi.
+Question:
+{question}
 
-Context: {context}
-Question: {question}
-Human: {human_input}
-Chat History: {chat_history}
+Chat History (role, content):
+{chat_history}
 """
 
-
 PROMPT = PromptTemplate(
-    template = prompt_template,
-    input_variables = ["context", "question", "human_input", "chat_history"]
-)
-
-qa_chain = ConversationalRetrievalChain.from_llm(
-    llm,
-    retriever = retriever,
-    combine_docs_chain_kwargs = {"prompt": PROMPT},
-    return_source_documents = False,
+    template=prompt_template,
+    input_variables=["context", "question", "chat_history"],
 )
 
-# format the output in good format
-def format_and_wrap_text(text, wrap_length=100):
-    # Split the text into main points
-    main_points = text.split('**')
+# ===================== Chain =====================
 
-    formatted_text = ""
-    for i in range(1, len(main_points), 2):
-        # Add the main point title
-        formatted_text += f"{main_points[i]}\n"
-
-        # Split the subpoints by '* '
-        subpoints = main_points[i+1].strip().split('* ')
-        for subpoint in subpoints:
-            if subpoint.strip():
-                # Wrap each subpoint and add a bullet
-                wrapped_subpoint = textwrap.fill(subpoint, wrap_length)
-                formatted_text += f"{wrapped_subpoint}\n"
+# One-call chain (cheaper / fewer rate-limit errors than ConversationalRetrievalChain)
+qa_chain = RetrievalQA.from_chain_type(
+    llm=llm,
+    retriever=retriever,
+    chain_type="stuff",
+    return_source_documents=False,
+    chain_type_kwargs={"prompt": PROMPT},
+)
 
-        formatted_text += "\n"
+# Backoff helper for free-tier rate limits
+class RateLimitedError(Exception):
+    """Raised when HF returns a rate limit or capacity error"""
 
-    print(formatted_text)
+@retry(
+    reraise=True,
+    wait=wait_exponential(multiplier=1, min=1, max=20),
+    stop=stop_after_attempt(6),
+    retry=retry_if_exception_type(RateLimitedError),
+)
+def ask(chain, question, history):
+    try:
+        return chain({
+            "question": question,
+            "chat_history": history,
+            "context": ""  # retriever fills this internally in 'stuff' chain
+        })
+    except Exception as e:
+        # Very simple heuristic: treat 429/overloaded messages as retryable
+        msg = str(e).lower()
+        if any(k in msg for k in ["rate", "limit", "429", "overloaded", "capacity"]):
+            raise RateLimitedError(e)
+        raise
 
-# Streamlit App Design 
-st.set_page_config(page_title="Arjun AI")
+# ===================== UI State =====================
 
-# app 
-st.title("Arjun AI")
-st.write("Get Yourself Help from Krishna's Teaching of Bhagavad Gita")
+# simple UI rate-limit (1 request / 1.2s)
+if "last_call" not in st.session_state:
+    st.session_state.last_call = 0.0
 
-# Initialize chat history
 if "messages" not in st.session_state:
     st.session_state.messages = []
 
-# Display chat messages from history on app rerun
-for message in st.session_state.messages:
-    with st.chat_message(message["role"]):
-        st.markdown(message["content"])
+# Display history
+for m in st.session_state.messages:
+    with st.chat_message(m["role"]):
+        st.markdown(m["content"])
+
+# ===================== Chat =====================
+
+def wrap_points(text: str, width: int = 86) -> str:
+    lines = []
+    for raw in text.split("\n"):
+        if len(raw.strip()) == 0:
+            lines.append("")
+            continue
+        if raw.lstrip().startswith(("-", "*", "•")):
+            # keep bullets, only wrap right side
+            prefix = raw[: raw.find(raw.lstrip())]
+            bullet = raw.lstrip().split(" ")[0]
+            rest = raw.lstrip()[len(bullet):].strip()
+            wrapped = textwrap.fill(rest, width=width, subsequent_indent="  ")
+            lines.append(f"{bullet} {wrapped}")
+        else:
+            lines.append(textwrap.fill(raw, width=width))
+    return "\n".join(lines)
+
+prompt = st.chat_input("What is your question?")
+if prompt:
+    # UI throttle
+    if time.time() - st.session_state.last_call < 1.2:
+        st.info("Please wait a moment before asking again.")
+        st.stop()
+    st.session_state.last_call = time.time()
 
-# React to user input
-if prompt := st.chat_input("What is your question?"):
-    # Display user message in chat message container
-    st.chat_message("user").markdown(prompt)
-    # Add user message to chat history
     st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
 
     with st.chat_message("assistant"):
-        message_placeholder = st.empty()
-        full_response = ""
-
-        # Get response from QA chain
-        result = qa_chain({
-            "question": prompt,
-            "human_input": prompt,
-            "chat_history": [(msg["role"], msg["content"]) for msg in st.session_state.messages]
-        })
-        full_response = result['answer']
-
-        # Simulate stream of response with milliseconds delay
-        for chunk in full_response.split():
-            full_response = f"{full_response}"
-            time.sleep(0.05)
-            # Add a blinking cursor to simulate typing
-            message_placeholder.markdown(full_response)
-        
-        message_placeholder.markdown(full_response)
-    
-    # Add assistant response to chat history
-    st.session_state.messages.append({"role": "assistant", "content": full_response})
-
+        box = st.empty()
+        box.markdown("_thinking…_")
+
+        # Build history as tuples (role, content)
+        history = [(m["role"], m["content"]) for m in st.session_state.messages if m["role"] != "assistant"]
+        try:
+            res = ask(qa_chain, prompt, history)
+            answer = res.get("result", "")
+        except Exception as e:
+            answer = f"Sorry — the model is busy right now: `{e}`. Please try again in a moment."
+
+        answer = wrap_points(answer)
+        box.markdown(answer)
+        st.session_state.messages.append({"role": "assistant", "content": answer})