Update app.py

app.py

@@ -1,6 +1,3 @@
-# ------------------------------
-# UniversalResearch AI with LADDER (OpenAI Integration)
-# ------------------------------
 import logging
 import os
 import re
@@ -11,12 +8,11 @@ import sys
 from datetime import datetime
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import List, Dict, Any, Optional, Sequence
-
 import chromadb
 import requests
 import streamlit as st
 
-# LangChain & LangGraph imports
+# LangChain and LangGraph imports
 from langchain_openai import OpenAIEmbeddings
 from langchain_community.vectorstores import Chroma
 from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
@@ -27,7 +23,7 @@ from langgraph.graph.message import add_messages
 from typing_extensions import TypedDict, Annotated
 from langchain.tools.retriever import create_retriever_tool
 
-# Increase Python's recursion limit at the start (if needed)
+# Increase Python's recursion limit at the very start (if needed)
 sys.setrecursionlimit(10000)
 
 # ------------------------------
@@ -43,12 +39,6 @@ logger = logging.getLogger(__name__)
 # State Schema Definition
 # ------------------------------
 class AgentState(TypedDict):
-    """
-    Stores the messages and context for each step in the workflow.
-    'messages': conversation so far
-    'context': domain-specific data (docs, counters)
-    'metadata': any additional info (timestamps, status)
-    """
     messages: Annotated[Sequence[AIMessage | HumanMessage | ToolMessage], add_messages]
     context: Dict[str, Any]
     metadata: Dict[str, Any]
@@ -57,56 +47,46 @@ class AgentState(TypedDict):
 # Configuration
 # ------------------------------
 class ResearchConfig:
-    """
-    Universal config for the advanced AI system with Tufa Labs' LADDER approach,
-    using OpenAI for both embeddings and completions.
-
-    Make sure to set OPENAI_API_KEY in your environment or HF Space secrets.
-    """
-    OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")  # Must match your HF secret name
+    DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY")
     CHROMA_PATH = "chroma_db"
     CHUNK_SIZE = 512
     CHUNK_OVERLAP = 64
     MAX_CONCURRENT_REQUESTS = 5
     EMBEDDING_DIMENSIONS = 1536
-
-    # Example map for featured documents
     DOCUMENT_MAP = {
-        "Sample Research Document 1": "Topic A Overview",
-        "Sample Research Document 2": "Topic B Analysis",
-        "Sample Research Document 3": "Topic C Innovations"
+        "Research Report: Results of a New AI Model Improving Image Recognition Accuracy to 98%":
+            "CV-Transformer Hybrid Architecture",
+        "Academic Paper Summary: Why Transformers Became the Mainstream Architecture in Natural Language Processing":
+            "Transformer Architecture Analysis",
+        "Latest Trends in Machine Learning Methods Using Quantum Computing":
+            "Quantum ML Frontiers"
     }
-
-    # Analysis template referencing LADDER's approach
     ANALYSIS_TEMPLATE = (
-        "Analyze the following research documents with scientific rigor:\n{context}\n\n"
-        "Use Tufa Labs’ LADDER method to:\n"
-        "1. Break down complex problems into subproblems.\n"
-        "2. Iteratively refine the solution.\n"
-        "3. Provide analysis including:\n"
-        "   a. Key Contributions\n"
-        "   b. Novel Methodologies\n"
-        "   c. Empirical Results (with metrics)\n"
-        "   d. Potential Applications\n"
-        "   e. Limitations & Future Directions\n\n"
-        "Format your response in Markdown with LaTeX where applicable."
+        "Analyze these technical documents with scientific rigor:\n{context}\n\n"
+        "Respond with:\n"
+        "1. Key Technical Contributions (bullet points)\n"
+        "2. Novel Methodologies\n"
+        "3. Empirical Results (with metrics)\n"
+        "4. Potential Applications\n"
+        "5. Limitations & Future Directions\n\n"
+        "Format: Markdown with LaTeX mathematical notation where applicable"
     )
 
