Update app.py

app.py

@@ -1232,401 +1232,270 @@ def multi_agent_chat_advanced(query: str, file=None) -> str:
     except Exception as e:
         return f"Multi-Agent Error: {e}"
 
-# Tab 6
-# LangGraph node functions
-# Initialize the embedding model
+# === Tab 6: Smart Multi‐Document QA (LangGraph + AutoGen + Pinecone Retriever) ===
+
+# Initialize the sentence‐transformer embedding model
 embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
 
-# Intent embedding classification (supports file names)
+# Define intent labels and example phrases for embedding‐based routing
 INTENT_LABELS = {
-    "DocQA": ["document", "file", "paper", "cb", "proposal", "project"],
-    "Summarise": ["summarise", "summary", "abstract", "key points", "overview", "main points"],
-    "General": ["who are you", "tell me something", "what can you do", "fun fact"],
+    "DocQA":    ["document", "file", "paper", "proposal", "project"],
+    "Summarise":["summarise", "summary", "abstract", "key points", "overview", "main points"],
+    "General":  ["who are you", "tell me something", "what can you do", "fun fact"],
 }
 
-# AutoGen Multi-Agent Collaboration Logic 
 def detect_intent_embedding(query, file_names=[]):
+    """
+    Compute embedding of the user query, compare against each intent's example embeddings,
+    and return the label with highest cosine similarity.
+    """
     query_emb = embedding_model.encode(query, normalize_embeddings=True)
-    best_label = None
-    best_score = -1
-    all_phrases = INTENT_LABELS.copy()
+    best_label, best_score = None, -1.0
+    # include file names as additional examples for DocQA
+    phrases = { **INTENT_LABELS }
     if file_names:
-        all_phrases["DocQA"] += [name.lower() for name in file_names]
-    for label, examples in all_phrases.items():
-        for example in examples:
-            example_emb = embedding_model.encode(example, normalize_embeddings=True)
-            score = float(query_emb @ example_emb.T)
+        phrases["DocQA"] += [name.lower() for name in file_names]
+    # find highest scoring intent
+    for label, examples in phrases.items():
+        for ex in examples:
+            ex_emb = embedding_model.encode(ex, normalize_embeddings=True)
+            score = float(query_emb @ ex_emb.T)
             if score > best_score:
-                best_score = score
-                best_label = label
-    return best_label if best_label else "General"
-
-def autogen_multi_document_analysis(query: str, docs: list, file_names: list) -> str:
-    try:      
-        # Create a temporary working directory
-        temp_dir = tempfile.mkdtemp(dir="/tmp")
-        os.environ["OPENAI_CACHE_DIR"] = temp_dir
-        
-        # Set AutoGen's working directory
-        os.environ["AUTOGEN_CACHE_PATH"] = temp_dir
-        os.environ["AUTOGEN_CACHEDIR"] = temp_dir
-        os.environ["OPENAI_CACHE_PATH"] = temp_dir
-        
-        # Force AutoGen to use our temporary directory instead of ./.cache
-        if hasattr(autogen, "set_cache_dir"):
-            autogen.set_cache_dir(temp_dir)
-        
-        # Prepare document context
-        context = "\n\n".join(
-            f"Document {name}:\n{doc[:2000]}..." 
-            for name, doc in zip(file_names, docs)
-        )
-
-        # Configure LLM
-        config_list = [{
-            "model": "gpt-4o-mini",
-            "api_key": openai_api_key
-        }]
-
-        # Base configuration (without any cache-related parameters)
-        llm_config = {
-            "config_list": config_list,
-            "temperature": 0
-        }
-        
-        # Switch to temporary directory before AutoGen processing
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            # AutoGen processing code
-            user_proxy = UserProxyAgent(
-                name="User",
-                system_message="A user seeking information from multiple documents.",
-                human_input_mode="NEVER",
-                code_execution_config={"use_docker": False},
-                llm_config=llm_config
-            )
-
-            # Define document analysis expert
-            doc_analyzer = AssistantAgent(
-                name="DocumentAnalyzer",
-                system_message="""You are an expert at analyzing and comparing documents. Focus on:
-                1. Key similarities and differences
-                2. Main themes and topics
-                3. Relationships between documents
-                4. Evidence-based analysis""",
-                llm_config=llm_config
-            )
-
-            # Define Q&A expert
-            qa_expert = AssistantAgent(
-                name="QAExpert",
-                system_message="""You are an expert at extracting specific information. Focus on:
-                1. Finding relevant details
-                2. Answering specific questions
-                3. Cross-referencing information
-                4. Providing evidence""",
-                llm_config=llm_config
-            )
-
-            # Define summarisation expert
-            summarizer = AssistantAgent(
-                name="Summarizer",
-                system_message="""You are an expert at summarizing content. Focus on:
-                1. Key points and findings
-                2. Important relationships
-                3. Critical conclusions
-                4. Comprehensive overview""",
-                llm_config=llm_config
-            )
-
-            # Create group chat
-            groupchat = GroupChat(
-                agents=[user_proxy, doc_analyzer, qa_expert, summarizer],
-                messages=[],
-                max_round=5
-            )
+                best_label, best_score = label, score
+    return best_label or "General"
 
