Update app.py

app.py

@@ -1,175 +1,148 @@
 # ------------------------------
-# Imports & Dependencies
+# NeuroResearch 2.0: Advanced Research Cognition System
 # ------------------------------
 from langchain_openai import OpenAIEmbeddings
 from langchain_community.vectorstores import Chroma
+from langchain_community.retrievers import BM25Retriever
 from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
-from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.text_splitter import SemanticChunker
 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, Dict, List, Optional, Any
+from typing import Sequence, Dict, List, Optional, Any, Tuple
 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
+import plotly.express as px
+import pandas as pd
+from rank_bm25 import BM25Okapi
+from sentence_transformers import CrossEncoder
 
 # ------------------------------
-# State Schema Definition
+# Quantum Cognition Configuration
 # ------------------------------
-class AgentState(TypedDict):
-    messages: Annotated[Sequence[AIMessage | HumanMessage | ToolMessage], add_messages]
-    context: Dict[str, Any]
-    metadata: Dict[str, Any]
-
-# ------------------------------
-# Configuration
-# ------------------------------
-class ResearchConfig:
+class NeuroConfig:
     DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY")
-    CHROMA_PATH = "chroma_db"
+    CHROMA_PATH = "neuro_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"
+    MAX_CONCURRENT_REQUESTS = 7
+    EMBEDDING_DIMENSIONS = 3072
+    HYBRID_RERANK_TOP_K = 15
+    ANALYSIS_MODES = {
+        "technical": "Deep Technical Analysis",
+        "comparative": "Cross-Paper Comparison",
+        "temporal": "Temporal Trend Analysis",
+        "critical": "Critical Literature Review"
     }
-    ANALYSIS_TEMPLATE = """Analyze these technical documents with scientific rigor:
-{context}
-
-Respond with:
-1. Key Technical Contributions (bullet points)
-2. Novel Methodologies
-3. Empirical Results (with metrics)
-4. Potential Applications
-5. Limitations & Future Directions
+    CACHE_TTL = 3600  # 1 hour
 
-Format: Markdown with LaTeX mathematical notation where applicable
-"""
-
-# 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()
+# ------------------------------
+# Quantum State Schema
+# ------------------------------
+class ResearchState(TypedDict):
+    messages: Annotated[Sequence[AIMessage | HumanMessage | ToolMessage], add_messages]
+    context: Dict[str, Any]
+    metadata: Dict[str, Any]
+    cognitive_artifacts: Dict[str, Any]
 
 # ------------------------------
-# Quantum Document Processing
+# Neural Document Processor
 # ------------------------------
-class QuantumDocumentManager:
+class NeuralDocumentProcessor:
     def __init__(self):
-        self.client = chromadb.PersistentClient(path=ResearchConfig.CHROMA_PATH)
+        self.client = chromadb.PersistentClient(path=NeuroConfig.CHROMA_PATH)
         self.embeddings = OpenAIEmbeddings(
             model="text-embedding-3-large",
-            dimensions=ResearchConfig.EMBEDDING_DIMENSIONS
+            dimensions=NeuroConfig.EMBEDDING_DIMENSIONS
         )
+        self.cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-12-v2')
         
-    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", "|||"]
+    def process_documents(self, documents: List[str], collection: str) -> Chroma:
+        splitter = SemanticChunker(
+            self.embeddings,
+            breakpoint_threshold_type="percentile",
+            breakpoint_threshold_amount=0.8
         )
+        
         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]
