app.py

import os
import streamlit as st
from dotenv import load_dotenv
from utils.loader import extract_content_from_url
from utils.chunker import chunk_text
from utils.vector_store import create_vector_store, query_vector_store
import google.generativeai as genai

# Load environment variables
load_dotenv()

# Configure Gemini
genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
model = genai.GenerativeModel('gemini-2.5-flash')

# Streamlit app configuration
st.set_page_config(
    page_title="Personal Research Assistant",
    page_icon="🔍",
    layout="wide"
)

def generate_summary(text):
    """Generate an executive summary using Gemini."""
    prompt = f"""
    Please provide a concise executive summary of the following text. 
    Focus on the main points, key findings, and overall significance.
    Keep it under 300 words.
    
    Text:
    {text}
    """
    response = model.generate_content(prompt)
    return response.text

def generate_key_insights(text):
    """Generate key insights using Gemini."""
    prompt = f"""
    Extract the most important insights from the following text.
    Present them as a bulleted list of 5-7 key points.
    Each point should be concise but meaningful.
    
    Text:
    {text}
    """
    response = model.generate_content(prompt)
    return response.text

def answer_question(text, question):
    """Answer a question about the text using Gemini."""
    prompt = f"""
    Based on the following text, answer the question as accurately as possible.
    If the answer isn't in the text, say "I couldn't find the answer in the provided content."
    
    Text:
    {text}
    
    Question: {question}
    Answer:
    """
    response = model.generate_content(prompt)
    return response.text

def main():
    st.title("🔍 Personal Research Assistant")
    st.markdown("Extract insights from any blog or article URL")
    
    # Sidebar for settings
    with st.sidebar:
        st.header("Settings")
        chunk_size = st.slider("Chunk size (for long articles)", 500, 2000, 1000)
        chunk_overlap = st.slider("Chunk overlap", 0, 500, 200)
        st.markdown("---")
        st.markdown("Powered by Goose3, Gemini 3, and LangChain")
    
    # Main content area
    url = st.text_input("Enter article/blog URL:", placeholder="https://example.com/article")
    
    if url:
        with st.spinner("Extracting and processing content..."):
            try:
                # Extract content
                article = extract_content_from_url(url)
                
                if not article.text:
                    st.error("Could not extract meaningful content from this URL.")
                    return
                
                # Display basic info
                st.subheader(article.title)
                if article.meta_description:
                    st.caption(article.meta_description)
                
                # Generate summary and insights
                col1, col2 = st.columns(2)
                
                with col1:
                    st.subheader("Executive Summary")
                    summary = generate_summary(article.text)
                    st.write(summary)
                
                with col2:
                    st.subheader("Key Insights")
                    insights = generate_key_insights(article.text)
                    st.markdown(insights)
                
                # Chunking and vector store for long articles
                if len(article.text.split()) > 1000:
                    st.markdown("---")
                    st.subheader("Semantic Search (for long articles)")
                    
                    chunks = chunk_text(article.text, chunk_size=chunk_size, chunk_overlap=chunk_overlap)
                    vector_store = create_vector_store(chunks)
                    
                    query = st.text_input("Ask a question about the article:")
                    if query:
                        relevant_chunks = query_vector_store(vector_store, query, k=3)
                        context = "\n\n".join([chunk.page_content for chunk in relevant_chunks])
                        
                        answer = answer_question(context, query)
                        st.markdown("**Answer:**")
                        st.write(answer)
                        
                        with st.expander("See relevant passages"):
                            for chunk in relevant_chunks:
                                st.markdown(f"```\n{chunk.page_content}\n```")
                                st.markdown("---")
                
                # Simple Q&A for shorter articles
                else:
                    st.markdown("---")
                    st.subheader("Q&A")
                    question = st.text_input("Ask a question about the article:")
                    if question:
                        answer = answer_question(article.text, question)
                        st.markdown("**Answer:**")
                        st.write(answer)
            
            except Exception as e:
                st.error(f"An error occurred: {str(e)}")

if __name__ == "__main__":
    main()