-            # Create manager
-            manager = GroupChatManager(
-                groupchat=groupchat,
-                llm_config=llm_config
-            )
-
-            # Prepare task prompt
-            task_prompt = f"""Analyze these documents and answer the query:
-        
-            Query: {query}
-
-            Documents Context:
-            {context}
-
-            Requirements:
-            1. Provide a direct and clear answer
-            2. Support all claims with evidence from the documents
-            3. Consider relationships between all documents
-            4. If comparing, analyze all relevant aspects
-            5. If summarizing, cover all important points
-            6. If looking for specific content, search thoroughly
-            7. If analyzing relationships, consider all connections
-
-            Please provide a comprehensive and well-structured answer."""
-            
-            # Execute the group discussion
-            user_proxy.initiate_chat(manager, message=task_prompt)
-            return user_proxy.last_message()["content"]
-        finally:
-            # After processing, change back to the original directory
-            os.chdir(original_dir)
-            
-        return result
+def decide_next(state):
+    """
+    LangGraph router node: choose next node based on detected intent label.
+    """
+    label = detect_intent_embedding(state["query"], state.get("file_names", []))
+    return label
 
-    except Exception as e:
-        print(f"ERROR in AutoGen processing: {str(e)}")
-        return f"Error analyzing documents: {str(e)}"
+def autogen_multi_document_analysis(query: str, docs: list, file_names: list) -> str:
+    """
+    When multiple documents or comparison/relationship queries arise,
+    spin up an AutoGen group chat of specialists (document analysis, Q&A, summariser)
+    to collaboratively reason across all file contexts.
+    """
+    # prepare a temporary workspace for cache
+    temp_dir = tempfile.mkdtemp(dir="/tmp")
+    os.environ["OPENAI_CACHE_DIR"]     = temp_dir
+    os.environ["AUTOGEN_CACHE_PATH"]   = temp_dir
+    os.environ["AUTOGEN_CACHEDIR"]     = temp_dir
+    os.environ["OPENAI_CACHE_PATH"]    = temp_dir
+    if hasattr(autogen, "set_cache_dir"):
+        autogen.set_cache_dir(temp_dir)
+
+    # build combined context snippet for each document
+    context = "\n\n".join(f"Document {name}:\n{doc[:2000]}..."
+                           for name, doc in zip(file_names, docs))
+
+    # configure LLM settings for AutoGen
+    llm_config = {
+        "config_list": [{"model":"gpt-4o-mini", "api_key": openai_api_key}],
+        "temperature": 0
+    }
+
+    # instantiate agents
+    user_proxy = UserProxyAgent( name="User",
+        system_message="User seeking cross-document analysis.",
+        human_input_mode="NEVER",
+        code_execution_config={"use_docker":False},
+        llm_config=llm_config
+    )
+    doc_analyzer = AssistantAgent( name="DocumentAnalyzer",
+        system_message="Expert on comparing document content and structure.",
+        llm_config=llm_config
+    )
+    qa_expert = AssistantAgent( name="QAExpert",
+        system_message="Expert at extracting precise answers from text.",
+        llm_config=llm_config
+    )
+    summarizer = AssistantAgent( name="Summarizer",
+        system_message="Expert at generating concise summaries.",
+        llm_config=llm_config
+    )
 
+    # launch a small group chat
+    group = GroupChat(
+        agents=[user_proxy, doc_analyzer, qa_expert, summarizer],
+        messages=[], max_round=5
+    )
+    manager = GroupChatManager(groupchat=group, llm_config=llm_config)
 
