Update app.py

app.py

@@ -1232,270 +1232,417 @@ def multi_agent_chat_advanced(query: str, file=None) -> str:
     except Exception as e:
         return f"Multi-Agent Error: {e}"
 
-# === Tab 6: Smart Multi‐Document QA (LangGraph + AutoGen + Pinecone Retriever) ===
-
-# Initialize the sentence‐transformer embedding model
+# Tab 6
+# LangGraph node functions
+# Initialize the embedding model
 embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
 
-# Define intent labels and example phrases for embedding‐based routing
+# Intent embedding classification (supports file names)
 INTENT_LABELS = {
-    "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"],
+    "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"],
 }
 
+# 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, best_score = None, -1.0
-    # include file names as additional examples for DocQA
-    phrases = { **INTENT_LABELS }
+    best_label = None
+    best_score = -1
+    all_phrases = INTENT_LABELS.copy()
     if file_names:
-        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)
+        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)
             if score > best_score:
-                best_label, best_score = label, score
-    return best_label or "General"
-
-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
+                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:
-    """
-    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
-    )
+    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)
+        )
 
-    # 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)
+        # 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
+            )
 
-    # build the task prompt
-    prompt = f"""Analyze these documents and answer the query:
+            # 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
+            )
 
-Query: {query}
+            # 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
+            )
 
-Documents Context:
-{context}
+            # 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
+            )
 
-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"]
+            # Create group chat
+            groupchat = GroupChat(
+                agents=[user_proxy, doc_analyzer, qa_expert, summarizer],
+                messages=[],
+                max_round=5
+            )
+
+            # 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
+
+    except Exception as e:
+        print(f"ERROR in AutoGen processing: {str(e)}")
+        return f"Error analyzing documents: {str(e)}"
+
+
+
+def decide_next(state):
+    query = state.get("query", "")
+    file_names = state.get("file_names", [])
+    label = detect_intent_embedding(query, file_names)
+    return label
+
+
+# === LangGraph Node Functions ===
 
 def general_run(state):
-    """
-    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))}
+    """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."}
 
 def docqa_run(state):
-    """
-    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"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))}
+    """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):
-    """
-    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))}
-
+    """Document summarisation processing."""
+    try:
+        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."}
+        
 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("Router", lambda state: state)  # Router 僅傳遞狀態
     graph.add_node("DocQA", docqa_run)
-    graph.add_node("Summarise", summariser_run)
     graph.add_node("General", general_run)
+    graph.add_node("Summarise", summariser_run)
     graph.set_entry_point("Router")
     graph.add_conditional_edges("Router", decide_next, {
         "DocQA": "DocQA",
+        "General": "General",
         "Summarise": "Summarise",
-        "General": "General"
     })
     graph.set_finish_point("DocQA")
-    graph.set_finish_point("Summarise")
     graph.set_finish_point("General")
+    graph.set_finish_point("Summarise")
     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)
-                return file_path if os.path.exists(file_path) else None
+                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
         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)
-        return file_path if os.path.exists(file_path) else None
+        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
     else:
-        if hasattr(file, "name") and os.path.exists(file.name):
-            return file.name
+        print("DEBUG: File type unrecognized")
+        if hasattr(file, "name"):
+            if 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"]
-
-        # prepare file list and load content
+        
+        # Process list of files
         files = file if isinstance(file, list) else [file]
-        all_docs, file_names, docs_text = [], [], []
+        all_docs = []
+        file_names = []
+        docs_by_file = []
+        
+        # Process each uploaded file
         for f in files:
-            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"]
-
-        # 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)
-        )
+            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 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)
+        if not docs_by_file:
+            return general_run({"query": query})["answer"]
 
-        # otherwise, run through LangGraph
-        state = {"query": query, "file_names": file_names, "docs": docs_text, "retriever": retriever}
+        # Build the retriever using Pinecone
+        try:
+            import pinecone
+            # Initialize 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"
+                )
+            
+            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})
+            
+            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)
+            
+        # 使用 LangGraph 處理單文檔查詢 — 修改這部分來使用 LangGraph
+        state = {
+            "query": query,
+            "file_names": file_names,
+            "docs": docs_by_file,
+            "retriever": retriever
+        }
+        
+        # 獲取 LangGraph 編譯後的管道
         pipeline = build_langgraph_pipeline()
-        out = pipeline.invoke(state)
-        return out.get("answer") or out.get("summary")
-
+        
+        # 調用 LangGraph 處理狀態
+        result = pipeline.invoke(state)
+        
+        # 從結果中提取答案或摘要
+        if "answer" in result:
+            return result["answer"]
+        elif "summary" in result:
+            return result["summary"]
+        else:
+            return "Processing completed but no specific answer or summary was generated."
+        
     except Exception as e:
-        print(f"ERROR in Tab6 main: {e}")
-        return f"Sorry, an error occurred: {e}"
+        print(f"ERROR in main function: {str(e)}")
+        return f"I apologize, but I encountered an error: {str(e)}"
 
 # Gradio Interface Settings
 demo_description = """