Test push3

app.py

@@ -1,113 +1,85 @@
+# Install required packages first:
+# pip install langchain huggingface_hub pandas faiss-cpu numpy transformers torch accelerate bitsandbytes gradio
+
+import pandas as pd
+import numpy as np
 import gradio as gr
+import torch
+from langchain.vectorstores import FAISS
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.chains import RetrievalQA
+from langchain.prompts import PromptTemplate
+from langchain.llms import HuggingFacePipeline
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
 from huggingface_hub import InferenceClient
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
+# Configuration for both components
+EMBEDDING_MODEL_NAME = "sentence-transformers/all-mpnet-base-v2"
+LLM_MODEL_NAME = "EleutherAI/gpt-neo-1.3B"
+CHAT_MODEL_NAME = "HuggingFaceH4/zephyr-7b-beta"
+
+# ------ Chat Component ------
+chat_client = InferenceClient(CHAT_MODEL_NAME)
+
+def chat_respond(
+    message: str,
+    history: list[list[str]],
+    system_message: str,
+    max_tokens: int,
+    temperature: float,
+    top_p: float,
 ):
     messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
+    
+    for human, assistant in history:
+        messages.extend([
+            {"role": "user", "content": human},
+            {"role": "assistant", "content": assistant}
+        ])
+    
     messages.append({"role": "user", "content": message})
 
     response = ""
-
-    for message in client.chat_completion(
+    for chunk in chat_client.chat_completion(
         messages,
         max_tokens=max_tokens,
         stream=True,
         temperature=temperature,
         top_p=top_p,
     ):
-        token = message.choices[0].delta.content
-
+        token = chunk.choices[0].delta.content
         response += token
         yield response
 
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-
-# Install required packages
-# pip install langchain huggingface_hub pandas faiss-cpu numpy transformers torch accelerate bitsandbytes gradio
-
-import pandas as pd
-import numpy as np
-from langchain.vectorstores import FAISS
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain.chains import RetrievalQA
-from langchain.prompts import PromptTemplate
-from langchain.llms import HuggingFacePipeline
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-import torch
-import gradio as gr
-
+# ------ RAG Component ------
 def load_embeddings(csv_path):
-    try:
-        df = pd.read_csv(csv_path)
+    df = pd.read_csv(csv_path)
+    
+    if 'Cleaned_Ideas' not in df.columns or 'Embeddings' not in df.columns:
+        raise ValueError("CSV must contain 'Cleaned_Ideas' and 'Embeddings' columns")
         
-        if 'Cleaned_Ideas' not in df.columns or 'Embeddings' not in df.columns:
-            raise ValueError("CSV must contain 'Cleaned_Ideas' and 'Embeddings' columns")
-            
-        df['Embeddings'] = df['Embeddings'].apply(
-            lambda x: np.fromstring(
-                x.strip("[]").replace("\n", ""),
-                sep=", ",
-                dtype=np.float32
-            )
+    df['Embeddings'] = df['Embeddings'].apply(
+        lambda x: np.fromstring(
+            x.strip("[]").replace("\n", ""),
+            sep=", ",
+            dtype=np.float32
         )
+    )
+    
+    expected_dim = 768
+    valid_embeddings = df['Embeddings'].apply(lambda x: len(x) == expected_dim)
+    if not valid_embeddings.all():
+        invalid_count = len(df) - valid_embeddings.sum()
+        raise ValueError(f"{invalid_count} entries have invalid embedding dimensions")
         
-        expected_dim = 768
-        valid_embeddings = df['Embeddings'].apply(lambda x: len(x) == expected_dim)
-        if not valid_embeddings.all():
-            invalid_count = len(df) - valid_embeddings.sum()
-            raise ValueError(f"{invalid_count} entries have invalid embedding dimensions")
-            
-        return df['Cleaned_Ideas'].tolist(), np.array(df['Embeddings'].tolist())
-        
-    except Exception as e:
-        print(f"Error loading embeddings: {str(e)}")
-        raise
-
-# 1. Load texts and embeddings from CSV
-texts, embeddings = load_embeddings("ideas_with_embeddings.csv")
-
-# 2. Improved embedding model and FAISS configuration
-try:
+    return df['Cleaned_Ideas'].tolist(), np.array(df['Embeddings'].tolist())
+#                                                           Fixed here → ↑
+def setup_rag_system():
+    # Load data and create vector store
+    texts, embeddings = load_embeddings("ideas_with_embeddings.csv")
+    
     embedding_model = HuggingFaceEmbeddings(
-        model_name="sentence-transformers/all-mpnet-base-v2",
+        model_name=EMBEDDING_MODEL_NAME,
         model_kwargs={'device': 'cpu'},
         encode_kwargs={'normalize_embeddings': True}
     )
@@ -117,152 +89,122 @@ try:
         embedding=embedding_model,
         normalize_L2=True
     )
-    print(f"FAISS index created with {vector_store.index.ntotal} entries")
-    
-except Exception as e:
-    print(f"Vector store creation failed: {str(e)}")
-    raise
 
-# 3. Using an openly available model (GPT-Neo 1.3B)
-model_name = "EleutherAI/gpt-neo-1.3B"
-try:
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    # Load LLM
+    tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL_NAME)
     model = AutoModelForCausalLM.from_pretrained(
-        model_name,
+        LLM_MODEL_NAME,
         device_map="auto",
         torch_dtype=torch.float16,
         trust_remote_code=True
     )
