Update app.py

app.py

@@ -9,546 +9,444 @@ from langgraph.graph import END, StateGraph
 from langgraph.prebuilt import ToolNode
 from langgraph.graph.message import add_messages
 from typing_extensions import TypedDict, Annotated
-from typing import Sequence
+from typing import Sequence, Dict, List, Optional, Any
 import chromadb
 import re
 import os
 import streamlit as st
 import requests
+import hashlib
+import json
+import time
 from langchain.tools.retriever import create_retriever_tool
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+
+# ------------------------------
+# State Schema Definition
+# ------------------------------
+class AgentState(TypedDict):
+    messages: Annotated[Sequence[AIMessage | HumanMessage | ToolMessage], add_messages]
+    context: Dict[str, Any]
+    metadata: Dict[str, Any]
 
 # ------------------------------
 # Configuration
 # ------------------------------
-# Get DeepSeek API key from Hugging Face Space secrets
-DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY")
+class ResearchConfig:
+    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
+    DOCUMENT_MAP = {
+        "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 = """Analyze these technical documents with scientific rigor:
+{context}
 
-if not DEEPSEEK_API_KEY:
-    st.error("""
-    **Missing API Configuration**  
-    Please configure your DeepSeek API key in Hugging Face Space secrets:
-    1. Go to your Space's Settings
-    2. Click on 'Repository secrets'
-    3. Add a secret named DEEPSEEK_API_KEY
-    """)
-    st.stop()
+Respond with:
+1. Key Technical Contributions (bullet points)
+2. Novel Methodologies
+3. Empirical Results (with metrics)
+4. Potential Applications
+5. Limitations & Future Directions
 
-# Create directory for Chroma persistence
-os.makedirs("chroma_db", exist_ok=True)
+Format: Markdown with LaTeX mathematical notation where applicable
+"""
 
-# ------------------------------
-# ChromaDB Client Configuration
-# ------------------------------
-chroma_client = chromadb.PersistentClient(path="chroma_db")
+# Validation
+if not ResearchConfig.DEEPSEEK_API_KEY:
+    st.error("""**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()
 
 # ------------------------------
-# Dummy Data: Research & Development Texts
+# Quantum Document Processing
 # ------------------------------
-research_texts = [
+class QuantumDocumentManager:
+    def __init__(self):
+        self.client = chromadb.PersistentClient(path=ResearchConfig.CHROMA_PATH)
+        self.embeddings = OpenAIEmbeddings(
+            model="text-embedding-3-large",
+            dimensions=ResearchConfig.EMBEDDING_DIMENSIONS
+        )
+        
+    def create_collection(self, documents: List[str], collection_name: str) -> Chroma:
+        splitter = RecursiveCharacterTextSplitter(
+            chunk_size=ResearchConfig.CHUNK_SIZE,
+            chunk_overlap=ResearchConfig.CHUNK_OVERLAP,
+            separators=["\n\n", "\n", "|||"]
+        )
+        docs = splitter.create_documents(documents)
+        return Chroma.from_documents(
+            documents=docs,
+            embedding=self.embeddings,
+            client=self.client,
+            collection_name=collection_name,
+            ids=[self._document_id(doc.page_content) for doc in docs]
+        )
+    
+    def _document_id(self, content: str) -> str:
+        return f"{hashlib.sha256(content.encode()).hexdigest()[:16]}-{int(time.time())}"
+
+# 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_texts = [
+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"
-]
-
-# ------------------------------
-# Text Splitting & Document Creation
-# ------------------------------
-splitter = RecursiveCharacterTextSplitter(
-    chunk_size=300,
-    chunk_overlap=30,
-    separators=["\n\n", "\n", ". ", "! ", "? ", " "]
-)
-
-research_docs = splitter.create_documents(research_texts)
-development_docs = splitter.create_documents(development_texts)
-
-# ------------------------------
-# Creating Vector Stores with Embeddings
-# ------------------------------
-embeddings = OpenAIEmbeddings(
-    model="text-embedding-3-large",
-    # dimensions=1024  # Uncomment if needed
-)
-
-research_vectorstore = Chroma.from_documents(
-    documents=research_docs,
-    embedding=embeddings,
-    client=chroma_client,
-    collection_name="research_collection"
-)
-
-development_vectorstore = Chroma.from_documents(
-    documents=development_docs,
-    embedding=embeddings,
-    client=chroma_client,
-    collection_name="development_collection"
-)
+], "development")
 
 # ------------------------------