+    # build the task prompt
+    prompt = f"""Analyze these documents and answer the query:
 
-def decide_next(state):
-    query = state.get("query", "")
-    file_names = state.get("file_names", [])
-    label = detect_intent_embedding(query, file_names)
-    return label
+Query: {query}
 
+Documents Context:
+{context}
 
-# === LangGraph Node Functions ===
+Requirements:
+1. Provide a direct and clear answer
+2. Support claims with evidence from the documents
+3. Consider relationships and comparisons where relevant
+Please produce a well-structured answer."""
+    user_proxy.initiate_chat(manager, message=prompt)
+    return user_proxy.last_message()["content"]
 
 def general_run(state):
-    """Use direct LLM response instead of General Agent."""
-    try:
-        prompt = f"""You are a helpful AI assistant. Please answer the following question:
-        {state["query"]}
-        
-        Provide a clear and informative answer."""
-        
-        response = llm_gpt4.invoke(prompt)
-        answer = response.content if hasattr(response, 'content') else str(response)
-        return {"answer": answer}
-    except Exception as e:
-        print(f"ERROR in general_run: {str(e)}")
-        return {"answer": "I apologize, but I'm having trouble processing your request."}
+    """
+    LangGraph 'General' node: fallback that asks GPT-4o-mini directly for general queries.
+    """
+    response = llm_gpt4.invoke(f"You are a helpful assistant. Answer concisely:\n{state['query']}")
+    return {"answer": getattr(response, "content", str(response))}
 
 def docqa_run(state):
-    """Document Q&A processing."""
-    try:
-        # If a retriever exists, use it to get relevant documents; otherwise, use provided docs
-        if "retriever" in state:
-            relevant_docs = state["retriever"].get_relevant_documents(state["query"])
-            context = "\n".join(d.page_content for d in relevant_docs)
-        else:
-            context = "\n".join(state["docs"])
-            
-        prompt = f"""Based on the following context, please answer the question:
-        Question: {state["query"]}
-        
-        Context:
-        {context[:3000]}
-        
-        Provide a detailed and accurate answer based on the context."""
-        
-        response = llm_gpt4.invoke(prompt)
-        return {"answer": response.content if hasattr(response, 'content') else str(response)}
-    except Exception as e:
-        print(f"ERROR in docqa_run: {str(e)}")
-        return general_run(state)
-
-def summariser_run(state):
-    """Document summarisation processing."""
-    try:
+    """
+    LangGraph 'DocQA' node: retrieve from the provided retriever and answer via LLM.
+    """
+    retriever = state.get("retriever")
+    if retriever:
+        docs = retriever.get_relevant_documents(state["query"])
+        context = "\n".join(d.page_content for d in docs)
+    else:
         context = "\n".join(state["docs"])
-        prompt = f"""Please provide a comprehensive summary of the following document:
-        {context[:3000]}
-        
-        Focus on:
-        1. Main topics and key points
-        2. Important findings or conclusions
-        3. Significant details"""
-        
-        response = llm_gpt4.invoke(prompt)
-        return {"summary": response.content if hasattr(response, 'content') else str(response)}
-    except Exception as e:
-        print(f"ERROR in summariser_run: {str(e)}")
-        return {"summary": "Error generating summary."}
+    prompt = f"Based on the following context, answer the question:\n\nContext:\n{context[:3000]}\n\nQuestion: {state['query']}"
+    response = llm_gpt4.invoke(prompt)
+    return {"answer": getattr(response, "content", str(response))}
 
+def summariser_run(state):
+    """
+    LangGraph 'Summarise' node: produce a concise summary of the combined documents.
+    """
+    context = "\n".join(state["docs"])
+    prompt = f"Please summarise the following content:\n\n{context[:3000]}"
+    response = llm_gpt4.invoke(prompt)
+    return {"summary": getattr(response, "content", str(response))}
+
+def build_langgraph_pipeline():
+    """
+    Assemble the LangGraph state graph: Router -> {DocQA, Summarise, General}.
+    """
+    graph = StateGraph(dict)
+    graph.add_node("Router", lambda state: state)
+    graph.add_node("DocQA", docqa_run)
+    graph.add_node("Summarise", summariser_run)
+    graph.add_node("General", general_run)
+    graph.set_entry_point("Router")
+    graph.add_conditional_edges("Router", decide_next, {
+        "DocQA": "DocQA",
+        "Summarise": "Summarise",
+        "General": "General"
+    })
+    graph.set_finish_point("DocQA")
+    graph.set_finish_point("Summarise")
+    graph.set_finish_point("General")
+    return graph.compile()
 
 def get_file_path_tab6(file):
     if isinstance(file, str):