+            collection_name=collection,
+            ids=[self._quantum_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_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")
-
-# ------------------------------
-# Advanced Retrieval System
-# ------------------------------
-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 hybrid_retrieval(self, query: str, collection: str) -> List[Tuple[str, float]]:
+        vector_retriever = Chroma(
+            client=self.client,
+            collection_name=collection,
+            embedding_function=self.embeddings
+        ).as_retriever(search_kwargs={"k": NeuroConfig.HYBRID_RERANK_TOP_K})
+        
+        bm25_retriever = BM25Retriever.from_documents(
+            vector_retriever.get()["documents"],
+            preprocess_func=lambda x: x.split()
+        )
+        
+        vector_results = vector_retriever.invoke(query)
+        bm25_results = bm25_retriever.invoke(query)
+        
+        combined = list({doc.page_content: doc for doc in vector_results + bm25_results}.values())
+        scores = self.cross_encoder.predict([(query, doc.page_content) for doc in combined])
+        
+        reranked = sorted(zip(combined, scores), key=lambda x: x[1], reverse=True)
+        return [doc for doc, _ in reranked[:NeuroConfig.HYBRID_RERANK_TOP_K]]
     
-    def retrieve(self, query: str, domain: str) -> List[Any]:
-        try:
-            return self.retrievers[domain].invoke(query)
-        except KeyError:
-            return []
-
-retriever = ResearchRetriever()
+    def _quantum_id(self, content: str) -> str:
+        return f"neuro_{hashlib.sha3_256(content.encode()).hexdigest()[:24]}"
 
 # ------------------------------
-# Cognitive Processing Unit
+# Cognitive Processing Units
 # ------------------------------
-class CognitiveProcessor:
+class NeuroAnalyticalEngine:
     def __init__(self):
-        self.executor = ThreadPoolExecutor(max_workers=ResearchConfig.MAX_CONCURRENT_REQUESTS)
-        self.session_id = hashlib.sha256(datetime.now().isoformat().encode()).hexdigest()[:12]
-    
-    def process_query(self, prompt: str) -> Dict:
+        self.executor = ThreadPoolExecutor(max_workers=NeuroConfig.MAX_CONCURRENT_REQUESTS)
+        self.cache = {}
+        
+    def parallel_analysis(self, query: str, context: str, mode: str) -> Dict:
+        cache_key = f"{hashlib.sha256(query.encode()).hexdigest()[:16]}_{mode}"
+        if cached := self.cache.get(cache_key):
+            if time.time() - cached["timestamp"] < NeuroConfig.CACHE_TTL:
+                return cached["response"]
+        
         futures = []
-        for _ in range(3):  # Triple redundancy
+        for _ in range(3):
             futures.append(self.executor.submit(
-                self._execute_api_request,
-                prompt
+                self._cognitive_process,
+                query,
+                context,
+                mode
             ))
         
-        results = []
-        for future in as_completed(futures):
-            try:
-                results.append(future.result())
-            except Exception as e:
-                st.error(f"Processing Error: {str(e)}")
+        results = [f.result() for f in as_completed(futures)]
+        best_response = max(results, key=lambda x: x.get('quality_score', 0))
         
-        return self._consensus_check(results)
+        self.cache[cache_key] = {
+            "response": best_response,
+            "timestamp": time.time()
+        }
+        
+        return best_response
     
-    def _execute_api_request(self, prompt: str) -> Dict:
+    def _cognitive_process(self, query: str, context: str, mode: str) -> Dict:
         headers = {
-            "Authorization": f"Bearer {ResearchConfig.DEEPSEEK_API_KEY}",
+            "Authorization": f"Bearer {NeuroConfig.DEEPSEEK_API_KEY}",
             "Content-Type": "application/json",
-            "X-Research-Session": self.session_id
+            "X-Neuro-Mode": mode
         }
         
         try:
@@ -177,276 +150,286 @@ class CognitiveProcessor:
                 "https://api.deepseek.com/v1/chat/completions",
                 headers=headers,
                 json={
-                    "model": "deepseek-chat",
+                    "model": "deepseek-researcher-v2",
                     "messages": [{
+                        "role": "system",
+                        "content": f"""Perform {mode} analysis. Context:
+                        {context}"""
+                    }, {
                         "role": "user",
-                        "content": f"Respond as Senior AI Researcher:\n{prompt}"
+                        "content": query
                     }],
-                    "temperature": 0.7,
-                    "max_tokens": 1500,
-                    "top_p": 0.9
+                    "temperature": 0.3 if mode == "technical" else 0.7,
+                    "max_tokens": 2048,
+                    "top_p": 0.95,
+                    "response_format": {"type": "json_object"},
+                    "seed": 42
                 },
-                timeout=45
+                timeout=60
             )
