Upload 8 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+src/data/vector_stores/default_pdf_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+src/Ring_App_Documentation.pdf filter=lfs diff=lfs merge=lfs -text

src/Ring_App_Documentation.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64e0a8f1ceb73caf38efb4ca3dc534b8071b41a06d32758ae9e88a65695ea171
+size 4177325

src/chat_logic.py

@@ -0,0 +1,167 @@
+# chat_logic.py
+
+import os
+import re
+import warnings
+from pathlib import Path
+from typing import Any, Tuple, Optional, Dict
+
+# Langchain/OpenAI imports
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain_core.prompts import PromptTemplate, ChatPromptTemplate
+from langchain_classic.chains import ConversationalRetrievalChain
+from langchain_classic.memory import ConversationBufferMemory, ConversationSummaryBufferMemory
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter, CharacterTextSplitter
+from langchain_community.vectorstores import Chroma
+from langchain_community.document_transformers import EmbeddingsRedundantFilter, LongContextReorder
+from langchain_classic.retrievers.document_compressors import DocumentCompressorPipeline
+from langchain_classic.retrievers.document_compressors import EmbeddingsFilter
+from langchain_classic.retrievers import ContextualCompressionRetriever
+from langchain_text_splitters import TextSplitter
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.language_models import BaseChatModel
+
+# --- Constants & Helpers ---
+
+LOCAL_VECTOR_STORE_DIR = Path(__file__).resolve().parent.joinpath("data", "vector_stores")
+# !!! SET YOUR DEFAULT PDF PATH HERE !!!
+# Assuming the default PDF is in the same directory as this script.
+DEFAULT_PDF_PATH = Path(__file__).resolve().parent.joinpath("S:\\ano_dec_pro\\AnomalyDetectionCVPR2018-Pytorch\\ring_chat_bot\\Ring_App_Documentation.pdf")
+DEFAULT_VECTORSTORE_NAME = "default_pdf_db"
+OPENAI_KEY = os.getenv("OPENAI_API_KEY")
+
+
+def ensure_dir(p: Path) -> None:
+    p.mkdir(parents=True, exist_ok=True)
+
+def load_default_pdf():
+    # Attempt to find the default PDF in the script directory
+    if not DEFAULT_PDF_PATH.exists():
+        raise FileNotFoundError(
+            f"Default PDF not found: {DEFAULT_PDF_PATH}. Please place your PDF here or update the path in chat_logic.py"
+        )
+    loader = PyPDFLoader(DEFAULT_PDF_PATH.as_posix())
+    return loader.load()
+
+def split_documents(docs, chunk_size: int = 1600, chunk_overlap: int = 200):
+    splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+    return splitter.split_documents(docs)
+
+def select_embeddings(openai_key: str | None) -> OpenAIEmbeddings:
+    if not openai_key:
+        raise ValueError("OPENAI_API_KEY is required.")
+    return OpenAIEmbeddings(api_key=openai_key)
+
+# --- Core RAG Components ---
+
+def vectorstore_backed_retriever(vs: Chroma, search_type: str = "similarity", k: int = 16, score_threshold: float | None = None) -> BaseRetriever:
+    kwargs = {}
+    if k is not None:
+        kwargs["k"] = k
+    if score_threshold is not None:
+        kwargs["score_threshold"] = score_threshold
+    return vs.as_retriever(search_type=search_type, search_kwargs=kwargs)
+
+
+def make_compression_retriever(embeddings: OpenAIEmbeddings, base_retriever: BaseRetriever, chunk_size: int = 500, k: int = 16, similarity_threshold: float | None = None) -> ContextualCompressionRetriever:
+    splitter: TextSplitter = CharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=0, separator=". ")
+    redundant_filter = EmbeddingsRedundantFilter(embeddings=embeddings)
+    relevant_filter = EmbeddingsFilter(embeddings=embeddings, k=k, similarity_threshold=similarity_threshold)
+    reordering = LongContextReorder()
+    pipeline = DocumentCompressorPipeline(transformers=[splitter, redundant_filter, relevant_filter, reordering])
+    return ContextualCompressionRetriever(base_compressor=pipeline, base_retriever=base_retriever)
+
+
+def make_memory(model_name: str, openai_key: str | None):
+    # Simplified memory logic for Streamlit
+    return ConversationSummaryBufferMemory(
+        max_token_limit=1024,
+        llm=ChatOpenAI(model_name="gpt-3.5-turbo", openai_api_key=openai_key, temperature=0.1),
+        return_messages=True,
+        memory_key="chat_history",
+        output_key="answer",
+        input_key="question",
+    )
+
+
+def answer_template(language: str = "english") -> str:
+    return f"""Answer the question at the end, using only the following context (delimited by <context></context>).
+Your answer must be in the language at the end.
+
+<context>
+{{chat_history}}
+
+{{context}}
+</context>
+
+Question: {{question}}
+
+Language: {language}.
+"""
+
+def build_chain(model: str, retriever: BaseRetriever, openai_key: str | None) -> Tuple[ConversationalRetrievalChain, Any]:
+    condense_question_prompt = PromptTemplate(
+        input_variables=["chat_history", "question"],
+        template=(
+            "Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language.\n\nChat History:\n{chat_history}\n\nFollow Up Input: {question}\n\nStandalone question:"
+        ),
+    )
+    answer_prompt = ChatPromptTemplate.from_template(answer_template(language="english"))
+    memory = make_memory(model, openai_key)
+
+    standalone_llm = ChatOpenAI(api_key=openai_key, model=model, temperature=0.1)
+    response_llm = ChatOpenAI(api_key=openai_key, model=model, temperature=0.5, top_p=0.95)
+
+    chain = ConversationalRetrievalChain.from_llm(
+        condense_question_prompt=condense_question_prompt,
+        combine_docs_chain_kwargs={"prompt": answer_prompt},
+        condense_question_llm=standalone_llm,
+        llm=response_llm,
+        memory=memory,
+        retriever=retriever,
+        chain_type="stuff",
+        verbose=False,
+        return_source_documents=True,
+    )
+    return chain, memory
+
+
+def setup_default_rag(openai_key: str, model_name: str = "gpt-4-turbo") -> Tuple[ConversationalRetrievalChain, Any]:
+    """
+    Sets up the RAG chain using the default hardcoded PDF file.
+    This replaces the file upload functionality for the initial setup.
+    """
+    
+    vectorstore_path = LOCAL_VECTOR_STORE_DIR.joinpath(DEFAULT_VECTORSTORE_NAME)
+    ensure_dir(vectorstore_path)
+    
+    embeddings = select_embeddings(openai_key)
+
+    # Check if the vector store already exists locally (persistence logic)
+    if not any(vectorstore_path.iterdir()):
+        # 1. Load and split the default PDF
+        docs = load_default_pdf()
+        chunks = split_documents(docs)
+        
+        # 2. Create and persist the Vector Store (Chroma)
+        vs = Chroma.from_documents(
+            documents=chunks, 
+            embedding=embeddings, 
+            persist_directory=vectorstore_path.as_posix()
+        )
+        vs.persist()
+    else:
+        # 3. Load the existing Vector Store
+        vs = Chroma(embedding_function=embeddings, persist_directory=vectorstore_path.as_posix())
+
+    # 4. Create Retriever
+    base_retriever = vectorstore_backed_retriever(vs)
+    retriever = make_compression_retriever(embeddings=embeddings, base_retriever=base_retriever)
+
+    # 5. Build and return chain
+    chain, memory = build_chain(model_name, retriever, openai_key)
+
+    return chain, memory
+
+# The process_uploaded_file function is removed as we are hardcoding the default file setup.