-        print("DEBUG: File is a string:", file)
         if os.path.exists(file):
-            print("DEBUG: File exists:", file)
             return file
         else:
-            print("DEBUG: File does not exist:", file)
             return None
     elif isinstance(file, dict):
-        print("DEBUG: File is a dict:", file)
         data = file.get("data")
         name = file.get("name")
-        print("DEBUG: Data:", data, "Name:", name)
         if data:
             if isinstance(data, str) and os.path.exists(data):
-                print("DEBUG: Data is a valid file path:", data)
                 return data
             else:
                 temp_dir = mkdtemp()
                 file_path = os.path.join(temp_dir, name if name else "uploaded_file")
-                print("DEBUG: Writing data to temporary file:", file_path)
                 with open(file_path, "wb") as f:
                     if isinstance(data, str):
                         f.write(data.encode("utf-8"))
                     else:
                         f.write(data)
-                if os.path.exists(file_path):
-                    print("DEBUG: Temporary file created:", file_path)
-                    return file_path
-                else:
-                    print("ERROR: Temporary file not created:", file_path)
-                    return None
+                return file_path if os.path.exists(file_path) else None
         else:
-            print("DEBUG: No data in dict, returning None")
             return None
     elif hasattr(file, "save"):
-        print("DEBUG: File has save attribute")
         temp_dir = mkdtemp()
         file_path = os.path.join(temp_dir, file.name)
         file.save(file_path)
-        if os.path.exists(file_path):
-            print("DEBUG: File saved to:", file_path)
-            return file_path
-        else:
-            print("ERROR: File not saved properly:", file_path)
-            return None
+        return file_path if os.path.exists(file_path) else None
     else:
-        print("DEBUG: File type unrecognized")
-        if hasattr(file, "name"):
-            if os.path.exists(file.name):
-                return file.name
+        if hasattr(file, "name") and os.path.exists(file.name):
+            return file.name
         return None
 
-@traceable(name="multi_doc")       
+@traceable(name="multi_doc")
 def langgraph_tab6_main(query: str, file=None):
+    """
+    Main entrypoint for Tab 6.
+    1. If no file: call general_run.
+    2. Load one or more docs, chunk them.
+    3. Initialize Pinecone index 'Rag_Docs' with dimension=768, metric=cosine.
+    4. Upsert chunks into Pinecone under namespace 'Rag_Docs'.
+    5. Build retriever and ConversationalRetrievalChain.
+    6. If multi‐doc or comparison query → autogen_multi_document_analysis.
+    7. Else route through LangGraph pipeline.
+    """
     try:
-        print(f"DEBUG: Starting processing with query: {query}")
-        
-        # If no file is uploaded, directly use general_run
         if not file:
             return general_run({"query": query})["answer"]
-        
-        # Process list of files
+
+        # prepare file list and load content
         files = file if isinstance(file, list) else [file]
-        all_docs = []
-        file_names = []
-        docs_by_file = []
-        
-        # Process each uploaded file
+        all_docs, file_names, docs_text = [], [], []
         for f in files:
-            try:
-                path = get_file_path_tab6(f)
-                if not path:
-                    continue
-                
-                file_names.append(os.path.basename(path))
-                
-                # Choose loader based on file type
-                if path.lower().endswith('.pdf'):
-                    loader = PyPDFLoader(path)
-                elif path.lower().endswith('.docx'):
-                    loader = UnstructuredWordDocumentLoader(path)
-                else:
-                    loader = TextLoader(path)
-                
-                docs = loader.load()
-                if docs:
-                    text = "\n".join(doc.page_content for doc in docs if hasattr(doc, 'page_content'))
-                    docs_by_file.append(text)
-                    all_docs.extend(docs)
-            except Exception as e:
-                print(f"ERROR processing file: {str(e)}")
-                continue
-
-        if not docs_by_file:
+            path = get_file_path_tab6(f)
+            if not path: continue
+            file_names.append(os.path.basename(path))
+            loader = (PyPDFLoader if path.endswith(".pdf") else
+                      UnstructuredWordDocumentLoader if path.endswith(".docx") else
+                      TextLoader)(path)
+            docs = loader.load()
+            if docs:
+                docs_text.append("\n".join(d.page_content for d in docs))
+                all_docs.extend(docs)
+
+        if not docs_text:
             return general_run({"query": query})["answer"]
 