-# Creating Retriever Tools with MMR
+# Advanced Retrieval System
 # ------------------------------
-research_retriever = research_vectorstore.as_retriever(
-    search_type="mmr",
-    search_kwargs={
-        'k': 3,
-        'fetch_k': 10,
-        'lambda_mult': 0.7
-    }
-)
-
-development_retriever = development_vectorstore.as_retriever(
-    search_type="mmr",
-    search_kwargs={
-        'k': 3,
-        'fetch_k': 10,
-        'lambda_mult': 0.7
-    }
-)
-
-research_tool = create_retriever_tool(
-    research_retriever,
-    "research_db_tool",
-    "Search information from the research database."
-)
-
-development_tool = create_retriever_tool(
-    development_retriever,
-    "development_db_tool",
-    "Search information from the development database."
-)
+class ResearchRetriever:
+    def __init__(self):
+        self.retrievers = {
+            "research": research_docs.as_retriever(
+                search_type="mmr",
+                search_kwargs={
+                    'k': 4,
+                    'fetch_k': 20,
+                    'lambda_mult': 0.85
+                }
+            ),
+            "development": development_docs.as_retriever(
+                search_type="similarity",
+                search_kwargs={'k': 3}
+            )
+        }
+    
+    def retrieve(self, query: str, domain: str) -> List[Any]:
+        try:
+            return self.retrievers[domain].invoke(query)
+        except KeyError:
+            return []
 
-tools = [research_tool, development_tool]
+retriever = ResearchRetriever()
 
 # ------------------------------
-# Agent Function & Workflow Functions
+# Cognitive Processing Unit
 # ------------------------------
-class AgentState(TypedDict):
-    messages: Annotated[Sequence[AIMessage | HumanMessage | ToolMessage], add_messages]
-
-def agent(state: AgentState):
-    print("---CALL AGENT---")
-    messages = state["messages"]
-
-    if isinstance(messages[0], tuple):
-        user_message = messages[0][1]
-    else:
-        user_message = messages[0].content
-
-    prompt = f"""Given this user question: "{user_message}"
-If it's about research or academic topics, respond EXACTLY in this format:
-SEARCH_RESEARCH: <search terms>
-
-If it's about development status, respond EXACTLY in this format:
-SEARCH_DEV: <search terms>
-
-Otherwise, just answer directly.
-"""
-
-    headers = {
-        "Accept": "application/json",
-        "Authorization": f"Bearer {DEEPSEEK_API_KEY}",
-        "Content-Type": "application/json"
-    }
-    
-    data = {
-        "model": "deepseek-chat",
-        "messages": [{"role": "user", "content": prompt}],
-        "temperature": 0.7,
-        "max_tokens": 1024
-    }
+class CognitiveProcessor:
+    def __init__(self):
+        self.executor = ThreadPoolExecutor(max_workers=ResearchConfig.MAX_CONCURRENT_REQUESTS)
+        self.session_id = hashlib.sha256(datetime.now().isoformat().encode()).hexdigest()[:12]
     
-    try:
-        response = requests.post(
-            "https://api.deepseek.com/v1/chat/completions",
-            headers=headers,
-            json=data,
-            verify=False,
-            timeout=30
-        )
-        response.raise_for_status()
+    def process_query(self, prompt: str) -> Dict:
+        futures = []
+        for _ in range(3):  # Triple redundancy
+            futures.append(self.executor.submit(
+                self._execute_api_request,
+                prompt
+            ))
         
