Codex PR

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.10-slim
+
+# System deps for PDF parsing
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    poppler-utils \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python deps first for better cache hits
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . /app
+
+# Default model can be overridden in Space settings
+ENV DEFAULT_MODEL=t5-small
+ENV PORT=7860
+
+EXPOSE 7860
+
+# Start Streamlit on the expected port/interface
+CMD ["streamlit", "run", "app.py", "--server.port", "7860", "--server.address", "0.0.0.0"]

api/utils.py

@@ -1,5 +1,4 @@
 import re
-import nltk
 from typing import List, Dict, Any
 import logging
 
@@ -113,7 +112,8 @@ def get_text_statistics(text: str) -> Dict[str, Any]:
     Get basic statistics about the text.
     """
     words = text.split()
-    sentences = nltk.sent_tokenize(text)
+    # Lightweight sentence split to avoid NLTK downloads
+    sentences = [s.strip() for s in re.split(r'(?<=[\.\!\?])\s+', text) if s.strip()]
     
     return {
         'total_characters': len(text),
@@ -121,4 +121,4 @@ def get_text_statistics(text: str) -> Dict[str, Any]:
         'total_sentences': len(sentences),
         'average_words_per_sentence': len(words) / len(sentences) if sentences else 0,
         'estimated_reading_time_minutes': len(words) / 200  # Average reading speed
-    } 
+    }

app.py

@@ -1,314 +1,197 @@
+import os
 import streamlit as st
-import requests
-import json
-import time
-from typing import Dict, Any, Optional
-import io
+from typing import Dict, Any
+
+from api.pdf_processor import PDFProcessor
+from api.summarizer import BookSummarizer
+
+DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "sshleifer/distilbart-cnn-12-6")
+AVAILABLE_MODELS = BookSummarizer(DEFAULT_MODEL).get_available_models()
+
 
-# Page configuration
 st.set_page_config(
-    page_title="Book Summarizer AI",
+    page_title="Book Summarizer",
     page_icon="📚",
     layout="wide",
-    initial_sidebar_state="expanded"
+    initial_sidebar_state="expanded",
 )
 
-# API configuration
-API_BASE_URL = "http://localhost:8000"
 
-def main():
-    # Custom CSS for better styling
-    st.markdown("""
-    <style>
-    .main-header {
-        font-size: 3rem;
-        font-weight: bold;
-        text-align: center;
-        color: #1f77b4;
-        margin-bottom: 2rem;
-    }
-    .sub-header {
-        font-size: 1.5rem;
-        color: #666;
-        text-align: center;
-        margin-bottom: 2rem;
-    }
-    .success-box {
-        background-color: #d4edda;
-        border: 1px solid #c3e6cb;
-        border-radius: 5px;
-        padding: 1rem;
-        margin: 1rem 0;
-    }
-    .error-box {
-        background-color: #f8d7da;
-        border: 1px solid #f5c6cb;
-        border-radius: 5px;
-        padding: 1rem;
-        margin: 1rem 0;
+@st.cache_resource
+def get_pdf_processor() -> PDFProcessor:
+    return PDFProcessor()
+
+
+@st.cache_resource
+def get_summarizer(model_name: str) -> BookSummarizer:
+    summarizer = BookSummarizer(model_name=model_name)
+    summarizer.load_model()
+    return summarizer
+
+
+def summarize_pdf(
+    uploaded_file,
+    model_name: str,
+    max_length: int,
+    min_length: int,
+    chunk_size: int,
+    overlap: int,
+) -> Dict[str, Any]:
+    pdf_bytes = uploaded_file.getvalue()
+    processor = get_pdf_processor()
+
+    validation = processor.validate_pdf(pdf_bytes)
+    if not validation["valid"]:
+        raise ValueError(validation["message"])
+
+    metadata = processor.get_pdf_metadata(pdf_bytes)
+    extraction = processor.extract_text_from_pdf(pdf_bytes)
+    if not extraction["success"]:
+        raise RuntimeError(extraction["message"])
+
+    summarizer = get_summarizer(model_name)
+    summary_result = summarizer.summarize_book(
+        text=extraction["text"],
+        chunk_size=chunk_size,
+        overlap=overlap,
+        max_length=max_length,
+        min_length=min_length,
+    )
+
+    if not summary_result["success"]:
+        raise RuntimeError(summary_result.get("error", "Summarization failed"))
+
+    return {
+        "metadata": metadata,
+        "validation": validation,
+        "extraction": extraction,
+        "summary": summary_result,
     }
-    .info-box {
-        background-color: #d1ecf1;
-        border: 1px solid #bee5eb;
-        border-radius: 5px;
-        padding: 1rem;
-        margin: 1rem 0;
+
+
+def sidebar_controls():
+    st.header("Settings")
+
+    model_names = [m["name"] for m in AVAILABLE_MODELS]
+    model_descriptions = {m["name"]: m["description"] for m in AVAILABLE_MODELS}
+
+    selected_model = st.selectbox(
+        "Model",
+        model_names,
+        index=model_names.index(DEFAULT_MODEL) if DEFAULT_MODEL in model_names else 0,
+        help="Free, locally run Hugging Face models. First run downloads weights.",
+    )
+    st.caption(model_descriptions.get(selected_model, ""))
+
+    max_length = st.slider(
+        "Maximum summary length (words)",
+        min_value=50,
+        max_value=250,
+        value=140,
+        step=10,
+    )
+    min_length = st.slider(
+        "Minimum summary length (words)",
+        min_value=20,
+        max_value=min_length_limit := min(120, max_length - 10),
+        value=min(50, max_length - 20),
+        step=5,
+    )
+
+    chunk_size = st.slider(
+        "Chunk size (characters)",
+        min_value=600,
+        max_value=2000,
+        value=1200,
+        step=50,
+        help="Longer chunks preserve context but take longer.",
+    )
+    overlap = st.slider(
+        "Chunk overlap (characters)",
+        min_value=50,
+        max_value=300,
+        value=120,
+        step=10,
+    )
+
+    return {
+        "model": selected_model,
+        "max_length": max_length,
+        "min_length": min_length,
+        "chunk_size": chunk_size,
+        "overlap": overlap,
     }
-    </style>
-    """, unsafe_allow_html=True)
-    
-    # Header
-    st.markdown('<h1 class="main-header">📚 Book Summarizer AI</h1>', unsafe_allow_html=True)
-    st.markdown('<p class="sub-header">Transform your PDF books into intelligent summaries using AI</p>', unsafe_allow_html=True)
-    
-    # Sidebar
+
+
+def show_file_info(uploaded_file):
+    size_mb = len(uploaded_file.getvalue()) / (1024 * 1024)
+    st.info(f"Selected: **{uploaded_file.name}** ({size_mb:.1f} MB)")
+
+
+def show_results(result: Dict[str, Any]):
+    summary_text = result["summary"]["summary"]
+    stats = result["summary"]["statistics"]
+    original_stats = result["extraction"]["statistics"]
+
+    st.success("Summary ready!")
+
+    col1, col2, col3, col4 = st.columns(4)
+    col1.metric("Pages", result["validation"]["pages"])
+    col2.metric("Original words", f"{original_stats.get('total_words', 0):,}")
+    col3.metric("Summary words", f"{stats.get('final_summary_length', 0):,}")
+    compression = stats.get("overall_compression_ratio", 0)
+    col4.metric("Compression", f"{compression:.1%}" if compression else "N/A")
+
+    st.subheader("Summary")
+    st.text_area("Generated summary", value=summary_text, height=400, label_visibility="collapsed")
+
+    st.download_button(
+        label="Download summary",
+        data=summary_text.encode("utf-8"),
+        file_name=f"{result['metadata'].get('title', 'summary').replace(' ', '_')}.txt",
+        mime="text/plain",
+    )
+
+    st.subheader("Book snapshot")
+    preview = result["extraction"]["text"][:1500]
+    if len(result["extraction"]["text"]) > 1500:
+        preview += " ..."
+    st.text_area("First 1500 characters", value=preview, height=220, label_visibility="collapsed")
+
+
+def main():
+    st.title("📚 AI-Powered Book Summarizer")
+    st.write(
+        "Upload a PDF (under 50MB) to generate a concise summary locally with free, open models. "
+        "No paid API keys required—first run will download model weights."
+    )
+
+    st.divider()
+
     with st.sidebar:
-        st.header("⚙️ Settings")
-        
-        # Model selection
-        st.subheader("AI Model")
-        try:
-            models_response = requests.get(f"{API_BASE_URL}/models")
-            if models_response.status_code == 200:
-                models_data = models_response.json()
-                models = models_data.get('models', [])
-                current_model = models_data.get('current_model', '')
-                
-                model_names = [model['name'] for model in models]
-                selected_model = st.selectbox(
-                    "Choose AI Model",
-                    model_names,
-                    index=model_names.index(current_model) if current_model in model_names else 0
-                )
-                
-                # Show model description
-                selected_model_info = next((m for m in models if m['name'] == selected_model), None)
-                if selected_model_info:
-                    st.info(f"**{selected_model_info['description']}**")
-            else:
-                st.error("Failed to load models")
-                selected_model = "facebook/bart-large-cnn"
-        except Exception as e:
-            st.error(f"Error loading models: {str(e)}")
-            selected_model = "facebook/bart-large-cnn"
-        
-        # Summary settings
-        st.subheader("Summary Settings")
-        max_length = st.slider("Maximum Summary Length", 50, 500, 150, help="Maximum number of words in the summary")
-        min_length = st.slider("Minimum Summary Length", 10, 200, 50, help="Minimum number of words in the summary")
-        
-        # Advanced settings
-        with st.expander("Advanced Settings"):
-            chunk_size = st.slider("Chunk Size", 500, 2000, 1000, help="Size of text chunks for processing")
-            overlap = st.slider("Chunk Overlap", 50, 200, 100, help="Overlap between text chunks")
-        
-        # API status
-        st.subheader("API Status")
-        try:
-            health_response = requests.get(f"{API_BASE_URL}/health")
-            if health_response.status_code == 200:
-                st.success("✅ API Connected")
-            else:
-                st.error("❌ API Error")
-        except:
-            st.error("❌ API Unavailable")
-    
-    # Main content
-    tab1, tab2, tab3 = st.tabs(["📖 Summarize Book", "📊 Text Analysis", "ℹ️ About"])
-    
-    with tab1:
-        st.header("📖 Book Summarization")
-        
-        # File upload
-        uploaded_file = st.file_uploader(
-            "Choose a PDF book file",
-            type=['pdf'],
-            help="Upload a PDF file (max 50MB)"
-        )
-        
-        if uploaded_file is not None:
-            # File info
-            file_size = len(uploaded_file.getvalue()) / (1024 * 1024)  # MB
-            st.info(f"📄 **File:** {uploaded_file.name} ({file_size:.1f} MB)")
-            
-            # Validate file
-            if st.button("🔍 Validate PDF", type="secondary"):
-                with st.spinner("Validating PDF..."):
-                    try:
-                        files = {"file": uploaded_file.getvalue()}
-                        response = requests.post(f"{API_BASE_URL}/upload-pdf", files=files)
-                        
-                        if response.status_code == 200:
-                            data = response.json()
-                            st.success(f"✅ {data['message']}")
-                            
-                            # Display metadata
-                            metadata = data.get('metadata', {})
-                            col1, col2, col3 = st.columns(3)
-                            with col1:
-                                st.metric("Pages", data['pages'])
-                            with col2:
-                                st.metric("Size", f"{data['size_mb']:.1f} MB")
-                            with col3:
-                                st.metric("Title", metadata.get('title', 'Unknown'))
-                        else:
-                            st.error(f"❌ Validation failed: {response.json().get('detail', 'Unknown error')}")
-                    except Exception as e:
-                        st.error(f"❌ Error: {str(e)}")
-            
-            # Summarize button
-            if st.button("🚀 Generate Summary", type="primary"):
-                if uploaded_file is not None:
-                    with st.spinner("Processing your book..."):
-                        try:
-                            # Prepare request
-                            files = {"file": uploaded_file.getvalue()}
-                            data = {
-                                "max_length": max_length,
-                                "min_length": min_length,
-                                "chunk_size": chunk_size,
-                                "overlap": overlap,
-                                "model_name": selected_model
-                            }
-                            
-                            # Send request
-                            response = requests.post(f"{API_BASE_URL}/summarize", files=files, data=data)
-                            
-                            if response.status_code == 200:
-                                result = response.json()
-                                
-                                # Display success message
-                                st.success("✅ Summary generated successfully!")
-                                
-                                # Display statistics
-                                col1, col2, col3, col4 = st.columns(4)
-                                stats = result.get('statistics', {})
-                                orig_stats = result.get('original_statistics', {})
-                                
-                                with col1:
-                                    st.metric("Original Words", f"{orig_stats.get('total_words', 0):,}")
-                                with col2:
-                                    st.metric("Summary Words", f"{stats.get('final_summary_length', 0):,}")
-                                with col3:
-                                    compression = stats.get('overall_compression_ratio', 0)
-                                    st.metric("Compression", f"{compression:.1%}")
-                                with col4:
-                                    st.metric("Chunks Processed", stats.get('total_chunks', 0))
-                                
-                                # Display summary
-                                st.subheader("📝 Generated Summary")
-                                summary = result.get('summary', '')
-                                st.text_area(
-                                    "Summary",
-                                    value=summary,
-                                    height=400,
-                                    disabled=True
-                                )
-                                
-                                # Download button
-                                summary_bytes = summary.encode('utf-8')
-                                st.download_button(
-                                    label="📥 Download Summary",
-                                    data=summary_bytes,
-                                    file_name=f"{uploaded_file.name.replace('.pdf', '')}_summary.txt",
-                                    mime="text/plain"
-                                )
-                                
-                            else:
-                                error_msg = response.json().get('detail', 'Unknown error')
-                                st.error(f"❌ Summarization failed: {error_msg}")
-                                
-                        except Exception as e:
-                            st.error(f"❌ Error: {str(e)}")
-    
-    with tab2:
-        st.header("📊 Text Analysis")
-        
-        if uploaded_file is not None:
-            if st.button("📊 Analyze Text"):
-                with st.spinner("Analyzing text..."):
-                    try:
-                        files = {"file": uploaded_file.getvalue()}
-                        response = requests.post(f"{API_BASE_URL}/extract-text", files=files)
-                        
-                        if response.status_code == 200:
-                            data = response.json()
-                            stats = data.get('statistics', {})
-                            
-                            # Display statistics
-                            col1, col2, col3, col4 = st.columns(4)
-                            
-                            with col1:
-                                st.metric("Total Words", f"{stats.get('total_words', 0):,}")
-                            with col2:
-                                st.metric("Total Sentences", f"{stats.get('total_sentences', 0):,}")
-                            with col3:
-                                st.metric("Avg Words/Sentence", f"{stats.get('average_words_per_sentence', 0):.1f}")
-                            with col4:
-                                st.metric("Reading Time", f"{stats.get('estimated_reading_time_minutes', 0):.1f} min")
-                            
-                            # Text preview
-                            st.subheader("📄 Text Preview")
-                            text_response = requests.post(f"{API_BASE_URL}/extract-text", files=files)
-                            if text_response.status_code == 200:
-                                text_data = text_response.json()
-                                preview_text = text_data.get('text', '')[:1000] + "..." if len(text_data.get('text', '')) > 1000 else text_data.get('text', '')
-                                st.text_area("First 1000 characters:", value=preview_text, height=200, disabled=True)
-                        else:
-                            st.error(f"❌ Analysis failed: {response.json().get('detail', 'Unknown error')}")
-                    except Exception as e:
-                        st.error(f"❌ Error: {str(e)}")
-        else:
-            st.info("📄 Please upload a PDF file to analyze its text.")
-    
-    with tab3:
-        st.header("ℹ️ About")
-        
-        st.markdown("""
-        ## 🤖 Book Summarizer AI
-        
-        This application uses advanced AI models to automatically summarize PDF books. 
-        It processes the text in chunks and generates comprehensive summaries while 
-        maintaining the key information and context.
-        
-        ### ✨ Features
-        
-        - **PDF Text Extraction**: Advanced PDF processing with fallback methods
-        - **AI Summarization**: State-of-the-art transformer models
-        - **Configurable Settings**: Adjust summary length and processing parameters
-        - **Multiple Models**: Choose from different AI models for various use cases
-        - **Text Analysis**: Detailed statistics about the book content
-        
-        ### 🛠️ Technology Stack
-        
-        - **Frontend**: Streamlit
-        - **Backend**: FastAPI
-        - **AI Models**: Hugging Face Transformers (BART, T5)
-        - **PDF Processing**: PyPDF2, pdfplumber
-        - **Text Processing**: NLTK
-        
-        ### 📋 How It Works
-        
-        1. **Upload**: Select a PDF book file (max 50MB)
-        2. **Extract**: The system extracts and cleans text from the PDF
-        3. **Chunk**: Large texts are split into manageable chunks
-        4. **Summarize**: AI models process each chunk and generate summaries
-        5. **Combine**: Individual summaries are combined into a final summary
-        6. **Download**: Get your summary in text format
-        
-        ### 🚀 Getting Started
-        
-        1. Make sure the API server is running (`uvicorn api.main:app --reload`)
-        2. Upload a PDF book file
-        3. Configure your preferred settings
-        4. Click "Generate Summary" and wait for processing
-        5. Download your AI-generated summary
-        
-        ### 📞 Support
-        
-        For issues or questions, please check the API documentation at `/docs` 
-        when the server is running.
-        """)
+        controls = sidebar_controls()
+
+    uploaded_file = st.file_uploader("Upload a PDF", type=["pdf"])
+
+    if uploaded_file:
+        show_file_info(uploaded_file)
+        if st.button("Generate summary", type="primary"):
+            with st.spinner("Extracting text and generating summary..."):
+                try:
+                    result = summarize_pdf(
+                        uploaded_file=uploaded_file,
+                        model_name=controls["model"],
+                        max_length=controls["max_length"],
+                        min_length=controls["min_length"],
+                        chunk_size=controls["chunk_size"],
+                        overlap=controls["overlap"],
+                    )
+                    show_results(result)
+                except Exception as exc:
+                    st.error(f"Could not summarize this PDF: {exc}")
+    else:
+        st.info("Upload a small/medium PDF to get started. Scans or image-only PDFs will not work well.")
+
 
 if __name__ == "__main__":
-    main() 
+    main()

requirements.txt

@@ -1,12 +1,6 @@
 streamlit==1.28.1
-fastapi==0.104.1
-uvicorn==0.24.0
-python-multipart==0.0.6
 PyPDF2==3.0.1
 pdfplumber==0.10.3
 transformers==4.35.2
 torch>=2.2.0
-nltk==3.8.1
-requests==2.31.0
-python-dotenv==1.0.0
-pydantic==2.5.0 
+sentencepiece>=0.1.99

start.bat

@@ -1,32 +1,23 @@
 @echo off
-echo 📚 Book Summarizer AI - Windows Startup
-echo ======================================
+echo Book Summarizer - Windows Startup
+echo ================================
 
-echo.
-echo 🔧 Checking Python installation...
 python --version >nul 2>&1
 if errorlevel 1 (
-    echo ❌ Python is not installed or not in PATH
-    echo Please install Python from https://python.org
+    echo Python is not installed or not in PATH.
     pause
     exit /b 1
 )
 
-echo ✅ Python found
-
-echo.
-echo 📦 Installing dependencies...
+echo Installing dependencies (if needed)...
 pip install -r requirements.txt
 if errorlevel 1 (
-    echo ❌ Failed to install dependencies
+    echo Failed to install dependencies.
     pause
     exit /b 1
 )
 
-echo ✅ Dependencies installed
-
-echo.
-echo 🚀 Starting Book Summarizer AI...
-python start.py
+echo Launching Streamlit...
+python -m streamlit run app.py --server.port 8501 --server.address 0.0.0.0
 
-pause 
+pause

start.py

@@ -1,135 +1,36 @@
 #!/usr/bin/env python3
 """
-Startup script for Book Summarizer AI
-This script helps you start both the FastAPI backend and Streamlit frontend.
+Minimal launcher for the Streamlit book summarizer.
 """
 
 import subprocess
 import sys
-import time
-import requests
-import os
-from pathlib import Path
 
-def check_dependencies():
-    """Check if required packages are installed."""
-    required_packages = [
-        'streamlit', 'fastapi', 'uvicorn', 'transformers', 
-        'torch', 'PyPDF2', 'pdfplumber', 'nltk'
-    ]
-    
-    missing_packages = []
-    for package in required_packages:
-        try:
-            __import__(package)
-        except ImportError:
-            missing_packages.append(package)
-    
-    if missing_packages:
-        print("❌ Missing required packages:")
-        for package in missing_packages:
-            print(f"   - {package}")
-        print("\n📦 Install them with: pip install -r requirements.txt")
-        return False
-    
-    print("✅ All dependencies are installed")
-    return True
 
-def download_nltk_data():
-    """Download required NLTK data."""
-    try:
-        import nltk
-        nltk.download('punkt', quiet=True)
-        nltk.download('stopwords', quiet=True)
-        print("✅ NLTK data downloaded")
-    except Exception as e:
-        print(f"⚠️  Warning: Could not download NLTK data: {e}")
-
-def check_api_health():
-    """Check if the API is running and healthy."""
-    try:
-        response = requests.get("http://localhost:8000/health", timeout=5)
-        return response.status_code == 200
-    except:
-        return False
-
-def start_api():
-    """Start the FastAPI backend."""
-    print("🚀 Starting FastAPI backend...")
-    
-    # Check if API is already running
-    if check_api_health():
-        print("✅ API is already running")
-        return True
-    
-    try:
-        # Start the API server
-        api_process = subprocess.Popen([
-            sys.executable, "-m", "uvicorn", 
-            "api.main:app", 
-            "--reload", 
-            "--port", "8000",
-            "--host", "0.0.0.0"
-        ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        
-        # Wait for API to start
-        print("⏳ Waiting for API to start...")
-        for i in range(30):  # Wait up to 30 seconds
-            time.sleep(1)
-            if check_api_health():
-                print("✅ API started successfully")
-                return True
-        
-        print("❌ API failed to start within 30 seconds")
-        return False
-        
-    except Exception as e:
-        print(f"❌ Error starting API: {e}")
-        return False
-
-def start_frontend():
-    """Start the Streamlit frontend."""
-    print("🌐 Starting Streamlit frontend...")
-    
+def main():
+    print("Starting Streamlit app...")
+    print("If dependencies are missing, install with: pip install -r requirements.txt\n")
     try:
-        # Start Streamlit
-        subprocess.run([
-            sys.executable, "-m", "streamlit", "run", "app.py",
-            "--server.port", "8501",
-            "--server.address", "0.0.0.0"
-        ])
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "streamlit",
+                "run",
+                "app.py",
+                "--server.port",
+                "8501",
+                "--server.address",
+                "0.0.0.0",
+            ],
+            check=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        print(f"Streamlit exited with an error: {exc}")
+        sys.exit(exc.returncode)
     except KeyboardInterrupt:
-        print("\n👋 Shutting down...")
-    except Exception as e:
-        print(f"❌ Error starting frontend: {e}")
+        print("\nStopping Streamlit...")
 
-def main():
-    """Main startup function."""
-    print("📚 Book Summarizer AI - Startup")
-    print("=" * 40)
-    
-    # Check dependencies
-    if not check_dependencies():
-        sys.exit(1)
-    
-    # Download NLTK data
-    download_nltk_data()
-    
-    print("\n🔧 Starting services...")
-    
-    # Start API
-    if not start_api():
-        print("❌ Failed to start API. Please check the logs.")
-        sys.exit(1)
-    
-    print("\n🎉 Ready! Opening the application...")
-    print("📖 Frontend: http://localhost:8501")
-    print("🔌 API: http://localhost:8000")
-    print("📚 API Docs: http://localhost:8000/docs")
-    print("\n💡 Press Ctrl+C to stop the application")
-    
-    # Start frontend
-    start_frontend()
 
 if __name__ == "__main__":
-    main() 
+    main()

start.sh

@@ -1,28 +1,18 @@
 #!/bin/bash
 
-echo "📚 Book Summarizer AI - Unix/Linux/Mac Startup"
-echo "=============================================="
+echo "Book Summarizer - Startup"
+echo "========================="
 
-echo ""
-echo "🔧 Checking Python installation..."
 if ! command -v python3 &> /dev/null; then
-    echo "❌ Python 3 is not installed or not in PATH"
-    echo "Please install Python 3 from https://python.org"
+    echo "Python 3 is not installed or not in PATH."
     exit 1
 fi
 
-echo "✅ Python 3 found"
-
-echo ""
-echo "📦 Installing dependencies..."
-pip3 install -r requirements.txt
-if [ $? -ne 0 ]; then
-    echo "❌ Failed to install dependencies"
+echo "Installing dependencies (if needed)..."
+pip3 install -r requirements.txt || {
+    echo "Failed to install dependencies."
     exit 1
-fi
-
-echo "✅ Dependencies installed"
+}
 
-echo ""
-echo "🚀 Starting Book Summarizer AI..."
-python3 start.py 
+echo "Launching Streamlit..."
+python3 -m streamlit run app.py --server.port 8501 --server.address 0.0.0.0