-        # Build the retriever using Pinecone instead of FAISS, with fixed index name and namespace "Rag_Docs"
-        try:
-            import pinecone
-            # Initialize Pinecone (ensure the environment variables PINECONE_API_KEY and PINECONE_ENVIRONMENT are set)
-            pinecone.init(
-                api_key=os.getenv("PINECONE_API_KEY"),
-                environment=os.getenv("PINECONE_ENVIRONMENT")
-            )
-            
-            # Use fixed index name "Rag_Docs" as configured in your Pinecone account
-            index_name = "Rag_Docs"
-            # Check if the index exists; if not, create it with the appropriate dimension (768 for all-mpnet-base-v2)
-            if index_name not in pinecone.list_indexes():
-                pinecone.create_index(
-                    name=index_name,
-                    dimension=768,  # Ensure the embedding model dimension matches; for all-mpnet-base-v2, it is 768
-                    metric="cosine"
-                )
-            
-            # Split documents into chunks for finer retrieval
-            chunks = RecursiveCharacterTextSplitter(
-                chunk_size=500,
-                chunk_overlap=50
-            ).split_documents(all_docs)
-            
-            # Create or update the Pinecone index from the document chunks using a fixed namespace "Rag_Docs"
-            vectorstore = Pinecone.from_documents(
-                documents=chunks,
-                embedding=embeddings,
-                index_name=index_name,
-                namespace="Rag_Docs"  # 固定使用 "Rag_Docs" 作為 namespace，與你的 Pinecone 介面設定一致
-            )
-            
-            # Create the retriever from the vector store
-            retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
-            
-            global session_retriever, session_qa_chain
-            session_retriever = retriever
-            session_qa_chain = ConversationalRetrievalChain.from_llm(
-                llm=llm_gpt4,
-                retriever=retriever,
-                memory=ConversationBufferMemory(
-                    memory_key="chat_history",
-                    return_messages=True
-                ),
-            )
-        except Exception as e:
-            print(f"ERROR setting up Pinecone retriever: {str(e)}")
-            retriever = None
-
-        # If the query is a multi-document query or a complex query, use AutoGen collaboration
-        if len(docs_by_file) > 1 or "compare" in query.lower() or "relation" in query.lower():
-            return autogen_multi_document_analysis(query, docs_by_file, file_names)
-            
-        # Use LangGraph to process single-document queries
-        state = {
-            "query": query,
-            "file_names": file_names,
-            "docs": docs_by_file,
-            "retriever": retriever
-        }
-        
-        # Choose processing method based on query intent
-        intent = detect_intent_embedding(query, file_names)
-        if intent == "Summarise":
-            return summariser_run(state)["summary"]
-        elif intent == "DocQA":
-            return docqa_run(state)["answer"]
-        else:
-            return general_run(state)["answer"]
-        
+        # initialize Pinecone
+        import pinecone
+        pinecone.init(api_key=os.getenv("PINECONE_API_KEY"),
+                     environment=os.getenv("PINECONE_ENVIRONMENT"))
+        index_name = "Rag_Docs"
+        if index_name not in pinecone.list_indexes():
+            pinecone.create_index(name=index_name, dimension=768, metric="cosine")
+
+        # chunk documents and upsert into Pinecone
+        chunks = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50).split_documents(all_docs)
+        vectorstore = Pinecone.from_documents(
+            documents=chunks,
+            embedding=embeddings,
+            index_name=index_name,
+            namespace="Rag_Docs"
+        )
+        retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+
+        # set up conversational chain
+        global session_retriever, session_qa_chain
+        session_retriever = retriever
+        session_qa_chain = ConversationalRetrievalChain.from_llm(
+            llm=llm_gpt4,
+            retriever=retriever,
+            memory=ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+        )
+
+        # if multi‐doc or comparison request, hand off to AutoGen
+        if len(docs_text) > 1 or "compare" in query.lower() or "relation" in query.lower():
+            return autogen_multi_document_analysis(query, docs_text, file_names)
+
+        # otherwise, run through LangGraph
+        state = {"query": query, "file_names": file_names, "docs": docs_text, "retriever": retriever}
+        pipeline = build_langgraph_pipeline()
+        out = pipeline.invoke(state)
+        return out.get("answer") or out.get("summary")
+
     except Exception as e:
-        print(f"ERROR in main function: {str(e)}")
-        return f"I apologize, but I encountered an error: {str(e)}"
+        print(f"ERROR in Tab6 main: {e}")
+        return f"Sorry, an error occurred: {e}"
 
 # Gradio Interface Settings
 demo_description = """