-        response_text = response.json()['choices'][0]['message']['content']
-        print("Raw response:", response_text)
+        results = []
+        for future in as_completed(futures):
+            try:
+                results.append(future.result())
+            except Exception as e:
+                st.error(f"Processing Error: {str(e)}")
         
-        if "SEARCH_RESEARCH:" in response_text:
-            query = response_text.split("SEARCH_RESEARCH:")[1].strip()
-            results = research_retriever.invoke(query)
-            return {"messages": [AIMessage(content=f'Action: research_db_tool\n{{"query": "{query}"}}\n\nResults: {str(results)}')]}
-
-        elif "SEARCH_DEV:" in response_text:
-            query = response_text.split("SEARCH_DEV:")[1].strip()
-            results = development_retriever.invoke(query)
-            return {"messages": [AIMessage(content=f'Action: development_db_tool\n{{"query": "{query}"}}\n\nResults: {str(results)}')]}
-
-        else:
-            return {"messages": [AIMessage(content=response_text)]}
-
-    except Exception as e:
-        error_msg = f"API Error: {str(e)}"
-        if "Insufficient Balance" in str(e):
-            error_msg += "\n\nPlease check your DeepSeek API account balance."
-        return {"messages": [AIMessage(content=error_msg)]}
-
-def simple_grade_documents(state: AgentState):
-    messages = state["messages"]
-    last_message = messages[-1]
-    print("Evaluating message:", last_message.content)
-    
-    if "Results: [Document" in last_message.content:
-        print("---DOCS FOUND, GO TO GENERATE---")
-        return "generate"
-    else:
-        print("---NO DOCS FOUND, TRY REWRITE---")
-        return "rewrite"
-
-def generate(state: AgentState):
-    print("---GENERATE FINAL ANSWER---")
-    messages = state["messages"]
-    question = messages[0].content if isinstance(messages[0], tuple) else messages[0].content
-    last_message = messages[-1]
-
-    docs = ""
-    if "Results: [" in last_message.content:
-        results_start = last_message.content.find("Results: [")
-        docs = last_message.content[results_start:]
-    print("Documents found:", docs)
-
-    headers = {
-        "Accept": "application/json",
-        "Authorization": f"Bearer {DEEPSEEK_API_KEY}",
-        "Content-Type": "application/json"
-    }
-    
-    prompt = f"""Analyze these research documents and provide structured insights:
-Question: {question}
-Documents: {docs}
-
-Format your response with:
-1. Key Findings section with bullet points
-2. Technical Innovations section
-3. Potential Applications
-4. References to source documents (Doc1, Doc2, etc.)
-
-Focus on:
-- Distilling unique insights
-- Connecting different research aspects
-- Highlighting practical implications
-"""
-    
-    data = {
-        "model": "deepseek-chat",
-        "messages": [{
-            "role": "user",
-            "content": prompt
-        }],
-        "temperature": 0.7,
-        "max_tokens": 1024
-    }
+        return self._consensus_check(results)
     
-    try:
-        print("Sending generate request to API...")
-        response = requests.post(
-            "https://api.deepseek.com/v1/chat/completions",
-            headers=headers,
-            json=data,
-            verify=False,
-            timeout=30
-        )
-        response.raise_for_status()
+    def _execute_api_request(self, prompt: str) -> Dict:
+        headers = {
+            "Authorization": f"Bearer {ResearchConfig.DEEPSEEK_API_KEY}",
+            "Content-Type": "application/json",
+            "X-Research-Session": self.session_id
+        }
         
