Update app.py

app.py

@@ -3,452 +3,552 @@
 # ------------------------------
 from langchain_openai import OpenAIEmbeddings
 from langchain_community.vectorstores import Chroma
-from langchain_core.messages import HumanMessage, AIMessage, BaseMessage
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langgraph.graph import END, StateGraph
-from typing_extensions import TypedDict, Annotated
-from typing import Sequence, Dict, List, Optional, Any
+from langgraph.prebuilt import ToolNode
 from langgraph.graph.message import add_messages
+from typing_extensions import TypedDict, Annotated
+from typing import Sequence
 import chromadb
+import re
 import os
 import streamlit as st
 import requests
-import hashlib
-import json
-import time
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime
-from pydantic import BaseModel, ValidationError
-import traceback
+from langchain.tools.retriever import create_retriever_tool
 
 # ------------------------------
-# Configuration & Constants
+# Configuration
 # ------------------------------
-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
-    ANALYSIS_TEMPLATE = """**Technical Analysis Request**
-{context}
-
-Respond with:
-1. Key Technical Innovations (markdown table)
-2. Methodological Breakdown (bullet points)
-3. Quantitative Results (LaTeX equations)
-4. Critical Evaluation
-5. Research Impact Assessment
-
-Include proper academic citations where applicable."""
+# Get DeepSeek API key from Hugging Face Space secrets
+DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY")
+
+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()
+
+# Create directory for Chroma persistence
+os.makedirs("chroma_db", exist_ok=True)
 
 # ------------------------------
-# Document Schema & Content
+# ChromaDB Client Configuration
 # ------------------------------
-DOCUMENT_CONTENT = {
-    "CV-Transformer Hybrid": {
-        "content": """## Hybrid Architecture for Computer Vision
-**Authors**: DeepVision Research Team  
-**Abstract**: Novel combination of convolutional layers with transformer attention mechanisms.
-
-### Key Innovations:
-- Cross-attention feature fusion
-- Adaptive spatial pooling
-- Multi-scale gradient propagation
-
-$$\\mathcal{L}_{total} = \\alpha\\mathcal{L}_{CE} + \\beta\\mathcal{L}_{SSIM}$$""",
-        "metadata": {
-            "year": 2024,
-            "domain": "computer_vision",
-            "citations": 142
-        }
-    },
-    "Quantum ML Advances": {
-        "content": """## Quantum Machine Learning Breakthroughs
-**Authors**: Quantum AI Lab
-
-### Achievements:
-- Quantum-enhanced SGD (40% faster convergence)
-- 5-qubit QNN achieving 98% accuracy
-- Hybrid quantum-classical GANs
-
-$$\\mathcal{H} = -\\sum_{i<j} J_{ij}\\sigma_i^z\\sigma_j^z - \\Gamma\\sum_i\\sigma_i^x$$""",
-        "metadata": {
-            "year": 2023,
-            "domain": "quantum_ml",
-            "citations": 89
-        }
-    }
-}
+chroma_client = chromadb.PersistentClient(path="chroma_db")
 
-class DocumentSchema(BaseModel):
-    content: str
-    metadata: dict
-    doc_id: str
+# ------------------------------
+# Dummy Data: Research & Development Texts
+# ------------------------------
+research_texts = [
+    "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"
+]
+
+development_texts = [
+    "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"
+]
 
 # ------------------------------
-# State Management
+# Text Splitting & Document Creation
 # ------------------------------
-class ResearchState(TypedDict):
-    messages: Annotated[List[BaseMessage], add_messages]
-    context: Annotated[Dict[str, Any], "research_context"]
-    metadata: Annotated[Dict[str, str], "system_metadata"]
+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)
 
 # ------------------------------
-# Document Processing
+# Creating Vector Stores with Embeddings
 # ------------------------------
-class DocumentManager:
-    def __init__(self):
-        self.client = chromadb.PersistentClient(path=ResearchConfig.CHROMA_PATH)
-        self.embeddings = OpenAIEmbeddings(
-            model="text-embedding-3-large",
-            dimensions=ResearchConfig.EMBEDDING_DIMENSIONS
-        )
+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"
+)
+
+# ------------------------------
+# Creating Retriever Tools with MMR
+# ------------------------------
+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."
+)
+
+tools = [research_tool, development_tool]
+
+# ------------------------------
+# Agent Function & Workflow Functions
+# ------------------------------
+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"
+    }
     