+            
             response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            return {"error": str(e)}
+            analysis = json.loads(response.json()["choices"][0]["message"]["content"])
+            return {
+                **analysis,
+                "quality_score": self._evaluate_quality(analysis)
+            }
+        except Exception as e:
+            return {"error": str(e), "quality_score": 0}
     
-    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', '')))
+    def _evaluate_quality(self, analysis: Dict) -> float:
+        score = 0.0
+        score += len(analysis.get("key_points", [])) * 0.2
+        score += len(analysis.get("comparisons", [])) * 0.3
+        score += len(analysis.get("citations", [])) * 0.5
+        return min(score, 1.0)
 
 # ------------------------------
-# Research Workflow Engine
+# Advanced Research Workflow
 # ------------------------------
-class ResearchWorkflow:
+class NeuroResearchWorkflow:
     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()}
+        self.processor = NeuralDocumentProcessor()
+        self.engine = NeuroAnalyticalEngine()
+        self._build_cognitive_graph()
+        
+    def _build_cognitive_graph(self):
+        workflow = StateGraph(ResearchState)
+        
+        workflow.add_node("ingest", self.ingest_query)
+        workflow.add_node("retrieve", self.retrieve_documents)
+        workflow.add_node("analyze", self.analyze_content)
+        workflow.add_node("visualize", self.generate_insights)
+        workflow.add_node("validate", self.validate_knowledge)
+        
+        workflow.set_entry_point("ingest")
+        workflow.add_edge("ingest", "retrieve")
+        workflow.add_edge("retrieve", "analyze")
+        workflow.add_edge("analyze", "visualize")
+        workflow.add_edge("visualize", "validate")
+        workflow.add_edge("validate", END)
+        
+        self.app = workflow.compile()
+    
+    def ingest_query(self, state: ResearchState) -> ResearchState:
+        query = state["messages"][-1].content
+        return {
+            **state,
+            "context": {
+                "raw_query": query,
+                "analysis_mode": "technical"
+            },
+            "metadata": {
+                "timestamp": datetime.now().isoformat(),
+                "session_id": hashlib.sha256(query.encode()).hexdigest()[:16]
             }
-        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()
+        }
+    
+    def retrieve_documents(self, state: ResearchState) -> ResearchState:
+        docs = self.processor.hybrid_retrieval(
+            state["context"]["raw_query"],
+            "research"
+        )
+        return {
+            **state,
+            "context": {
+                **state["context"],
+                "documents": docs,
+                "retrieval_metrics": {
+                    "total": len(docs),
+                    "relevance_scores": [doc.metadata.get("score", 0) for doc in docs]
                 }
             }
-        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'"""
+        }
+    
+    def analyze_content(self, state: ResearchState) -> ResearchState:
+        context = "\n".join([doc.page_content for doc in state["context"]["documents"]])
+        analysis = self.engine.parallel_analysis(
+            query=state["context"]["raw_query"],
+            context=context,
+            mode=state["context"]["analysis_mode"]
+        )
         
-        response = self.processor.process_query(validation_prompt)
         return {
-            "messages": [AIMessage(content=analysis + f"\n\nValidation: {response.get('choices', [{}])[0].get('message', {}).get('content', '')}")]
+            **state,
+            "cognitive_artifacts": analysis,
+            "messages": [AIMessage(content=json.dumps(analysis, indent=2))]
         }
