research_assistant_dashboard.py

# import streamlit as st
# from openai import OpenAI
# import os
# from dotenv import load_dotenv
# from llama_index.core import (
#     VectorStoreIndex,
#     SimpleDirectoryReader,
#     Document,
#     GPTVectorStoreIndex,
# )
# from bson import ObjectId
# import requests
# import openai
# import numpy as np
# from pymongo import MongoClient
# from bson import ObjectId
# from datetime import datetime
# from llama_index.embeddings.openai import OpenAIEmbedding
# from typing import List, Dict

# # Initialize Perplexity API and OpenAI API
# load_dotenv()
# perplexity_api_key = os.getenv("PERPLEXITY_KEY")
# openai.api_key = os.getenv("OPENAI_KEY")

# # MongoDB setup
# MONGO_URI = os.getenv("MONGO_URI")
# client = MongoClient(MONGO_URI)
# db = client["novascholar_db"]
# research_papers_collection = db["research_papers"]


# def fetch_perplexity_data(api_key, topic):
#     """
#     Fetch research papers data from Perplexity API with proper formatting
#     """
#     headers = {
#         "accept": "application/json",
#         "content-type": "application/json",
#         "authorization": f"Bearer {api_key}",
#     }

#     # Structured prompt to get properly formatted response
#     messages = [
#         {
#             "role": "system",
#             "content": """You are a research paper retrieval expert. For the given topic, return exactly 10 research papers in the following format:
#             Title: Paper Title
#             Authors: Author 1, Author 2
#             Year: YYYY
#             Content: Detailed paper content with abstract and key findings
#             URL: DOI or paper URL
#             """,
#         },
#         {"role": "user", "content": f"Find 10 research papers about: {topic}"},
#     ]

#     try:
#         client = OpenAI(api_key=api_key, base_url="https://api.perplexity.ai")
#         response = client.chat.completions.create(
#             model="llama-3.1-sonar-small-128k-chat",  # Use the best Perplexity model
#             messages=messages,
#         )

#         # Extract and validate response
#         content = response.choices[0].message.content
#         st.write("Fetched Data:", content)  # Debugging line to check the fetched data

#         return content

#     except Exception as e:
#         st.error(f"Failed to fetch data from Perplexity API: {str(e)}")
#         return ""


# def split_and_vectorize_papers(content: str) -> List[Dict]:
#     """Split and vectorize papers using OpenAI embeddings"""
#     papers = content.split("\n\n")

#     # Initialize OpenAI client
#     # client = OpenAI()  # Uses api_key from environment variable
#     vectors = []

#     for paper in papers:
#         try:
#             # Get embedding using OpenAI's API directly
#             response = openai.embeddings.create(
#                 model="text-embedding-ada-002", input=paper, encoding_format="float"
#             )

#             # Extract embedding from response
#             embedding = response.data[0].embedding

#             vectors.append(
#                 {"content": paper, "vector": embedding, "timestamp": datetime.utcnow()}
#             )

#         except Exception as e:
#             st.error(f"Error vectorizing paper: {str(e)}")
#             continue

#     return vectors


# def store_papers_in_mongodb(papers):
#     """Store papers with vectors in MongoDB"""
#     try:
#         for paper in papers:
#             # Prepare MongoDB document
#             mongo_doc = {
#                 "content": paper["content"],
#                 "vector": paper["vector"],
#                 "created_at": datetime.utcnow(),
#             }

#             # Insert into MongoDB
#             db.papers.update_one(
#                 {"content": paper["content"]}, {"$set": mongo_doc}, upsert=True
#             )

#         st.success(f"Stored {len(papers)} papers in database")
#         return True
#     except Exception as e:
#         st.error(f"Error storing papers: {str(e)}")


# def get_research_papers(query):
#     """
#     Get and store research papers with improved error handling
#     """
#     # Fetch papers from Perplexity
#     content = fetch_perplexity_data(perplexity_api_key, query)

#     if not content:
#         return []

#     # Split and vectorize papers
#     papers = split_and_vectorize_papers(content)

#     # Store papers in MongoDB
#     if store_papers_in_mongodb(papers):
#         return papers
#     else:
#         st.warning("Failed to store papers in database, but returning fetched results")
#         return papers


# def analyze_research_gaps(papers):
#     """
#     Analyze research gaps with improved prompt and error handling
#     """
#     if not papers:
#         return "No papers provided for analysis"

#     # Prepare paper summaries for analysis
#     paper_summaries = "\n\n".join(
#         [
#             f"Key Findings: {paper['content'][:500]}..."
#             # f"Title: {paper['title']}\nYear: {paper['year']}\nKey Findings: {paper['content'][:500]}..."
#             for paper in papers
#         ]
#     )

#     headers = {
#         "Authorization": f"Bearer {perplexity_api_key}",
#         "Content-Type": "application/json",
#     }

#     data = {
#         "messages": [
#             {
#                 "role": "system",
#                 "content": "You are a research analysis expert. Identify specific research gaps and future research directions based on the provided papers. Format your response with clear sections: Current State, Identified Gaps, and Future Directions.",
#             },
#             {
#                 "role": "user",
#                 "content": f"Analyze these papers and identify research gaps:\n\n{paper_summaries}",
#             },
#         ]
#     }

#     try:
#         client = OpenAI(
#             api_key=perplexity_api_key, base_url="https://api.perplexity.ai"
#         )
#         response = client.chat.completions.create(
#             model="llama-3.1-sonar-small-128k-chat",  # Use the best Perplexity model
#             messages=data["messages"],
#         )
#         return response.choices[0].message.content