-    print("GPT-Neo 1.3B model loaded successfully.")
     
-except Exception as e:
-    print(f"Model loading failed: {str(e)}")
-    print("You may need to accept the model license at: https://huggingface.co/EleutherAI/gpt-neo-1.3B")
-    raise
-
-# Text generation pipeline
-pipe = pipeline(
-    "text-generation",
-    model=model,
-    tokenizer=tokenizer,
-    max_new_tokens=250,
-    temperature=0.7,
-    top_p=0.9,
-    repetition_penalty=1.1,
-    do_sample=True,
-    return_full_text=False,
-    pad_token_id=tokenizer.eos_token_id
-)
-
-llm = HuggingFacePipeline(pipeline=pipe)
-
-# 4. Enhanced prompt template
-template = """<context>
-{context}
-</context>
-
-<question>
-{question}
-</question>
+    pipe = pipeline(
+        "text-generation",
+        model=model,
+        tokenizer=tokenizer,
+        max_new_tokens=250,
+        temperature=0.7,
+        top_p=0.9,
+        repetition_penalty=1.1,
+        do_sample=True,
+        return_full_text=False,
+        pad_token_id=tokenizer.eos_token_id
+    )
 
-Analyze the philosophical concept using ONLY the provided context. Follow these steps:
-1. Identify key elements from the context
-2. Explain relationships between concepts
-3. Highlight any mentioned philosophical implications
+    # Setup QA chain
+    template = """<context>
+    {context}
+    </context>
 
-If context is insufficient, state: "This requires deeper analysis beyond current knowledge." 
+    <question>
+    {question}
+    </question>
 
-Answer:"""
+    Analyze the philosophical concept using ONLY the provided context. Follow these steps:
+    1. Identify key elements from the context
+    2. Explain relationships between concepts
+    3. Highlight any mentioned philosophical implications
 
-prompt = PromptTemplate(
-    template=template,
-    input_variables=["context", "question"],
-    template_format="f-string"
-)
+    If context is insufficient, state: "This requires deeper analysis beyond current knowledge." 
 
-# 5. Optimized retrieval configuration
-qa_chain = RetrievalQA.from_chain_type(
-    llm=llm,
-    chain_type="stuff",
-    retriever=vector_store.as_retriever(
-        search_type="similarity_score_threshold",
-        search_kwargs={
-            "k": 6,
-            "score_threshold": 0.55,
-            "include_metadata": True
-        }
-    ),
-    return_source_documents=True,
-    chain_type_kwargs={
-        "prompt": prompt,
-        "document_prompt": PromptTemplate(
-            input_variables=["page_content"],
-            template="{page_content}"
-        )
-    },
-    verbose=True
-)
+    Answer:"""
+    
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=HuggingFacePipeline(pipeline=pipe),
+        chain_type="stuff",
+        retriever=vector_store.as_retriever(
+            search_type="similarity_score_threshold",
+            search_kwargs={
+                "k": 6,
+                "score_threshold": 0.55,
+                "include_metadata": True
+            }
+        ),
+        return_source_documents=True,
+        chain_type_kwargs={
+            "prompt": PromptTemplate(
+                template=template,
+                input_variables=["context", "question"],
+                template_format="f-string"
+            )
+        },
+        verbose=True
+    )
+    return qa_chain
 