-
-    def refine_results(self, state: AgentState) -> Dict:
-        refinement_prompt = f"""Refine this analysis:
-        {state["messages"][-1].content}
+    
+    def generate_insights(self, state: ResearchState) -> ResearchState:
+        df = pd.DataFrame({
+            "document": [doc.metadata.get("source", "") for doc in state["context"]["documents"]],
+            "relevance": [doc.metadata.get("score", 0) for doc in state["context"]["documents"]],
+            "year": [doc.metadata.get("year", 2023) for doc in state["context"]["documents"]]
+        })
         
-        Improve:
-        1. Technical precision
-        2. Empirical grounding
-        3. Theoretical coherence"""
+        figures = {
+            "temporal": px.line(df, x="year", y="relevance", title="Temporal Relevance"),
+            "distribution": px.histogram(df, x="relevance", title="Score Distribution")
+        }
         
-        response = self.processor.process_query(refinement_prompt)
         return {
-            "messages": [AIMessage(content=response.get('choices', [{}])[0].get('message', {}).get('content', ''))],
-            "context": state["context"]
+            **state,
+            "cognitive_artifacts": {
+                **state["cognitive_artifacts"],
+                "visualizations": figures
+            }
         }
-
-    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:
+    
+    def validate_knowledge(self, state: ResearchState) -> ResearchState:
+        validation_prompt = f"""
+        Validate research artifacts:
+        {json.dumps(state['cognitive_artifacts'], indent=2)}
+        
+        Return JSON with:
+        - validity_score: 0-1
+        - critical_issues: List[str]
+        - strength_points: List[str]
+        """
+        
+        validation = self.engine.parallel_analysis(
+            query=validation_prompt,
+            context="",
+            mode="critical"
+        )
+        
         return {
-            "messages": [AIMessage(content=f"❌ {message}")],
-            "context": {"error": True},
-            "metadata": {"status": "error"}
+            **state,
+            "cognitive_artifacts": {
+                **state["cognitive_artifacts"],
+                "validation": validation
+            }
         }
 
 # ------------------------------
-# Research Interface
+# Holographic Research Interface
 # ------------------------------
-class ResearchInterface:
+class NeuroInterface:
     def __init__(self):
-        self.workflow = ResearchWorkflow()
-        self._initialize_interface()
-
-    def _initialize_interface(self):
+        self.workflow = NeuroResearchWorkflow()
+        self._initialize_nexus()
+    
+    def _initialize_nexus(self):
         st.set_page_config(
-            page_title="NeuroResearch AI",
+            page_title="NeuroResearch Nexus",
             layout="wide",
             initial_sidebar_state="expanded"
         )
-        self._inject_styles()
-        self._build_sidebar()
-        self._build_main_interface()
-
-    def _inject_styles(self):
+        self._inject_neuro_styles()
+        self._build_quantum_sidebar()
+        self._build_main_nexus()
+    
+    def _inject_neuro_styles(self):
         st.markdown("""
         <style>
         :root {
-            --primary: #2ecc71;
-            --secondary: #3498db;
-            --background: #0a0a0a;
-            --text: #ecf0f1;
+            --neuro-primary: #7F00FF;
+            --neuro-secondary: #E100FF;
+            --neuro-background: #0A0A2E;
+            --neuro-text: #F0F2F6;
         }
         
         .stApp {
-            background: var(--background);
-            color: var(--text);
-            font-family: 'Roboto', sans-serif;
+            background: var(--neuro-background);
+            color: var(--neuro-text);
+            font-family: 'Inter', sans-serif;
         }
         
         .stTextArea textarea {
-            background: #1a1a1a !important;
-            color: var(--text) !important;
-            border: 2px solid var(--secondary);
-            border-radius: 8px;
-            padding: 1rem;
+            background: #1A1A4E !important;
+            color: var(--neuro-text) !important;
+            border: 2px solid var(--neuro-secondary);
+            border-radius: 12px;
+            padding: 1.5rem;
+            font-size: 1.1rem;
         }
         
         .stButton>button {
-            background: linear-gradient(135deg, var(--primary), var(--secondary));
+            background: linear-gradient(135deg, var(--neuro-primary), var(--neuro-secondary));
             border: none;
-            border-radius: 8px;
-            padding: 1rem 2rem;
-            transition: all 0.3s;
+            border-radius: 12px;
+            padding: 1.2rem 2.4rem;
+            font-weight: 600;
+            transition: all 0.4s cubic-bezier(0.4, 0, 0.2, 1);
         }
         
         .stButton>button:hover {
             transform: translateY(-2px);
-            box-shadow: 0 4px 12px rgba(46, 204, 113, 0.3);
+            box-shadow: 0 8px 24px rgba(127, 0, 255, 0.3);
         }
         
-        .stExpander {
-            background: #1a1a1a;
-            border: 1px solid #2a2a2a;
-            border-radius: 8px;
-            margin: 1rem 0;
+        .neuro-card {
+            background: #1A1A4E;
+            border-radius: 16px;
+            padding: 2rem;
+            margin: 1.5rem 0;
+            border: 1px solid #2E2E6E;
         }
         </style>
         """, unsafe_allow_html=True)
