first commit

.env

@@ -0,0 +1,2 @@
+GROQ_API_KEY="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"
+TAVILY_API_KEY="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"

.github/workflows/main.yml

@@ -0,0 +1,31 @@
+name: Sync to Hugging Face Hub
+
+on:
+  push:
+    branches: [main]
+
+    # This allows you to run it manually from the Actions tab for testing
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git config --global user.email "your-email@example.com"
+          git config --global user.name "Your Name"
+          
+          # Add Hugging Face as a remote repository
+          # REPLACE 'your-username' AND 'space-name' BELOW:
+          git remote add space https://your-username:$HF_TOKEN@huggingface.co/spaces/your-username/space-name
+          
+          # Force push to the Space
+          git push --force space main

Dockerfile

@@ -0,0 +1,19 @@
+# Use a lightweight Python version
+FROM python:3.9-slim
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy your files to the container
+COPY . .
+
+# Install dependencies
+# We use --no-cache-dir to keep the image small
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose port 7860 (Required for Hugging Face Spaces)
+EXPOSE 7860
+
+# Command to run the app
+# Notice we force the port to 7860 here
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,79 @@
+import streamlit as st
+import backend # Importing the logic file we created earlier
+
+# --- PAGE CONFIGURATION ---
+st.set_page_config(
+    page_title="The Devil's Advocate",
+    page_icon="😈",
+    layout="centered"
+)
+
+# --- SESSION STATE INITIALIZATION ---
+# This keeps the chat history and database alive when the user clicks buttons
+if "messages" not in st.session_state:
+    st.session_state.messages = [
+        {"role": "assistant", "content": "I am the Devil's Advocate. State an opinion, and I will find evidence to challenge it."}
+    ]
+
+if "retriever" not in st.session_state:
+    st.session_state.retriever = None
+
+# --- SIDEBAR (Settings & Upload) ---
+with st.sidebar:
+    st.title("😈 Settings")
+    st.write("Upload a document to debate its contents, or leave empty to debate using the Web.")
+    
+    # File Uploader
+    uploaded_file = st.file_uploader("Upload PDF (Optional)", type=("pdf"))
+
+    # Logic: Process file ONLY if it's new
+    if uploaded_file and st.session_state.retriever is None:
+        with st.spinner("Reading and analyzing your document..."):
+            # Call the backend function
+            retriever = backend.process_uploaded_file(uploaded_file)
+            if retriever:
+                st.session_state.retriever = retriever
+                st.success("Document processed! I will now use this file to challenge you.")
+            else:
+                st.error("Error processing file.")
+
+    # Reset Button
+    if st.button("Clear Chat"):
+        st.session_state.messages = []
+        st.rerun()
+
+# --- MAIN CHAT INTERFACE ---
+st.title("The Devil's Advocate ⚖️")
+st.markdown("*> A RAG System designed to find the counter-argument.*")
+
+# 1. Display Chat History
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# 2. Handle User Input
+if prompt := st.chat_input("State your opinion (e.g., 'Remote work destroys culture')"):
+    
+    # A. Display User Message
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    # B. Generate AI Response
+    with st.chat_message("assistant"):
+        with st.spinner("Searching for counter-evidence..."):
+            try:
+                # Call the backend logic
+                # Pass the retriever (if it exists) or None (to trigger web search)
+                response = backend.get_advocate_response(
+                    prompt, 
+                    pdf_retriever=st.session_state.retriever
+                )
+                
+                st.markdown(response)
+                
+                # C. Save Response to History
+                st.session_state.messages.append({"role": "assistant", "content": response})
+                
+            except Exception as e:
+                st.error(f"An error occurred: {e}")

backend.py

@@ -0,0 +1,117 @@
+import os
+from dotenv import load_dotenv
+
+# --- CHANGED IMPORTS FOR GROQ & HUGGINGFACE ---
+from langchain_groq import ChatGroq
+from langchain_huggingface import HuggingFaceEmbeddings
+
+from langchain_community.vectorstores import FAISS
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+
+# Load environment variables
+load_dotenv()
+
+# --- CONFIGURATION (UPDATED) ---
+
+# 1. Setup Groq LLM (Uses your gsk_ key automatically if stored as GROQ_API_KEY in .env)
+# We use Llama-3-8b because it is fast and smart.
+llm = ChatGroq(
+    model="openai/gpt-oss-20b", 
+    temperature=0.7
+)
+
+# 2. Setup Embeddings (Switched to Free Local Embeddings)
+# This downloads a small model to your computer so you don't need an OpenAI key for this.
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+# Initialize Web Search Tool
+web_search_tool = TavilySearchResults(k=3)
+
+def process_uploaded_file(uploaded_file):
+    """
+    Process the uploaded PDF using local embeddings.
+    """
+    try:
+        file_path = f"temp_{uploaded_file.name}"
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+
+        loader = PyPDFLoader(file_path)
+        pages = loader.load_and_split()
+        
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200
+        )
+        splits = text_splitter.split_documents(pages)
+
+        # Create Vector Store using the new embeddings
+        vectorstore = FAISS.from_documents(documents=splits, embedding=embeddings)
+        retriever = vectorstore.as_retriever()
+
+        os.remove(file_path)
+        return retriever
+    except Exception as e:
+        print(f"Error processing file: {e}")
+        return None
+
+def generate_counter_query(user_input):
+    """
+    Uses Groq to flip the query.
+    """
+    flip_prompt = ChatPromptTemplate.from_template(
+        """
+        You are a research assistant.
+        User Statement: "{user_input}"
+        Task: Write a single, concise Google search query to find evidence that DISPROVES or CHALLENGES the user's statement.
+        Search Query:
+        """
+    )
+    
+    chain = flip_prompt | llm | StrOutputParser()
+    return chain.invoke({"user_input": user_input})
+
+def get_advocate_response(user_input, pdf_retriever=None):
+    context_text = ""
+    source_type = ""
+
+    # --- RETRIEVAL ---
+    if pdf_retriever:
+        docs = pdf_retriever.invoke(user_input)
+        context_text = "\n\n".join([d.page_content for d in docs])
+        source_type = "Uploaded Document"
+    else:
+        print("Switching to Web Search...")
+        counter_query = generate_counter_query(user_input)
+        print(f"flipped Query: {counter_query}")
+        
+        results = web_search_tool.invoke({"query": counter_query})
+        context_text = "\n\n".join([res['content'] for res in results])
+        source_type = "Web Search (Verified Sources)"
+
+    # --- GENERATION ---
+    system_template = """
+    You are the "Devil's Advocate". Critically analyze the user's statement 
+    and provide a counter-argument based ONLY on the context.
+
+    CONTEXT ({source_type}):
+    {context}
+
+    USER STATEMENT:
+    {user_input}
+
+    YOUR COUNTER-ARGUMENT:
+    """
+
+    prompt = ChatPromptTemplate.from_template(system_template)
+    chain = prompt | llm | StrOutputParser()
+    
+    return chain.invoke({
+        "source_type": source_type,
+        "context": context_text,
+        "user_input": user_input
+    })

requirements.txt

@@ -0,0 +1,10 @@
+streamlit
+langchain
+langchain-groq          # CHANGED: For your gsk_ key
+langchain-community
+langchain-huggingface   # CHANGED: For free local embeddings
+faiss-cpu
+python-dotenv
+tavily-python
+pypdf
+sentence-transformers   # Required for HuggingFace embeddings