-        response_text = response.json()['choices'][0]['message']['content']
-        print("Final Answer:", response_text)
-        return {"messages": [AIMessage(content=response_text)]}
-    except Exception as e:
-        error_msg = f"Generation Error: {str(e)}"
-        return {"messages": [AIMessage(content=error_msg)]}
-
-def rewrite(state: AgentState):
-    print("---REWRITE QUESTION---")
-    messages = state["messages"]
-    original_question = messages[0].content if len(messages) > 0 else "N/A"
-
-    headers = {
-        "Accept": "application/json",
-        "Authorization": f"Bearer {DEEPSEEK_API_KEY}",
-        "Content-Type": "application/json"
-    }
+        try:
+            response = requests.post(
+                "https://api.deepseek.com/v1/chat/completions",
+                headers=headers,
+                json={
+                    "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
+                },
+                timeout=45
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
     
-    data = {
-        "model": "deepseek-chat",
-        "messages": [{
-            "role": "user",
-            "content": f"Rewrite this question to be more specific and clearer: {original_question}"
-        }],
-        "temperature": 0.7,
-        "max_tokens": 1024
-    }
-    
-    try:
-        print("Sending rewrite request...")
-        response = requests.post(
-            "https://api.deepseek.com/v1/chat/completions",
-            headers=headers,
-            json=data,
-            verify=False,
-            timeout=30
-        )
-        response.raise_for_status()
-        
-        response_text = response.json()['choices'][0]['message']['content']
-        print("Rewritten question:", response_text)
-        return {"messages": [AIMessage(content=response_text)]}
-    except Exception as e:
-        error_msg = f"Rewrite Error: {str(e)}"
-        return {"messages": [AIMessage(content=error_msg)]}
-
-tools_pattern = re.compile(r"Action: .*")
-
-def custom_tools_condition(state: AgentState):
-    messages = state["messages"]
-    last_message = messages[-1]
-    content = last_message.content
-
-    print("Checking tools condition:", content)
-    if tools_pattern.match(content):
-        print("Moving to retrieve...")
-        return "tools"
-    print("Moving to END...")
-    return END
-
-# ------------------------------
-# Workflow Configuration using LangGraph
-# ------------------------------
-workflow = StateGraph(AgentState)
-
-# Add nodes
-workflow.add_node("agent", agent)
-retrieve_node = ToolNode(tools)
-workflow.add_node("retrieve", retrieve_node)
-workflow.add_node("rewrite", rewrite)
-workflow.add_node("generate", generate)
-
-# Set entry point
-workflow.set_entry_point("agent")
-
-# Define transitions
-workflow.add_conditional_edges(
-    "agent",
-    custom_tools_condition,
-    {
-        "tools": "retrieve",
-        END: END
-    }
-)
-
-workflow.add_conditional_edges(
-    "retrieve",
-    simple_grade_documents,
-    {
-        "generate": "generate",
-        "rewrite": "rewrite"
-    }
-)
-
-workflow.add_edge("generate", END)
-workflow.add_edge("rewrite", "agent")
-
-# Compile the workflow
-app = workflow.compile()
+    def _consensus_check(self, results: List[Dict]) -> Dict:
+        valid = [r for r in results if "error" not in r]
+        if not valid:
+            return {"error": "All API requests failed"}
+        return max(valid, key=lambda x: len(x.get('choices', [{}])[0].get('message', {}).get('content', '')))
 
 # ------------------------------
-# Processing Function
+# Research Workflow Engine
 # ------------------------------
-def process_question(user_question, app, config):
-    """Process user question through the workflow"""
-    events = []
-    for event in app.stream({"messages": [("user", user_question)]}, config):
-        events.append(event)
-    return events
+class ResearchWorkflow:
+    def __init__(self):
+        self.processor = CognitiveProcessor()
+        self.workflow = StateGraph(AgentState)
+        self._build_workflow()
+
+    def _build_workflow(self):
+        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)
+
+        self.workflow.set_entry_point("ingest")
+        self.workflow.add_edge("ingest", "retrieve")
+        self.workflow.add_edge("retrieve", "analyze")
+        self.workflow.add_conditional_edges(
+            "analyze",
+            self._quality_check,
+            {"valid": "validate", "invalid": "refine"}
+        )
+        self.workflow.add_edge("validate", END)
+        self.workflow.add_edge("refine", "retrieve")
+
+        self.app = self.workflow.compile()
+
+    def ingest_query(self, state: AgentState) -> Dict:
+        try:
+            query = state["messages"][-1].content
+            return {
+                "messages": [AIMessage(content="Query ingested successfully")],
+                "context": {"raw_query": query},
+                "metadata": {"timestamp": datetime.now().isoformat()}
+            }
+        except Exception as e:
+            return self._error_state(f"Ingestion Error: {str(e)}")
+
+    def retrieve_documents(self, state: AgentState) -> Dict:
+        try:
+            query = state["context"]["raw_query"]
+            docs = retriever.retrieve(query, "research")
+            return {
+                "messages": [AIMessage(content=f"Retrieved {len(docs)} documents")],
+                "context": {
+                    "documents": docs,
+                    "retrieval_time": time.time()
+                }
+            }
+        except Exception as e:
+            return self._error_state(f"Retrieval Error: {str(e)}")
+
+    def analyze_content(self, state: AgentState) -> Dict:
+        try:
+            docs = "\n\n".join([d.page_content for d in state["context"]["documents"]])
+            prompt = ResearchConfig.ANALYSIS_TEMPLATE.format(context=docs)
+            response = self.processor.process_query(prompt)
+            
+            if "error" in response:
+                return self._error_state(response["error"])
+            
+            return {
+                "messages": [AIMessage(content=response['choices'][0]['message']['content'])],
+                "context": {"analysis": response}
+            }
+        except Exception as e:
+            return self._error_state(f"Analysis Error: {str(e)}")
+
+    def validate_output(self, state: AgentState) -> Dict:
+        analysis = state["messages"][-1].content
+        validation_prompt = f"""Validate research analysis:
+        {analysis}
+        
+        Check for:
+        1. Technical accuracy
+        2. Citation support
+        3. Logical consistency
+        4. Methodological soundness
+        
+        Respond with 'VALID' or 'INVALID'"""
+        
+        response = self.processor.process_query(validation_prompt)
+        return {
+            "messages": [AIMessage(content=analysis + f"\n\nValidation: {response.get('choices', [{}])[0].get('message', {}).get('content', '')}")]
+        }
+
+    def refine_results(self, state: AgentState) -> Dict:
+        refinement_prompt = f"""Refine this analysis:
+        {state["messages"][-1].content}
+        
+        Improve:
+        1. Technical precision
+        2. Empirical grounding
+        3. Theoretical coherence"""
+        
+        response = self.processor.process_query(refinement_prompt)
+        return {
+            "messages": [AIMessage(content=response.get('choices', [{}])[0].get('message', {}).get('content', ''))],
+            "context": state["context"]
+        }
+
+    def _quality_check(self, state: AgentState) -> str:
+        content = state["messages"][-1].content
+        return "valid" if "VALID" in content else "invalid"
+
+    def _error_state(self, message: str) -> Dict:
+        return {
+            "messages": [AIMessage(content=f"❌ {message}")],
+            "context": {"error": True},
+            "metadata": {"status": "error"}
+        }
 
 # ------------------------------