#     except Exception as e:
#         st.error(f"Failed to analyze research gaps: {str(e)}")
#         return "Error analyzing research gaps"


# def create_research_paper(gaps, topic, papers):
#     """
#     Create a research paper that addresses the identified gaps using Perplexity API
#     """
#     full_texts = "\n\n".join([paper["content"] for paper in papers])
#     headers = {
#         "Authorization": f"Bearer {perplexity_api_key}",
#         "Content-Type": "application/json",
#     }
#     data = {
#         "messages": [
#             {
#                 "role": "system",
#                 "content": "You are a research paper generation expert. Create a comprehensive research paper that addresses the identified gaps based on the provided papers. Format your response with clear sections: Introduction, Literature Review, Methodology, Results, Discussion, Conclusion, and References.",
#             },
#             {
#                 "role": "user",
#                 "content": f"Create a research paper on the topic '{topic}' that addresses the following research gaps:\n\n{gaps}\n\nBased on the following papers:\n\n{full_texts}",
#             },
#         ]
#     }
#     try:
#         client = OpenAI(
#             api_key=perplexity_api_key, base_url="https://api.perplexity.ai"
#         )
#         response = client.chat.completions.create(
#             model="llama-3.1-sonar-small-128k-chat",  # Use the best Perplexity model
#             messages=data["messages"],
#         )
#         return response.choices[0].message.content

#     except Exception as e:
#         st.error(f"Failed to create research paper: {str(e)}")
#         return "Error creating research paper"


# def cosine_similarity(vec1, vec2):
#     """Calculate the cosine similarity between two vectors"""
#     vec1 = np.array(vec1)
#     vec2 = np.array(vec2)
#     return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))


# def calculate_cosine_similarity(vec1: List[float], vec2: List[float]) -> float:
#     """Calculate cosine similarity between two vectors"""
#     return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))


# def display_research_assistant_dashboard():
#     """Display research assistant dashboard"""
#     # Initialize session state for recommendations
#     if "recommendations" not in st.session_state:
#         st.session_state.recommendations = None
#     if "vectors" not in st.session_state:
#         st.session_state.vectors = None
#     if "generated_paper" not in st.session_state:
#         st.session_state.generated_paper = None

#     # Sidebar
#     with st.sidebar:
#         st.title(f"Welcome, {st.session_state.username}")
#         if st.button("Logout", use_container_width=True):
#             for key in st.session_state.keys():
#                 del st.session_state[key]
#             st.rerun()

#     # Main content
#     st.title("Research Paper Recommendations")
#     search_query = st.text_input("Enter research topic:")
#     col1, col2 = st.columns(2)
#     with col1:
#         if st.button("Get Research Papers"):
#             if search_query:
#                 with st.spinner("Fetching recommendations..."):
#                     st.session_state.recommendations = get_research_papers(search_query)
#                     st.session_state.vectors = [
#                         paper["vector"] for paper in st.session_state.recommendations
#                     ]
#                     st.markdown(
#                         "\n\n".join(
#                             [
#                                 f"**{i+1}.**\n{paper['content']}"
#                                 # f"**{i+1}. {paper['title']}**\n{paper['content']}"
#                                 for i, paper in enumerate(
#                                     st.session_state.recommendations
#                                 )
#                             ]
#                         )
#                     )
#             else:
#                 st.warning("Please enter a search query")
#     with col2:
#         if st.button("Analyze Research Gaps"):
#             if st.session_state.recommendations:
#                 with st.spinner("Analyzing research gaps..."):
#                     gaps = analyze_research_gaps(st.session_state.recommendations)
#                     st.session_state.generated_paper = create_research_paper(
#                         gaps, search_query, st.session_state.recommendations
#                     )
#                     st.markdown("### Potential Research Gaps")
#                     st.markdown(gaps)
#             else:
#                 st.warning("Please get research papers first")

#     if st.button("Save and Vectorize"):
#         if st.session_state.generated_paper:
#             try:
#                 # Initialize OpenAI client

#                 # Get embedding for generated paper
#                 response = openai.embeddings.create(
#                     model="text-embedding-ada-002",
#                     input=st.session_state.generated_paper,
#                     encoding_format="float",
#                 )
#                 generated_vector = response.data[0].embedding

#                 # Calculate similarities with stored vectors
#                 similarities = [
#                     calculate_cosine_similarity(generated_vector, paper_vector)
#                     for paper_vector in st.session_state.vectors
#                 ]

#                 # Display results
#                 st.markdown("### Generated Research Paper")
#                 st.markdown(st.session_state.generated_paper)

#                 st.markdown("### Cosine Similarities with Original Papers")
#                 for i, similarity in enumerate(similarities):
#                     st.metric(
#                         f"Paper {i+1}",
#                         value=f"{similarity:.3f}",
#                         help="Cosine similarity (1.0 = identical, 0.0 = completely different)",
#                     )

#             except Exception as e:
#                 st.error(f"Error during vectorization: {str(e)}")
#         else:
#             st.warning("Please analyze research gaps first")


# # Run the dashboard
# if __name__ == "__main__":
#     display_research_assistant_dashboard()

import research_combine2
# if __name__ == "__main__":
#     display_research_assistant_dashboard()
def display_research_assistant_dashboard():
    research_combine2.display_research_assistant_dashboard()