-# 6. Query processing function
-def process_query(query):
-    if not query.strip():
-        return "Please enter a valid question", ""
+# ------ Unified Interface ------
+def create_interface():
+    qa_chain = setup_rag_system()
     
-    try:
-        result = qa_chain({"query": query})
-        response = result['result'].split("Answer:")[-1].strip()
+    with gr.Blocks(title="Philosophical AI Assistant") as demo:
+        gr.Markdown("# 🤖 AI Philosophy Assistant")
+        gr.Markdown("Combining conversational AI with philosophical knowledge base")
         
-        sources_info = "\n\n**Sources:**\n"
-        for i, doc in enumerate(result['source_documents'][:3], 1):
-            excerpt = doc.page_content[:200].replace("\n", " ") + "..."
-            score = doc.metadata.get('score', 0)
-            sources_info += f"{i}. {excerpt} (Relevance: {score:.2f})\n\n"
-            
-        return response, sources_info
-    
-    except Exception as e:
-        return f"Error processing request: {str(e)}", ""
-
-# 7. Gradio interface
-def create_gradio_interface():
-    with gr.Blocks(title="Philosophical Concepts RAG v2") as demo:
-        gr.Markdown("# Enhanced Philosophical RAG System")
-        gr.Markdown("Yay Now with improved context understanding and source verification")
+        # Chat Tab
+        with gr.Tab("Chat"):
+            gr.ChatInterface(
+                fn=chat_respond,
+                additional_inputs=[
+                    gr.Textbox(value="You are a philosophy expert assistant.", label="System Role"),
+                    gr.Slider(1, 2048, value=512, label="Max Tokens"),
+                    gr.Slider(0.1, 4.0, value=0.7, label="Temperature"),
+                    gr.Slider(0.1, 1.0, value=0.95, label="Top-p")
+                ],
+                chatbot=gr.Chatbot(height=500, avatar_images=("👤", "🤖")),
+                textbox=gr.Textbox(placeholder="Ask me anything about philosophy...", container=False, scale=7),
+            )
         
-        with gr.Row():
-            with gr.Column(scale=4):
-                query_input = gr.Textbox(
-                    label="Your Question",
-                    placeholder="Ask about philosophical concepts...",
-                    lines=3
-                )
-                submit_btn = gr.Button("Analyze", variant="primary")
+        # Research Assistant Tab
+        with gr.Tab("Research Assistant"):
+            with gr.Row():
+                with gr.Column(scale=3):
+                    query_input = gr.Textbox(label="Research Query", lines=3)
+                    submit_btn = gr.Button("Analyze", variant="primary")
+                with gr.Column(scale=2):
+                    sources_output = gr.Markdown(label="Source Context")
+            response_output = gr.Markdown(label="Analysis Results")
             
-        with gr.Row():
-            with gr.Column(scale=3):
-                response_output = gr.Markdown(label="Analysis")
-            with gr.Column(scale=2):
-                sources_output = gr.Markdown(label="Supporting Context")
-                
-        submit_btn.click(
-            fn=process_query,
-            inputs=[query_input],
-            outputs=[response_output, sources_output]
-        )
-        
-        gr.Markdown("## Example Queries")
-        examples = gr.Examples(
-            examples=[
-                ["Explain the relationship between consciousness and reality using the provided context"],
-                ["How does the concept of 'being' differ across philosophical traditions?"],
-                ["Analyze the arguments for and against epistemological dualism"]
-            ],
-            inputs=query_input
-        )
-        
+            def process_query(query):
+                try:
+                    result = qa_chain({"query": query})
+                    response = result['result'].split("Answer:")[-1].strip()
+                    sources = "\n".join(
+                        f"**Source {i+1}:** {doc.page_content[:200]}..." 
+                        for i, doc in enumerate(result['source_documents'][:3])
+                    )
+                    return response, sources
+                except Exception as e:
+                    return f"Error: {str(e)}", ""
+            
+            submit_btn.click(
+                process_query,
+                inputs=query_input,
+                outputs=[response_output, sources_output]
+            )
+    
     return demo
 
-# 8. Launch the interface
 if __name__ == "__main__":
-    demo = create_gradio_interface()
-    demo.launch(share=True)
+    demo = create_interface()
+    demo.launch(share=True)