src/data/vector_stores/default_pdf_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5cf4518dece34cb61b6ed9a0d4d9e80ffbb5b27dbcb456599dd94c53b81a1501
+size 667648

src/data/vector_stores/default_pdf_db/e1eec7e8-c14a-4d91-84f8-494ed1640f40/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6947c7600d0ae572da78c33e440a007be9b2bc4763c61e7f99e7d8695deede2
+size 628400

src/data/vector_stores/default_pdf_db/e1eec7e8-c14a-4d91-84f8-494ed1640f40/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b081be2c2276a57e995075c7de2f3cb25e903798aac36d98042045533ab28f7d
+size 100

src/data/vector_stores/default_pdf_db/e1eec7e8-c14a-4d91-84f8-494ed1640f40/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b043c771f5c6da7fd675c1557bded1b551f2019df55601e652bb22d83312bc9d
+size 400

src/data/vector_stores/default_pdf_db/e1eec7e8-c14a-4d91-84f8-494ed1640f40/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+size 0

src/streamlit_app.py

@@ -1,40 +1,149 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# rag_streamlit_app.py
+
+import streamlit as st
+import os
+import warnings
+import re
+from dotenv import load_dotenv
+from chat_logic import setup_default_rag, OPENAI_KEY # Import core logic
+
+# Suppress LangChain and other warnings for a clean Streamlit app
+warnings.filterwarnings("ignore")
+load_dotenv()
+
+# --- Configuration ---
+st.set_page_config(page_title="Ring App RAG Chatbot", layout="wide")
+
+# --- Initialize Session State ---
+if 'chain' not in st.session_state:
+    st.session_state.chain = None
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+if 'memory' not in st.session_state:
+    st.session_state.memory = None
+if 'openai_api_key' not in st.session_state:
+    st.session_state.openai_api_key = OPENAI_KEY
+
+
+# --- Functions for UI Actions ---
+
+def clear_chat_history():
+    """Resets the chat history and the memory buffer."""
+    if st.session_state.memory:
+        st.session_state.memory.clear()
+    st.session_state.chat_history = []
+    st.toast("Chat history cleared!", icon="🧹")
+
+def initialize_rag_system():
+    """Initializes the RAG chain using the hardcoded default file."""
+    if st.session_state.openai_api_key:
+        with st.spinner("Setting up the Ring App knowledge base..."):
+            try:
+                model = "gpt-4-turbo" 
+                
+                # CALL THE NEW DEFAULT SETUP FUNCTION
+                chain, memory = setup_default_rag(st.session_state.openai_api_key, model)
+                
+                st.session_state.chain = chain
+                st.session_state.memory = memory
+                st.session_state.chat_history = []
+                st.toast("Ring App knowledge base loaded and chatbot ready!", icon="✅")
+            except FileNotFoundError as e:
+                 st.error(f"FATAL ERROR: {e}. Please ensure 'default_rag_file.pdf' is in the script directory.")
+                 st.session_state.chain = None
+            except Exception as e:
+                st.error(f"Error setting up RAG system: {e}")
+                st.session_state.chain = None
+                st.session_state.memory = None
+    elif not st.session_state.openai_api_key:
+         st.error("Please enter your OpenAI API Key in the sidebar.")
+
+
+def generate_response(prompt):
+    """Invokes the RAG chain with the user's prompt."""
+    if st.session_state.chain:
+        try:
+            # Invoke the chain
+            response = st.session_state.chain.invoke({"question": prompt})
+            answer = response.get("answer", "Sorry, I couldn't find an answer based only on the Ring App document.")
+            
+            # Clean response logic
+            answer = re.sub(r'\\n|\r|\n', ' ', answer)
+            answer = re.sub(r'(Sources?:\s*.+$)', '', answer, flags=re.IGNORECASE)
+            answer = re.sub(r'\[[^\]]*\]|\([^\)]*\)', '', answer)
+            answer = re.sub(r'[*_#>`~\-]{1,}', ' ', answer)
+            answer = re.sub(r'\s{2,}', ' ', answer).strip()
+            
+            # Update chat history state
+            st.session_state.chat_history.append({"role": "user", "content": prompt})
+            st.session_state.chat_history.append({"role": "assistant", "content": answer})
+            
+            return answer
+
+        except Exception as e:
+            st.error(f"An error occurred during the conversation: {e}")
+            return "Sorry, there was an error processing your request."
+    else:
+        return "Please initialize the chatbot using the button in the sidebar."
+
+
+# --- Streamlit UI Layout ---
+
+st.title("Ring App Support Chatbot")
+st.markdown("This RAG system is pre-loaded with knowledge about the **Ring Doorbell App**")
+
+# Sidebar for configuration
+with st.sidebar:
+    st.header("Configuration")
+    
+    # API Key Input
+    st.session_state.openai_api_key = st.text_input(
+        "OpenAI API Key", 
+        value=st.session_state.openai_api_key, 
+        type="password", 
+        help="Required to use OpenAI embeddings and models."
+    )
+    
+    st.markdown("---")
+    
+    # Initialization Button
+    if st.button("Initialize Chatbot", type="primary"):
+        initialize_rag_system()
+        
+    st.caption("The chatbot will only answer from the pre-loaded Ring App documentation.")
+    
+    st.markdown("---")
+    
+    # Reset Button
+    if st.button("Clear History", help="Clears conversation memory and chat display."):
+        clear_chat_history()
+        
+    # Check if the system is initialized and ready
+    if st.session_state.chain:
+        st.success("System Ready! Ask a question below.")
+
+
+# --- Main Chat Interface ---
+
+# Display chat messages from history
+for message in st.session_state.chat_history:
+    with st.chat_message(message["role"]):
+        st.write(message["content"])
+
+# Initial state prompt
+if not st.session_state.chain and not st.session_state.chat_history:
+    st.info("Click **Initialize Chatbot** in the sidebar to load the default Ring App knowledge base.")
+    st.stop()
+
+
+# Chat input box
+if prompt := st.chat_input("Ask a question about Ring App setup, dashboard, or history..."):
+    # Immediately display user message
+    with st.chat_message("user"):
+        st.write(prompt)
+    
+    # Generate and display assistant response
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking..."):
+            response_text = generate_response(prompt)
+            st.write(response_text)