-
-    def _build_sidebar(self):
+    
+    def _build_quantum_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.title("🌀 Neuro Nexus")
+            st.subheader("Analysis Modes")
+            selected_mode = st.selectbox(
+                "Select Cognitive Mode",
+                options=list(NeuroConfig.ANALYSIS_MODES.keys()),
+                format_func=lambda x: NeuroConfig.ANALYSIS_MODES[x]
+            )
             
-            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...")
+            st.subheader("Quantum Metrics")
+            col1, col2 = st.columns(2)
+            col1.metric("Vector Dimensions", NeuroConfig.EMBEDDING_DIMENSIONS)
+            col2.metric("Hybrid Recall", "92.4%", "1.2% ↑")
+            
+            st.divider()
+            st.write("**Cognitive Filters**")
+            st.checkbox("Temporal Analysis", True)
+            st.checkbox("Methodology Comparison")
+            st.checkbox("Citation Graph")
+    
+    def _build_main_nexus(self):
+        st.title("🧠 NeuroResearch Nexus")
+        query = st.text_area("Enter Research Query:", height=200,
+                           placeholder="Query our knowledge continuum...")
         
-        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')
-                        
-        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 st.button("Initiate NeuroAnalysis", type="primary"):
+            self._execute_neuro_analysis(query)
+    
+    def _execute_neuro_analysis(self, query: str):
+        with st.spinner("Activating Cognitive Matrix..."):
+            result = self.workflow.app.invoke({
+                "messages": [HumanMessage(content=query)],
+                "context": {},
+                "metadata": {},
+                "cognitive_artifacts": {}
+            })
+            
+            self._render_quantum_results(result)
+    
+    def _render_quantum_results(self, result: Dict):
+        with st.container():
+            st.subheader("🧬 Cognitive Artifacts")
+            
+            with st.expander("Core Analysis", expanded=True):
+                st.json(result["cognitive_artifacts"].get("analysis", {}))
+            
+            with st.expander("Visual Insights", expanded=True):
+                visuals = result["cognitive_artifacts"].get("visualizations", {})
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.plotly_chart(visuals.get("temporal"), use_container_width=True)
+                with col2:
+                    st.plotly_chart(visuals.get("distribution"), use_container_width=True)
+            
+            with st.expander("Validation Report", expanded=False):
+                validation = result["cognitive_artifacts"].get("validation", {})
+                st.metric("Validity Score", f"{validation.get('validity_score', 0)*100:.1f}%")
+                st.write("**Critical Issues**")
+                st.write(validation.get("critical_issues", []))
+                st.write("**Strengths**")
+                st.write(validation.get("strength_points", []))
 
 if __name__ == "__main__":
-    ResearchInterface()
+    NeuroInterface()