-    def initialize_collections(self):
-        try:
-            self.research_col = self._create_collection("research")
-            self.dev_col = self._create_collection("development")
-        except Exception as e:
-            st.error(f"Collection initialization failed: {str(e)}")
-            traceback.print_exc()
-
-    def _create_collection(self, name: str) -> Chroma:
-        documents, metadatas, ids = [], [], []
-        
-        for title, data in DOCUMENT_CONTENT.items():
-            try:
-                doc = DocumentSchema(
-                    content=data["content"],
-                    metadata=data["metadata"],
-                    doc_id=hashlib.sha256(title.encode()).hexdigest()[:16]
-                )
-                documents.append(doc.content)
-                metadatas.append(doc.metadata)
-                ids.append(doc.doc_id)
-            except ValidationError as e:
-                st.error(f"Invalid document format: {title} - {str(e)}")
-                continue
-
-        splitter = RecursiveCharacterTextSplitter(
-            chunk_size=ResearchConfig.CHUNK_SIZE,
-            chunk_overlap=ResearchConfig.CHUNK_OVERLAP,
-            separators=["\n## ", "\n### ", "\n\n", "\n• "]
+    data = {
+        "model": "deepseek-chat",
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.7,
+        "max_tokens": 1024
+    }
+    
+    try:
+        response = requests.post(
+            "https://api.deepseek.com/v1/chat/completions",
+            headers=headers,
+            json=data,
+            verify=False,
+            timeout=30
         )
+        response.raise_for_status()
         
-        try:
-            docs = splitter.create_documents(documents, metadatas=metadatas)
-            return Chroma.from_documents(
-                docs,
-                self.embeddings,
-                client=self.client,
-                collection_name=name,
-                ids=ids
-            )
-        except Exception as e:
-            raise RuntimeError(f"Failed creating {name} collection: {str(e)}")
+        response_text = response.json()['choices'][0]['message']['content']
+        print("Raw response:", response_text)
+        
+        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)}')]}
 
-# ------------------------------
-# Retrieval System
-# ------------------------------
-class ResearchRetriever:
-    def __init__(self):
-        self.dm = DocumentManager()
-        self.dm.initialize_collections()
+        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)
     
-    def retrieve(self, query: str, domain: str) -> List[DocumentSchema]:
-        try:
-            collection = self.dm.research_col if domain == "research" else self.dm.dev_col
-            if not collection:
-                return []
-            
-            results = collection.as_retriever(
-                search_type="mmr",
-                search_kwargs={'k': 4, 'fetch_k': 20}
-            ).invoke(query)
-            
-            return [DocumentSchema(
-                content=doc.page_content,
-                metadata=doc.metadata,
-                doc_id=doc.metadata.get("doc_id", "")
-            ) for doc in results if doc.page_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
+    }
+    
+    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()
+        
+        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"
+    }
+    
+    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()
         
-        except Exception as e:
-            st.error(f"Retrieval failure: {str(e)}")
-            traceback.print_exc()
-            return []
+        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
 
 # ------------------------------
-# Analysis Processor
+# Workflow Configuration using LangGraph
 # ------------------------------