-# Early check for missing API key
-if not ResearchConfig.OPENAI_API_KEY:
+if not ResearchConfig.DEEPSEEK_API_KEY:
     st.error(
-        """**OpenAI API Key Not Found**  
-Please set `OPENAI_API_KEY` in your Space secrets and rebuild the Space."""
+        """**Research Portal Configuration Required**  
+1. Obtain DeepSeek API key: [platform.deepseek.com](https://platform.deepseek.com/)  
+2. Configure secret: `DEEPSEEK_API_KEY` in Space settings  
+3. Rebuild deployment"""
     )
     st.stop()
 
 # ------------------------------
-# Universal Document Processing
+# Quantum Document Processing
 # ------------------------------
-class UniversalDocumentManager:
+class QuantumDocumentManager:
     """
-    Manages creation of document collections for any research domain,
-    using OpenAI embeddings for semantic search.
+    Manages creation of Chroma collections from raw document texts.
     """
     def __init__(self) -> None:
         try:
@@ -115,8 +95,6 @@ class UniversalDocumentManager:
         except Exception as e:
             logger.error(f"Error initializing PersistentClient: {e}")
             self.client = chromadb.Client()  # Fallback to in-memory client
-
-        # Configure embeddings from openai
         self.embeddings = OpenAIEmbeddings(
             model="text-embedding-3-large",
             dimensions=ResearchConfig.EMBEDDING_DIMENSIONS
@@ -124,7 +102,7 @@ class UniversalDocumentManager:
 
     def create_collection(self, documents: List[str], collection_name: str) -> Chroma:
         """
-        Splits documents into chunks and stores them in a Chroma collection.
+        Splits documents into chunks and stores them as a Chroma collection.
         """
         splitter = RecursiveCharacterTextSplitter(
             chunk_size=ResearchConfig.CHUNK_SIZE,
@@ -133,7 +111,7 @@ class UniversalDocumentManager:
         )
         try:
             docs = splitter.create_documents(documents)
-            logger.info(f"Created {len(docs)} doc chunks for collection '{collection_name}'.")
+            logger.info(f"Created {len(docs)} document chunks for collection '{collection_name}'.")
         except Exception as e:
             logger.error(f"Error splitting documents: {e}")
             raise e
@@ -148,22 +126,22 @@ class UniversalDocumentManager:
 
     def _document_id(self, content: str) -> str:
         """
-        Generates a unique ID using SHA256 + timestamp.
+        Generates a unique document ID using SHA256 and the current timestamp.
         """
         return f"{hashlib.sha256(content.encode()).hexdigest()[:16]}-{int(time.time())}"
 
-# Example collections (replace with your own)
-udm = UniversalDocumentManager()
-research_docs = udm.create_collection([
-    "Research Report: Novel AI Techniques in Renewable Energy",
-    "Academic Paper: Advances in Quantum Computing for Data Analysis",
-    "Survey: Emerging Trends in Biomedical Research"
+# Initialize document collections
+qdm = QuantumDocumentManager()
+research_docs = qdm.create_collection([
+    "Research Report: Results of a New AI Model Improving Image Recognition Accuracy to 98%",
+    "Academic Paper Summary: Why Transformers Became the Mainstream Architecture in Natural Language Processing",
+    "Latest Trends in Machine Learning Methods Using Quantum Computing"
 ], "research")
 
-development_docs = udm.create_collection([
-    "Project Update: New Algorithms in Software Engineering",
-    "Development Report: Innovations in User Interface Design",
-    "Case Study: Agile Methodologies in Large-Scale Software Projects"
+development_docs = qdm.create_collection([
+    "Project A: UI Design Completed, API Integration in Progress",
+    "Project B: Testing New Feature X, Bug Fixes Needed",
+    "Product Y: In the Performance Optimization Stage Before Release"
 ], "development")
 
 # ------------------------------
@@ -171,8 +149,7 @@ development_docs = udm.create_collection([
 # ------------------------------
 class ResearchRetriever:
     """
-    Provides retrieval methods for multiple domains (e.g., research, development).
-    Uses MMR or similarity-based retrieval from Chroma.
+    Provides retrieval methods for different domains.
     """
     def __init__(self) -> None:
         try:
@@ -191,8 +168,7 @@ class ResearchRetriever:
 
     def retrieve(self, query: str, domain: str) -> List[Any]:
         """
-        Retrieves documents for a given query and domain.
-        Defaults to 'research' if domain is unrecognized.
+        Retrieves documents based on the query and domain.
         """
         try:
             if domain == "research":
@@ -200,8 +176,8 @@ class ResearchRetriever:
             elif domain == "development":
                 return self.development_retriever.invoke(query)
             else:
-                logger.warning(f"Domain '{domain}' not recognized. Defaulting to 'research'.")
-                return self.research_retriever.invoke(query)
+                logger.warning(f"Domain '{domain}' not recognized.")
+                return []
         except Exception as e:
             logger.error(f"Retrieval error for domain '{domain}': {e}")
             return []
@@ -213,8 +189,8 @@ retriever = ResearchRetriever()
 # ------------------------------
 class CognitiveProcessor:
     """
-    Executes requests to the OpenAI Chat Completions endpoint in parallel,
-    then consolidates the results using a consensus mechanism (picks the longest).
+    Executes API requests to the DeepSeek backend using triple redundancy
+    and consolidates results via a consensus mechanism.
     """
     def __init__(self) -> None:
         self.executor = ThreadPoolExecutor(max_workers=ResearchConfig.MAX_CONCURRENT_REQUESTS)
@@ -222,10 +198,10 @@ class CognitiveProcessor:
 
     def process_query(self, prompt: str) -> Dict:
         """
-        Sends multiple parallel requests (triple redundancy) to OpenAI's ChatCompletion.
+        Processes a query by sending multiple API requests in parallel.
         """
         futures = []
-        for _ in range(3):
+        for _ in range(3):  # Triple redundancy for reliability
             futures.append(self.executor.submit(self._execute_api_request, prompt))
 
         results = []
@@ -240,63 +216,53 @@ class CognitiveProcessor:
 
     def _execute_api_request(self, prompt: str) -> Dict:
         """
-        Executes a single request to OpenAI's ChatCompletion endpoint.
+        Executes a single API request to the DeepSeek endpoint.
         """
-        # Use your OPENAI_API_KEY
         headers = {
-            "Authorization": f"Bearer {ResearchConfig.OPENAI_API_KEY}",
-            "Content-Type": "application/json"
+            "Authorization": f"Bearer {ResearchConfig.DEEPSEEK_API_KEY}",
+            "Content-Type": "application/json",
+            "X-Research-Session": self.session_id
         }
         payload = {
-            "model": "gpt-3.5-turbo",  # or "gpt-4", depending on your account
-            "messages": [
-                {
-                    "role": "user",
-                    "content": prompt
-                }
-            ],
+            "model": "deepseek-chat",
+            "messages": [{
+                "role": "user",
+                "content": f"Respond as Senior AI Researcher:\n{prompt}"
+            }],
             "temperature": 0.7,
             "max_tokens": 1500,
             "top_p": 0.9
         }
         try:
             response = requests.post(
-                "https://api.openai.com/v1/chat/completions",
+                "https://api.deepseek.com/v1/chat/completions",
                 headers=headers,
                 json=payload,
                 timeout=45
             )
             response.raise_for_status()
-            logger.info("OpenAI ChatCompletion request successful.")
+            logger.info("DeepSeek API request successful.")
             return response.json()
         except requests.exceptions.RequestException as e:
-            logger.error(f"OpenAI request failed: {e}")
+            logger.error(f"DeepSeek API request failed: {e}")
             return {"error": str(e)}
 
     def _consensus_check(self, results: List[Dict]) -> Dict:
         """
-        Chooses the 'best' response by comparing content lengths, discarding errors.
+        Consolidates multiple API responses, selecting the one with the most content.
         """
-        valid = [r for r in results if "error" not in r]
-        if not valid:
+        valid_results = [r for r in results if "error" not in r]
+        if not valid_results:
             logger.error("All API requests failed.")
             return {"error": "All API requests failed"}
-        return max(valid, key=lambda x: len(x.get('choices', [{}])[0].get('message', {}).get('content', '')))
+        return max(valid_results, key=lambda x: len(x.get('choices', [{}])[0].get('message', {}).get('content', '')))
 
 # ------------------------------
-# Research Workflow Engine (Tufa Labs' LADDER)
+# Research Workflow Engine
 # ------------------------------
 class ResearchWorkflow:
     """
-    Defines a multi-step workflow using LangGraph with Tufa Labs’ LADDER approach:
-    1. Ingest Query
-    2. Retrieve Documents
-    3. Analyze Content
-    4. Validate Output
-    5. Refine (Recursive Self-Learning)
-    
-    The refine step uses iterative subproblem breakdown, 
-    potentially combined with test-time reinforcement.
+    Defines the multi-step research workflow using a state graph.
     """
     def __init__(self) -> None:
         self.processor = CognitiveProcessor()
@@ -305,14 +271,13 @@ class ResearchWorkflow:
         self.app = self.workflow.compile()
 
     def _build_workflow(self) -> None:
-        # Node definitions
+        # Define nodes
         self.workflow.add_node("ingest", self.ingest_query)
         self.workflow.add_node("retrieve", self.retrieve_documents)
         self.workflow.add_node("analyze", self.analyze_content)
         self.workflow.add_node("validate", self.validate_output)
         self.workflow.add_node("refine", self.refine_results)
-
-        # Graph edges
+        # Set entry point and edges
         self.workflow.set_entry_point("ingest")
         self.workflow.add_edge("ingest", "retrieve")
         self.workflow.add_edge("retrieve", "analyze")
@@ -326,10 +291,11 @@ class ResearchWorkflow:
 
     def ingest_query(self, state: AgentState) -> Dict:
         """
-        Ingest the user query and initialize the refine counter for LADDER recursion.
+        Ingests the research query and initializes the refinement counter.
         """
         try:
             query = state["messages"][-1].content
+            # Initialize context with raw query and refinement counter
             new_context = {"raw_query": query, "refine_count": 0}
             logger.info("Query ingested.")
             return {
@@ -338,11 +304,11 @@ class ResearchWorkflow:
                 "metadata": {"timestamp": datetime.now().isoformat()}
             }
         except Exception as e:
-            return self._error_state(f"Ingestion Error: {e}")
+            return self._error_state(f"Ingestion Error: {str(e)}")
 
     def retrieve_documents(self, state: AgentState) -> Dict:
         """
-        Retrieves relevant documents from the specified domain (default: research).
+        Retrieves research documents based on the query.
         """
         try:
             query = state["context"]["raw_query"]
@@ -350,19 +316,14 @@ class ResearchWorkflow:
             logger.info(f"Retrieved {len(docs)} documents for query.")
             return {
                 "messages": [AIMessage(content=f"Retrieved {len(docs)} documents")],
-                "context": {
-                    "documents": docs,
-                    "retrieval_time": time.time(),
-                    "refine_count": state["context"].get("refine_count", 0)
-                }
+                "context": {"documents": docs, "retrieval_time": time.time(), "refine_count": state["context"].get("refine_count", 0)}
             }
         except Exception as e:
-            return self._error_state(f"Retrieval Error: {e}")
+            return self._error_state(f"Retrieval Error: {str(e)}")
 
     def analyze_content(self, state: AgentState) -> Dict:
         """
-        Uses the LADDER approach to break down and analyze documents,
-        returning a structured research analysis.
+        Analyzes the retrieved documents using the DeepSeek API.
         """
         try:
             docs = state["context"].get("documents", [])
@@ -371,82 +332,66 @@ class ResearchWorkflow:
             response = self.processor.process_query(prompt)
             if "error" in response:
                 return self._error_state(response["error"])
-            logger.info("Analysis completed.")
+            logger.info("Content analysis completed.")
             return {
-                "messages": [
-                    AIMessage(content=response.get('choices', [{}])[0].get('message', {}).get('content', ''))
-                ],
-                "context": {
-                    "analysis": response,
-                    "refine_count": state["context"].get("refine_count", 0)
-                }
+                "messages": [AIMessage(content=response.get('choices', [{}])[0].get('message', {}).get('content', ''))],
+                "context": {"analysis": response, "refine_count": state["context"].get("refine_count", 0)}
             }
         except Exception as e:
-            return self._error_state(f"Analysis Error: {e}")
+            return self._error_state(f"Analysis Error: {str(e)}")
 
     def validate_output(self, state: AgentState) -> Dict:
         """
-        Validates the analysis. If invalid, the system can refine 
-        using Tufa Labs’ LADDER approach.
+        Validates the technical analysis report.
         """
         analysis = state["messages"][-1].content
         validation_prompt = (
-            f"Validate this analysis:\n{analysis}\n\n"
+            f"Validate research analysis:\n{analysis}\n\n"
             "Check for:\n1. Technical accuracy\n2. Citation support\n3. Logical consistency\n4. Methodological soundness\n\n"
-            "Respond with 'VALID' or 'INVALID'."
+            "Respond with 'VALID' or 'INVALID'"
         )
         response = self.processor.process_query(validation_prompt)
-        logger.info("Validation completed.")
+        logger.info("Output validation completed.")
         return {
-            "messages": [
-                AIMessage(
-                    content=analysis + f"\n\nValidation: {response.get('choices', [{}])[0].get('message', {}).get('content', '')}"
-                )
-            ]
+            "messages": [AIMessage(content=analysis + f"\n\nValidation: {response.get('choices', [{}])[0].get('message', {}).get('content', '')}")]
         }
 
     def refine_results(self, state: AgentState) -> Dict:
         """
-        LADDER refinement: break down subproblems, re-solve them 
-        with no external data, potentially using TTRL for dynamic updates.
+        Refines the analysis report if validation fails.
+        Increments the refinement counter to limit infinite loops.
         """
         current_count = state["context"].get("refine_count", 0)
         state["context"]["refine_count"] = current_count + 1
-        logger.info(f"LADDER refinement iteration: {state['context']['refine_count']}")
-
+        logger.info(f"Refinement iteration: {state['context']['refine_count']}")
         refinement_prompt = (
-            "Refine this analysis with LADDER’s self-improvement approach:\n"
-            f"{state['messages'][-1].content}\n\n"
-            "Break down complex points further, re-solve them, and enhance:\n"
-            "- Technical precision\n- Empirical grounding\n- Theoretical coherence"
+            f"Refine this analysis:\n{state['messages'][-1].content}\n\n"
+            "Improve:\n1. Technical precision\n2. Empirical grounding\n3. Theoretical coherence"
         )
         response = self.processor.process_query(refinement_prompt)
         logger.info("Refinement completed.")
         return {
-            "messages": [
-                AIMessage(
-                    content=response.get('choices', [{}])[0].get('message', {}).get('content', '')
-                )
-            ],
+            "messages": [AIMessage(content=response.get('choices', [{}])[0].get('message', {}).get('content', ''))],
             "context": state["context"]
         }
 
     def _quality_check(self, state: AgentState) -> str:
         """
-        Checks if the analysis is valid. If the refine_count >= 3,
-        forcibly accept to avoid infinite loops.
+        Checks whether the analysis report is valid.
+        Forces a valid state if the refinement count exceeds a threshold.
         """
         refine_count = state["context"].get("refine_count", 0)
         if refine_count >= 3:
-            logger.warning("Refinement limit reached. Forcing valid outcome.")
+            logger.warning("Refinement limit reached. Forcing valid outcome to prevent infinite recursion.")
             return "valid"
-
         content = state["messages"][-1].content
-        return "valid" if "VALID" in content else "invalid"
+        quality = "valid" if "VALID" in content else "invalid"
+        logger.info(f"Quality check returned: {quality}")
+        return quality
 
     def _error_state(self, message: str) -> Dict:
         """
-        Returns an error state if any node fails.
+        Returns a standardized error state.
         """
         logger.error(message)
         return {
@@ -456,12 +401,11 @@ class ResearchWorkflow:
         }
 
 # ------------------------------
-# Streamlit UI
+# Research Interface (Streamlit UI)
 # ------------------------------
 class ResearchInterface:
     """
-    Provides a Streamlit-based interface for the UniversalResearch AI 
-    with Tufa Labs' LADDER approach, using OpenAI for both embeddings & completions.
+    Provides the Streamlit-based interface for executing the research workflow.
     """
     def __init__(self) -> None:
         self.workflow = ResearchWorkflow()
@@ -469,7 +413,7 @@ class ResearchInterface:
 
     def _initialize_interface(self) -> None:
         st.set_page_config(
-            page_title="UniversalResearch AI (OpenAI + LADDER)",
+            page_title="NeuroResearch AI",
             layout="wide",
             initial_sidebar_state="expanded"
         )
@@ -523,8 +467,8 @@ class ResearchInterface:
 
     def _build_sidebar(self) -> None:
         with st.sidebar:
-            st.title("🔍 Research Database (LADDER)")
-            st.subheader("Featured Research Topics")
+            st.title("🔍 Research Database")
+            st.subheader("Technical Papers")
             for title, short in ResearchConfig.DOCUMENT_MAP.items():
                 with st.expander(short):
                     st.markdown(f"```\n{title}\n```")
@@ -533,22 +477,19 @@ class ResearchInterface:
             st.metric("Embedding Dimensions", ResearchConfig.EMBEDDING_DIMENSIONS)
 
     def _build_main_interface(self) -> None:
-        st.title("🧠 UniversalResearch AI")
-        st.write(
-            "This system uses OpenAI for embeddings & completions"
-        )
+        st.title("🧠 NeuroResearch AI")
         query = st.text_area(
             "Research Query:",
             height=200,
-            placeholder="Enter a research question (e.g., advanced math, code tasks, etc.)..."
+            placeholder="Enter technical research question..."
         )
         if st.button("Execute Analysis", type="primary"):
             self._execute_analysis(query)
 
     def _execute_analysis(self, query: str) -> None:
         try:
-            with st.spinner("Initializing LADDER-based Analysis..."):
-                # The recursion_limit ensures multiple refine iterations are possible
+            with st.spinner("Initializing Quantum Analysis..."):
+                # Pass a recursion limit configuration into the graph invocation
                 results = self.workflow.app.stream({
                     "messages": [HumanMessage(content=query)],
                     "context": {},
@@ -565,14 +506,10 @@ class ResearchInterface:
 Potential issues:
 - Complex query structure
 - Document correlation failure
-- Rate limits or invalid API key
 - Temporal processing constraints"""
             )
 
     def _render_event(self, event: Dict) -> None:
-        """
-        Renders each event in the Streamlit UI, from ingestion to validation/refinement.
-        """
         if 'ingest' in event:
             with st.container():
                 st.success("✅ Query Ingested")
@@ -587,7 +524,7 @@ Potential issues:
         elif 'analyze' in event:
             with st.container():
                 content = event['analyze']['messages'][0].content
-                with st.expander("Research Analysis Report", expanded=True):
+                with st.expander("Technical Analysis Report", expanded=True):
                     st.markdown(content)
         elif 'validate' in event:
             with st.container():
@@ -595,7 +532,6 @@ Potential issues:
                 if "VALID" in content:
                     st.success("✅ Validation Passed")
                     with st.expander("View Validated Analysis", expanded=True):
-                        # Hide "Validation: ..." from final output
                         st.markdown(content.split("Validation:")[0])
                 else:
                     st.warning("⚠️ Validation Issues Detected")