-# Streamlit App UI (Enhanced Dark Theme)
+# Research Interface
 # ------------------------------
-def main():
-    st.set_page_config(
-        page_title="AI Research & Development Assistant",
-        layout="wide",
-        initial_sidebar_state="expanded"
-    )
-
-    st.markdown("""
-    <style>
-    .stApp {
-        background-color: #1a1a1a;
-        color: #ffffff;
-    }
-    
-    .stTextArea textarea {
-        background-color: #2d2d2d !important;
-        color: #ffffff !important;
-        border: 1px solid #3d3d3d;
-    }
-    
-    .stButton > button {
-        background-color: #4CAF50;
-        color: white;
-        border: none;
-        padding: 12px 28px;
-        border-radius: 6px;
-        transition: all 0.3s;
-        font-weight: 500;
-    }
-    
-    .stButton > button:hover {
-        background-color: #45a049;
-        transform: scale(1.02);
-        box-shadow: 0 2px 8px rgba(0,0,0,0.2);
-    }
-    
-    .data-box {
-        padding: 18px;
-        margin: 12px 0;
-        border-radius: 8px;
-        background-color: #2d2d2d;
-        border-left: 4px solid;
-    }
-    
-    .research-box {
-        border-color: #2196F3;
-    }
-    
-    .dev-box {
-        border-color: #4CAF50;
-    }
-    
-    .st-expander {
-        background-color: #2d2d2d;
-        border: 1px solid #3d3d3d;
-        border-radius: 6px;
-        margin: 16px 0;
-    }
-    
-    .st-expander .streamlit-expanderHeader {
-        color: #ffffff !important;
-        font-weight: 500;
-    }
-    
-    .stAlert {
-        background-color: #2d2d2d !important;
-        border: 1px solid #3d3d3d;
-    }
-    
-    h1, h2, h3 {
-        color: #ffffff !important;
-        border-bottom: 2px solid #3d3d3d;
-        padding-bottom: 8px;
-    }
-    
-    .stMarkdown {
-        color: #e0e0e0;
-        line-height: 1.6;
-    }
-    </style>
-    """, unsafe_allow_html=True)
+class ResearchInterface:
+    def __init__(self):
+        self.workflow = ResearchWorkflow()
+        self._initialize_interface()
+
+    def _initialize_interface(self):
+        st.set_page_config(
+            page_title="NeuroResearch AI",
+            layout="wide",
+            initial_sidebar_state="expanded"
+        )
+        self._inject_styles()
+        self._build_sidebar()
+        self._build_main_interface()
 