-class AnalysisEngine:
-    def __init__(self):
-        self.executor = ThreadPoolExecutor(max_workers=ResearchConfig.MAX_CONCURRENT_REQUESTS)
-        self.session_hash = hashlib.sha256(str(time.time()).encode()).hexdigest()[:12]
-
-    def analyze(self, prompt: str) -> Dict:
-        futures = [self.executor.submit(self._api_request, prompt) for _ in range(3)]
-        return self._validate_results([f.result() for f in as_completed(futures)])
-
-    def _api_request(self, prompt: str) -> Dict:
-        headers = {
-            "Authorization": f"Bearer {ResearchConfig.DEEPSEEK_API_KEY}",
-            "X-Session-ID": self.session_hash,
-            "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": prompt}],
-                    "temperature": 0.7,
-                    "max_tokens": 2000
-                },
-                timeout=30
-            )
-            response.raise_for_status()
-            return response.json()
-        except Exception as e:
-            return {"error": str(e), "status_code": 500}
-
-    def _validate_results(self, results: List[Dict]) -> Dict:
-        valid = [r for r in results if "error" not in r]
-        if not valid:
-            return {"error": "All analysis attempts failed", "results": results}
-        
-        # Corrected line with proper parenthesis closure
-        best = max(valid, key=lambda x: len(x.get('choices', [{}])[0].get('message', {}).get('content', '')))
-        return best
+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()
 
 # ------------------------------
-# Workflow Implementation
+# Processing Function
 # ------------------------------
-class ResearchWorkflow:
-    def __init__(self):
-        self.retriever = ResearchRetriever()
-        self.engine = AnalysisEngine()
-        self.workflow = StateGraph(ResearchState)
-        self._build_graph()
-
-    def _build_graph(self):
-        self.workflow.add_node("ingest", self._ingest)
-        self.workflow.add_node("retrieve", self._retrieve)
-        self.workflow.add_node("analyze", self._analyze)
-        self.workflow.add_node("validate", self._validate)
-        self.workflow.add_node("refine", self._refine)
-
-        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_gate,
-            {"valid": "validate", "invalid": "refine"}
-        )
-        self.workflow.add_edge("validate", END)
-        self.workflow.add_edge("refine", "retrieve")
-
-    def _ingest(self, state: ResearchState) -> ResearchState:
-        try:
-            query = next(msg.content for msg in reversed(state["messages"]) 
-                      if isinstance(msg, HumanMessage))
-            return {
-                "messages": [AIMessage(content="Query ingested")],
-                "context": {
-                    "query": query,
-                    "documents": [],
-                    "errors": []
-                },
-                "metadata": {
-                    "session_id": hashlib.sha256(str(time.time()).encode()).hexdigest()[:8],
-                    "timestamp": datetime.now().isoformat()
-                }
-            }
-        except Exception as e:
-            return self._handle_error(f"Ingest failed: {str(e)}", state)
-
-    def _retrieve(self, state: ResearchState) -> ResearchState:
-        try:
-            docs = self.retriever.retrieve(state["context"]["query"], "research")
-            return {
-                "messages": [AIMessage(content=f"Retrieved {len(docs)} documents")],
-                "context": {
-                    **state["context"],
-                    "documents": docs,
-                    "retrieval_time": time.time()
-                },
-                "metadata": state["metadata"]
-            }
-        except Exception as e:
-            return self._handle_error(f"Retrieval error: {str(e)}", state)
-
-    def _analyze(self, state: ResearchState) -> ResearchState:
-        docs = state["context"].get("documents", [])
-        if not docs:
-            return self._handle_error("No documents for analysis", state)
-        
-        try:
-            context = "\n\n".join([d.content for d in docs])
-            prompt = ResearchConfig.ANALYSIS_TEMPLATE.format(context=context)
-            result = self.engine.analyze(prompt)
-            
-            if "error" in result:
-                raise RuntimeError(result["error"])
-            
-            content = result['choices'][0]['message']['content']
-            
-            if len(content) < 200 or not any(c.isalpha() for c in content):
-                raise ValueError("Insufficient analysis content")
-            
-            return {
-                "messages": [AIMessage(content=content)],
-                "context": state["context"],
-                "metadata": state["metadata"]
-            }
-        except Exception as e:
-            return self._handle_error(f"Analysis failed: {str(e)}", state)
-
-    def _validate(self, state: ResearchState) -> ResearchState:
-        return state
-
-    def _refine(self, state: ResearchState) -> ResearchState:
-        return state
-
-    def _quality_gate(self, state: ResearchState) -> str:
-        content = state["messages"][-1].content if state["messages"] else ""
-        required = ["Innovations", "Results", "Evaluation"]
-        return "valid" if all(kw in content for kw in required) else "invalid"
-
-    def _handle_error(self, message: str, state: ResearchState) -> ResearchState:
-        return {
-            "messages": [AIMessage(content=f"🚨 Error: {message}")],
-            "context": {
-                **state["context"],
-                "errors": state["context"]["errors"] + [message]
-            },
-            "metadata": state["metadata"]
-        }
+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
 
 # ------------------------------
-# User Interface
+# Streamlit App UI (Enhanced Dark Theme)
 # ------------------------------
-class ResearchInterface:
-    def __init__(self):
-        self.workflow = ResearchWorkflow().workflow.compile()
-        self._setup_interface()
-
-    def _setup_interface(self):
-        st.set_page_config(
-            page_title="Research Assistant",
-            layout="wide",
-            initial_sidebar_state="expanded"
-        )
-        self._apply_styles()
-        self._build_sidebar()
-        self._build_main()
+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)
 
-    def _apply_styles(self):
-        st.markdown("""
-        <style>
-        .stApp {
-            background: #0a192f;
-            color: #64ffda;
-        }
-        .stTextArea textarea {
-            background: #172a45 !important;
-            color: #a8b2d1 !important;
-        }
-        .stButton>button {
-            background: #233554;
-            border: 1px solid #64ffda;
-        }
-        .error-box {
-            border: 1px solid #ff4444;
-            border-radius: 5px;
-            padding: 1rem;
-            margin: 1rem 0;
-        }
-        </style>
-        """, unsafe_allow_html=True)
-
-    def _build_sidebar(self):
-        with st.sidebar:
-            st.title("🔍 Document Database")
-            for title, data in DOCUMENT_CONTENT.items():
-                with st.expander(title[:25]+"..."):
-                    st.markdown(f"```\n{data['content'][:300]}...\n```")
-
-    def _build_main(self):
-        st.title("🧠 Research Analysis System")
-        query = st.text_area("Enter your research query:", height=150)
+    with st.sidebar:
+        st.header("📚 Available Data")
         
-        if st.button("Start Analysis", type="primary"):
-            self._run_analysis(query)
-
-    def _run_analysis(self, query: str):
-        try:
-            with st.spinner("🔍 Analyzing documents..."):
-                state = {
-                    "messages": [HumanMessage(content=query)],
-                    "context": {
-                        "query": "",
-                        "documents": [],
-                        "errors": []
-                    },
-                    "metadata": {}
-                }
-                
-                for event in self.workflow.stream(state):
-                    self._display_progress(event)
-                
-                final_state = self.workflow.invoke(state)
-                self._show_results(final_state)
-                
-        except Exception as e:
-            st.error(f"""**Analysis Failed**
-            {str(e)}
-            Common solutions:
-            - Simplify your query
-            - Check document database status
-            - Verify API connectivity""")
-
-    def _display_progress(self, event):
-        current_state = next(iter(event.values()))
-        with st.container():
-            st.markdown("---")
-            cols = st.columns([1,2,1])
+        st.subheader("Research Database")
+        for text in research_texts:
+            st.markdown(f'<div class="data-box research-box">{text}</div>', unsafe_allow_html=True)
             
-            with cols[0]:
-                st.subheader("Processing Stage")
-                stage = list(event.keys())[0].title()
-                st.code(stage)
-                
-            with cols[1]:
-                st.subheader("Documents")
-                docs = current_state["context"].get("documents", [])
-                st.metric("Retrieved", len(docs))
-                
-            with cols[2]:
-                st.subheader("Status")
-                if current_state["context"].get("errors"):
-                    st.error("Errors detected")
-                else:
-                    st.success("Normal operation")
-
-    def _show_results(self, state: ResearchState):
-        if state["context"].get("errors"):
-            st.error("Analysis completed with errors")
-            with st.expander("Error Details"):
-                for error in state["context"]["errors"]:
-                    st.markdown(f"- {error}")
-        else:
-            st.success("Analysis completed successfully ✅")
-            with st.expander("Full Report"):
-                st.markdown(state["messages"][-1].content)
+        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"}})
+                        
+                        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  
+        """)
 
 if __name__ == "__main__":
-    ResearchInterface()
+    main()