-    with st.sidebar:
-        st.header("📚 Available Data")
+    def _inject_styles(self):
+        st.markdown("""
+        <style>
+        :root {
+            --primary: #2ecc71;
+            --secondary: #3498db;
+            --background: #0a0a0a;
+            --text: #ecf0f1;
+        }
+        
+        .stApp {
+            background: var(--background);
+            color: var(--text);
+            font-family: 'Roboto', sans-serif;
+        }
+        
+        .stTextArea textarea {
+            background: #1a1a1a !important;
+            color: var(--text) !important;
+            border: 2px solid var(--secondary);
+            border-radius: 8px;
+            padding: 1rem;
+        }
+        
+        .stButton>button {
+            background: linear-gradient(135deg, var(--primary), var(--secondary));
+            border: none;
+            border-radius: 8px;
+            padding: 1rem 2rem;
+            transition: all 0.3s;
+        }
+        
+        .stButton>button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(46, 204, 113, 0.3);
+        }
         
-        st.subheader("Research Database")
-        for text in research_texts:
-            st.markdown(f'<div class="data-box research-box">{text}</div>', unsafe_allow_html=True)
+        .stExpander {
+            background: #1a1a1a;
+            border: 1px solid #2a2a2a;
+            border-radius: 8px;
+            margin: 1rem 0;
+        }
+        </style>
+        """, unsafe_allow_html=True)
+
+    def _build_sidebar(self):
+        with st.sidebar:
+            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```")
             
-        st.subheader("Development Database")
-        for text in development_texts:
-            st.markdown(f'<div class="data-box dev-box">{text}</div>', unsafe_allow_html=True)
-
-    st.title("🤖 AI Research & Development Assistant")
-    st.markdown("---")
-
-    query = st.text_area("Enter your question:", height=100, placeholder="e.g., What is the latest advancement in AI research?")
-
-    col1, col2 = st.columns([1, 2])
-    with col1:
-        if st.button("🔍 Get Answer", use_container_width=True):
-            if query:
-                try:
-                    with st.spinner('Processing your question...'):
-                        events = process_question(query, app, {"configurable": {"thread_id": "1"}})
+            st.subheader("Analysis Metrics")
+            st.metric("Vector Collections", 2)
+            st.metric("Embedding Dimensions", ResearchConfig.EMBEDDING_DIMENSIONS)
+
+    def _build_main_interface(self):
+        st.title("🧠 NeuroResearch AI")
+        query = st.text_area("Research Query:", height=200,
+                           placeholder="Enter technical research question...")
+        
+        if st.button("Execute Analysis", type="primary"):
+            self._execute_analysis(query)
+
+    def _execute_analysis(self, query: str):
+        try:
+            with st.spinner("Initializing Quantum Analysis..."):
+                results = self.workflow.app.stream(
+                    {"messages": [HumanMessage(content=query)], "context": {}, "metadata": {}}
+                )
+                
+                for event in results:
+                    self._render_event(event)
+                
+                st.success("✅ Analysis Completed Successfully")
+        except Exception as e:
+            st.error(f"""**Analysis Failed**
+            {str(e)}
+            Potential issues:
+            - Complex query structure
+            - Document correlation failure
+            - Temporal processing constraints""")
+
+    def _render_event(self, event: Dict):
+        if 'ingest' in event:
+            with st.container():
+                st.success("✅ Query Ingested")
+                
+        elif 'retrieve' in event:
+            with st.container():
+                docs = event['retrieve']['context']['documents']
+                st.info(f"📚 Retrieved {len(docs)} documents")
+                with st.expander("View Retrieved Documents", expanded=False):
+                    for i, doc in enumerate(docs, 1):
+                        st.markdown(f"**Document {i}**")
+                        st.code(doc.page_content, language='text')
                         
-                        for event in events:
-                            if 'agent' in event:
-                                with st.expander("🔄 Processing Step", expanded=True):
-                                    content = event['agent']['messages'][0].content
-                                    if "Error" in content:
-                                        st.error(content)
-                                    elif "Results:" in content:
-                                        st.markdown("### 📑 Retrieved Documents")
-                                        docs = content.split("Results:")[1].strip()
-                                        
-                                        # Process and deduplicate documents
-                                        unique_docs = list({
-                                            doc.split('page_content=')[1].split(')')[0].strip("'") 
-                                            for doc in docs.split("Document(")[1:]
-                                        })
-                                        
-                                        for i, doc in enumerate(unique_docs, 1):
-                                            st.markdown(f"""
-                                            **Document {i}**  
-                                            {doc}
-                                            """)
-                            elif 'generate' in event:
-                                content = event['generate']['messages'][0].content
-                                if "Error" in content:
-                                    st.error(content)
-                                else:
-                                    st.markdown("### ✨ Final Answer")
-                                    st.markdown(f"""
-                                    <div style='
-                                        background-color: #2d2d2d;
-                                        padding: 20px;
-                                        border-radius: 8px;
-                                        margin-top: 16px;
-                                    '>
-                                        {content}
-                                    </div>
-                                    """, unsafe_allow_html=True)
-                except Exception as e:
-                    st.error(f"""
-                    **Processing Error**  
-                    {str(e)}  
-                    Please check:  
-                    - API key configuration  
-                    - Account balance  
-                    - Network connection
-                    """)
-            else:
-                st.warning("⚠️ Please enter a question first!")
-
-    with col2:
-        st.markdown("""
-        ### 🎯 How to Use
-        1. **Enter** your question in the text box  
-        2. **Click** the search button  
-        3. **Review** processing steps  
-        4. **Analyze** final structured answer  
-
-        ### 💡 Example Questions
-        - What's new in quantum machine learning?  
-        - How is Project Y progressing?  
-        - Recent breakthroughs in AI image recognition?  
-
-        ### 🔍 Search Features
-        - Automatic query optimization  
-        - Technical document analysis  
-        - Cross-project insights  
-        - Source-aware reporting  
-        """)
+        elif 'analyze' in event:
+            with st.container():
+                content = event['analyze']['messages'][0].content
+                with st.expander("Technical Analysis Report", expanded=True):
+                    st.markdown(content)
+                    
+        elif 'validate' in event:
+            with st.container():
+                content = event['validate']['messages'][0].content
+                if "VALID" in content:
+                    st.success("✅ Validation Passed")
+                    with st.expander("View Validated Analysis", expanded=True):
+                        st.markdown(content.split("Validation:")[0])
+                else:
+                    st.warning("⚠️ Validation Issues Detected")
+                    with st.expander("View Validation Details", expanded=True):
+                        st.markdown(content)
 
 if __name__ == "__main__":
-    main()
+    ResearchInterface()