Update src/streamlit_app.py

src/streamlit_app.py

@@ -4,8 +4,7 @@ import json
 from typing import Dict, List, Optional
 import re
 from urllib.parse import quote
-import asyncio
-import aiohttp
+import time
 
 # Configure page
 st.set_page_config(
@@ -41,48 +40,38 @@ class OllamaLLM:
     def check_connection(self) -> bool:
         """Check if Ollama is running"""
         try:
-            response = requests.get(self.models_url, timeout=5)
+            response = requests.get(self.models_url, timeout=3)
             return response.status_code == 200
-        except:
+        except Exception:
             return False
     
     def get_available_models(self) -> List[str]:
         """Get list of available models"""
         try:
-            response = requests.get(self.models_url, timeout=10)
+            response = requests.get(self.models_url, timeout=5)
             if response.status_code == 200:
                 data = response.json()
-                return [model["name"] for model in data.get("models", [])]
+                models = data.get("models", [])
+                return [model["name"] for model in models]
             return []
-        except:
+        except Exception:
             return []
     
     def generate_summary(self, text: str, model: str = "llama3.2", language: str = "English", 
                         summary_type: str = "concise") -> str:
         """Generate AI summary using local LLM"""
         try:
-            # Craft prompt based on language and summary type
+            # Truncate text if too long
+            if len(text) > 2000:
+                text = text[:2000] + "..."
+            
+            # Craft prompt based on summary type
             if summary_type == "concise":
-                prompt = f"""Summarize the following Wikipedia content in {language} in 2-3 sentences. 
-                Make it clear and informative:
-
-                {text}
-
-                Summary:"""
+                prompt = f"Summarize this Wikipedia content in {language} in 2-3 clear sentences:\n\n{text}\n\nSummary:"
             elif summary_type == "detailed":
-                prompt = f"""Provide a comprehensive summary of the following Wikipedia content in {language}. 
-                Include key points, important facts, and context:
-
-                {text}
-
-                Detailed Summary:"""
+                prompt = f"Provide a detailed summary of this Wikipedia content in {language}. Include key points and important facts:\n\n{text}\n\nDetailed Summary:"
             else:  # explanatory
-                prompt = f"""Explain the following Wikipedia content in {language} in a simple, 
-                easy-to-understand way as if explaining to someone unfamiliar with the topic:
-
-                {text}
-
-                Explanation:"""
+                prompt = f"Explain this Wikipedia content in {language} in simple terms that anyone can understand:\n\n{text}\n\nExplanation:"
             
             # Request to Ollama
             payload = {
@@ -91,7 +80,7 @@ class OllamaLLM:
                 "stream": False,
                 "options": {
                     "temperature": 0.7,
-                    "num_predict": 500 if summary_type == "detailed" else 200
+                    "num_predict": 300 if summary_type == "detailed" else 150
                 }
             }
             
@@ -99,22 +88,20 @@ class OllamaLLM:
             
             if response.status_code == 200:
                 data = response.json()
-                return data.get("response", "").strip()
+                summary = data.get("response", "").strip()
+                return summary if summary else "No summary generated"
             else:
-                return f"Error: {response.status_code}"
+                return f"Error: Status {response.status_code}"
                 
+        except requests.exceptions.Timeout:
+            return "Error: Request timeout - try a smaller text"
         except Exception as e:
-            return f"LLM Error: {str(e)}"
+            return f"Error: {str(e)}"
     
     def translate_text(self, text: str, target_language: str, model: str = "llama3.2") -> str:
         """Translate text using local LLM"""
         try:
-            prompt = f"""Translate the following text to {target_language}. 
-            Provide only the translation, no additional text:
-
-            {text}
-
-            Translation:"""
+            prompt = f"Translate this text to {target_language}. Only provide the translation:\n\n{text}\n\nTranslation:"
             
             payload = {
                 "model": model,
@@ -122,7 +109,7 @@ class OllamaLLM:
                 "stream": False,
                 "options": {
                     "temperature": 0.3,
-                    "num_predict": 300
+                    "num_predict": 200
                 }
             }
             
@@ -130,11 +117,12 @@ class OllamaLLM:
             
             if response.status_code == 200:
                 data = response.json()
-                return data.get("response", "").strip()
+                translation = data.get("response", "").strip()
+                return translation if translation else text
             else:
-                return text  # Return original if translation fails
+                return text
                 
-        except Exception as e:
+        except Exception:
             return text
 
 class WikipediaAPI:
@@ -160,6 +148,7 @@ class WikipediaAPI:
             
             data = response.json()
             return data.get("query", {}).get("search", [])
+            
         except Exception as e:
             st.error(f"Search error: {str(e)}")
             return []
@@ -174,11 +163,11 @@ class WikipediaAPI:
             response.raise_for_status()
             
             return response.json()
+            
         except Exception as e:
-            st.error(f"Summary error: {str(e)}")
             return None
     
-    def get_page_content(self, title: str, lang: str = "en", char_limit: int = 3000) -> Optional[str]:
+    def get_page_content(self, title: str, lang: str = "en", char_limit: int = 2000) -> Optional[str]:
         """Get page content sections"""
         try:
             params = {
@@ -204,23 +193,34 @@ class WikipediaAPI:
                     return page_data["extract"]
             
             return None
-        except Exception as e:
-            st.error(f"Content error: {str(e)}")
+            
+        except Exception:
             return None
 
 def clean_html(text: str) -> str:
     """Remove HTML tags from text"""
+    if not text:
+        return ""
     clean = re.compile('<.*?>')
     return re.sub(clean, '', text)
 
 def simple_summarize(text: str, max_sentences: int = 3) -> str:
     """Fallback simple text summarization"""
+    if not text:
+        return "No content available"
+    
     sentences = text.split('. ')
+    if len(sentences) <= max_sentences:
+        return text
+    
     summary_sentences = sentences[:max_sentences]
-    return '. '.join(summary_sentences) + ('.' if not summary_sentences[-1].endswith('.') else '')
+    result = '. '.join(summary_sentences)
+    if not result.endswith('.'):
+        result += '.'
+    return result
 
 def main():
-    # Custom CSS for mobile-first design
+    # Custom CSS
     st.markdown("""
     <style>
     .main-header {
@@ -230,13 +230,13 @@ def main():
     }
     .search-container {
         background-color: #f8f9fa;
-        padding: 1rem;
+        padding: 1.5rem;
         border-radius: 10px;
         margin-bottom: 1rem;
     }
     .result-card {
         background-color: white;
-        padding: 1rem;
+        padding: 1.5rem;
         border-radius: 8px;
         border: 1px solid #dee2e6;
         margin-bottom: 1rem;
@@ -245,13 +245,14 @@ def main():
     .article-title {
         color: #007bff;
         font-weight: bold;
+        font-size: 1.2rem;
         margin-bottom: 0.5rem;
     }
-    .llm-status {
-        padding: 0.5rem;
-        border-radius: 5px;
+    .status-box {
+        padding: 0.8rem;
+        border-radius: 8px;
         margin-bottom: 1rem;
-        font-size: 0.9rem;
+        font-weight: bold;
     }
     .status-connected {
         background-color: #d4edda;
@@ -270,51 +271,51 @@ def main():
         border-left: 4px solid #007bff;
         margin: 1rem 0;
     }
-    @media (max-width: 768px) {
-        .stSelectbox, .stTextInput {
-            font-size: 16px;
-        }
-    }
     </style>
     """, unsafe_allow_html=True)
     
     # Header
-    st.markdown("<h1 class='main-header'>🤖 WikiBot - AI-Powered Multilingual Assistant</h1>", unsafe_allow_html=True)
-    st.markdown("<p style='text-align: center; color: #666;'>Search Wikipedia with Local LLM Intelligence</p>", unsafe_allow_html=True)
+    st.markdown("<h1 class='main-header'>🤖 WikiBot - AI-Powered Assistant</h1>", unsafe_allow_html=True)
+    st.markdown("<p style='text-align: center; color: #666;'>Wikipedia + Local LLM Intelligence</p>", unsafe_allow_html=True)
+    
+    # Initialize session state
+    if 'search_results' not in st.session_state:
+        st.session_state.search_results = []
     
     # Initialize APIs
     wiki_api = WikipediaAPI()
     llm = OllamaLLM()
     
     # Check LLM connection
-    llm_connected = llm.check_connection()
-    available_models = llm.get_available_models() if llm_connected else []
+    with st.spinner("Checking Ollama connection..."):
+        llm_connected = llm.check_connection()
+        available_models = llm.get_available_models() if llm_connected else []
     
-    # LLM Status
+    # Status display
     if llm_connected:
         st.markdown(f"""
-        <div class='llm-status status-connected'>
-            ✅ <strong>Local LLM Connected</strong> - Ollama running with {len(available_models)} models
+        <div class='status-box status-connected'>
+            ✅ Ollama Connected - {len(available_models)} models available
         </div>
         """, unsafe_allow_html=True)
     else:
         st.markdown("""
-        <div class='llm-status status-disconnected'>
-            ❌ <strong>Local LLM Disconnected</strong> - Install and run Ollama for AI features
+        <div class='status-box status-disconnected'>
+            ❌ Ollama Offline - Basic mode only
         </div>
         """, unsafe_allow_html=True)
-        st.info("To enable AI features: Install Ollama from https://ollama.ai and run `ollama serve`")
     
-    # Search interface
+    # Main search interface
     st.markdown("<div class='search-container'>", unsafe_allow_html=True)
     
+    # Search inputs
     col1, col2 = st.columns([3, 1])
     
     with col1:
         query = st.text_input(
-            "🔍 Search Wikipedia",
-            placeholder="e.g., 'Explain Kargil War in Telugu'",
-            help="Enter your search query in any language"
+            "🔍 Search Query",
+            placeholder="e.g., 'Artificial Intelligence', 'Kargil War'",
+            help="Enter your Wikipedia search query"
         )
     
     with col2:
@@ -324,218 +325,180 @@ def main():
             index=0
         )
     
-    # Advanced options
-    with st.expander("⚙️ Advanced Options"):
-        col1, col2, col3 = st.columns(3)
-        
-        with col1:
-            num_results = st.slider("Number of results", 1, 10, 3)
-        
-        with col2:
-            if llm_connected:
-                summary_mode = st.selectbox(
-                    "AI Summary Type", 
-                    ["concise", "detailed", "explanatory"],
-                    index=0
-                )
-            else:
-                summary_mode = st.selectbox(
-                    "Summary Type", 
-                    ["short", "medium", "long"],
-                    index=1
-                )
-        
-        with col3:
-            if llm_connected and available_models:
-                selected_model = st.selectbox(
-                    "LLM Model",
-                    options=available_models,
-                    index=0
-                )
-            else:
-                st.info("No models available")
-                selected_model = None
-        
-        # Translation options
+    # Options
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        num_results = st.slider("Results", 1, 8, 3)
+    
+    with col2:
         if llm_connected:
-            col1, col2 = st.columns(2)
-            with col1:
-                enable_translation = st.checkbox("🌐 Enable Translation", value=False)
-            with col2:
-                if enable_translation:
-                    target_lang = st.selectbox(
-                        "Translate to",
-                        options=list(LANGUAGES.keys()),
-                        index=1
-                    )
+            summary_type = st.selectbox(
+                "AI Summary", 
+                ["concise", "detailed", "explanatory"]
+            )
+        else:
+            summary_type = st.selectbox(
+                "Summary", 
+                ["short", "medium", "long"]
+            )
+    
+    with col3:
+        if llm_connected and available_models:
+            selected_model = st.selectbox("Model", available_models)
+        else:
+            selected_model = None
+            st.info("No models")
+    
+    # Translation option
+    if llm_connected:
+        enable_translation = st.checkbox("🌐 Enable Translation")
+        if enable_translation:
+            target_lang = st.selectbox(
+                "Translate to", 
+                [lang for lang in LANGUAGES.keys() if lang != selected_lang]
+            )
     
     st.markdown("</div>", unsafe_allow_html=True)
     
     # Search button
-    if st.button("🔎 Search with AI", type="primary", use_container_width=True):
-        if query:
-            lang_code = LANGUAGES[selected_lang]
-            
-            with st.spinner(f"Searching Wikipedia and processing with AI..."):
-                # Search for articles
-                search_results = wiki_api.search_articles(query, lang_code, num_results)
+    search_clicked = st.button("🔎 Search", type="primary", use_container_width=True)
+    
+    if search_clicked and query:
+        lang_code = LANGUAGES[selected_lang]
+        
+        with st.spinner("Searching Wikipedia..."):
+            search_results = wiki_api.search_articles(query, lang_code, num_results)
+            st.session_state.search_results = search_results
+    
+    # Display results
+    if st.session_state.search_results:
+        st.success(f"Found {len(st.session_state.search_results)} results")
+        
+        for idx, result in enumerate(st.session_state.search_results):
+            with st.container():
+                st.markdown("<div class='result-card'>", unsafe_allow_html=True)
                 
-                if search_results:
-                    st.success(f"Found {len(search_results)} results - Processing with {'AI' if llm_connected else 'basic'} summarization")
-                    
-                    for idx, result in enumerate(search_results):
-                        with st.container():
-                            st.markdown("<div class='result-card'>", unsafe_allow_html=True)
-                            
-                            # Article title
-                            title = result.get("title", "")
-                            st.markdown(f"<div class='article-title'>{idx+1}. {title}</div>", unsafe_allow_html=True)
-                            
-                            # Get detailed content for AI processing
-                            content = wiki_api.get_page_content(title, lang_code)
-                            summary_data = wiki_api.get_page_summary(title, lang_code)
+                # Title
+                title = result.get("title", "")
+                st.markdown(f"<div class='article-title'>{idx+1}. {title}</div>", unsafe_allow_html=True)
+                
+                # Get content
+                lang_code = LANGUAGES[selected_lang]
+                summary_data = wiki_api.get_page_summary(title, lang_code)
+                
+                # Show thumbnail
+                if summary_data and "thumbnail" in summary_data:
+                    col1, col2 = st.columns([1, 4])
+                    with col1:
+                        st.image(summary_data["thumbnail"]["source"], width=100)
+                    content_col = col2
+                else:
+                    content_col = st
+                
+                with content_col:
+                    # AI Summary
+                    if llm_connected and selected_model:
+                        # Get detailed content for AI
+                        detailed_content = wiki_api.get_page_content(title, lang_code)
+                        
+                        if detailed_content:
+                            with st.spinner("Generating AI summary..."):
+                                ai_summary = llm.generate_summary(
+                                    detailed_content, 
+                                    selected_model, 
+                                    selected_lang, 
+                                    summary_type
+                                )
                             
-                            if content and llm_connected and selected_model:
-                                # AI-powered summary
-                                with st.spinner("Generating AI summary..."):
-                                    ai_summary = llm.generate_summary(
-                                        content, 
-                                        selected_model, 
-                                        selected_lang, 
-                                        summary_mode
-                                    )
+                            if ai_summary and not ai_summary.startswith("Error"):
+                                st.markdown("<div class='ai-summary'>", unsafe_allow_html=True)
+                                st.markdown("**🤖 AI Summary:**")
+                                st.write(ai_summary)
                                 
-                                if ai_summary and not ai_summary.startswith("Error") and not ai_summary.startswith("LLM Error"):
-                                    st.markdown("<div class='ai-summary'>", unsafe_allow_html=True)
-                                    st.markdown("**🤖 AI Summary:**")
-                                    st.write(ai_summary)
-                                    
-                                    # Translation if enabled
-                                    if 'enable_translation' in locals() and enable_translation and target_lang != selected_lang:
-                                        with st.spinner(f"Translating to {target_lang}..."):
-                                            translated = llm.translate_text(ai_summary, target_lang, selected_model)
-                                            if translated != ai_summary:
-                                                st.markdown(f"**🌐 Translation to {target_lang}:**")
-                                                st.write(translated)
-                                    
-                                    st.markdown("</div>", unsafe_allow_html=True)
-                                else:
-                                    # Fallback to simple summary
-                                    st.warning("AI summary failed, using fallback")
-                                    fallback_summary = simple_summarize(content, 3)
-                                    st.write(fallback_summary)
-                            
-                            elif summary_data:
-                                # Standard Wikipedia summary
-                                summary_text = summary_data.get("extract", "")
-                                if not llm_connected:
-                                    if summary_mode == "short":
-                                        summary_text = simple_summarize(summary_text, 2)
-                                    elif summary_mode == "medium":
-                                        summary_text = simple_summarize(summary_text, 4)
+                                # Translation
+                                if 'enable_translation' in locals() and enable_translation:
+                                    with st.spinner("Translating..."):
+                                        translated = llm.translate_text(ai_summary, target_lang, selected_model)
+                                        if translated != ai_summary:
+                                            st.markdown(f"**🌐 {target_lang}:**")
+                                            st.write(translated)
                                 
-                                st.write(summary_text)
-                            
+                                st.markdown("</div>", unsafe_allow_html=True)
                             else:
-                                # Fallback to search snippet
-                                snippet = clean_html(result.get("snippet", ""))
-                                st.write(snippet)
-                            
-                            # Display thumbnail if available
-                            if summary_data and "thumbnail" in summary_data:
-                                st.image(summary_data["thumbnail"]["source"], width=150)
-                            
-                            # Wikipedia link
-                            if summary_data and "content_urls" in summary_data:
-                                wiki_url = summary_data["content_urls"]["desktop"]["page"]
-                                st.markdown(f"[📖 Read full article on Wikipedia]({wiki_url})")
-                            
-                            # Detailed content button
-                            if st.button(f"📝 Show detailed content", key=f"detail_{idx}"):
-                                if content:
-                                    st.text_area(
-                                        "Full Content",
-                                        content,
-                                        height=300,
-                                        key=f"content_{idx}"
-                                    )
-                                else:
-                                    st.warning("Detailed content not available")
-                            
-                            st.markdown("</div>", unsafe_allow_html=True)
-                            st.markdown("---")
+                                st.warning("AI summary failed")
+                                if summary_data:
+                                    basic_summary = summary_data.get("extract", "")
+                                    st.write(simple_summarize(basic_summary, 3))
+                        else:
+                            st.warning("Could not fetch detailed content")
+                    
+                    else:
+                        # Basic summary
+                        if summary_data:
+                            basic_summary = summary_data.get("extract", "")
+                            if summary_type == "short":
+                                basic_summary = simple_summarize(basic_summary, 2)
+                            elif summary_type == "medium":
+                                basic_summary = simple_summarize(basic_summary, 4)
+                            st.write(basic_summary)
+                        else:
+                            snippet = clean_html(result.get("snippet", ""))
+                            st.write(snippet)
                 
-                else:
-                    st.warning(f"No results found for '{query}' in {selected_lang}")
-                    st.info("Try different keywords or switch to another language")
-        
-        else:
-            st.warning("Please enter a search query")
+                # Wikipedia link
+                if summary_data and "content_urls" in summary_data:
+                    wiki_url = summary_data["content_urls"]["desktop"]["page"]
+                    st.markdown(f"[📖 Read on Wikipedia]({wiki_url})")
+                
+                st.markdown("</div>", unsafe_allow_html=True)
+                st.markdown("---")
     
-    # Status dashboard
+    elif search_clicked and not query:
+        st.warning("Please enter a search query")
+    
+    # Footer stats
     st.markdown("---")
     col1, col2, col3, col4 = st.columns(4)
     
     with col1:
         st.metric("🌍 Languages", len(LANGUAGES))
-    
     with col2:
-        st.metric("🤖 LLM Status", "Connected" if llm_connected else "Offline")
-    
+        st.metric("🤖 LLM", "ON" if llm_connected else "OFF")
     with col3:
         st.metric("📚 Models", len(available_models))
-    
     with col4:
-        st.metric("🔍 Search Mode", "AI-Powered" if llm_connected else "Standard")
+        st.metric("📊 Results", len(st.session_state.search_results))
     
-    # Setup instructions
-    with st.expander("🛠️ Setup Instructions"):
+    # Setup guide
+    with st.expander("🛠️ Ollama Setup Guide"):
         st.markdown("""
-        ### Install Ollama for AI Features:
+        ### Quick Setup:
         
-        1. **Install Ollama:**
-           ```bash
-           # MacOS/Linux
-           curl -fsSL https://ollama.ai/install.sh | sh
-           
-           # Windows - Download from https://ollama.ai
-           ```
+        **1. Install Ollama:**
+        ```bash
+        # macOS/Linux
+        curl -fsSL https://ollama.ai/install.sh | sh
         
-        2. **Pull a model:**
-           ```bash
-           ollama pull llama3.2
-           # or
-           ollama pull mistral
-           ollama pull codellama
-           ```
+        # Windows: Download from https://ollama.ai
+        ```
         
-        3. **Start Ollama server:**
-           ```bash
-           ollama serve
-           ```
+        **2. Pull a model:**
+        ```bash
+        ollama pull llama3.2
+        ```
         
-        4. **Restart this app** - LLM features will be automatically enabled!
+        **3. Start server:**
+        ```bash
+        ollama serve
+        ```
         
-        ### Recommended Models:
-        - **llama3.2** - Great for general summarization
-        - **mistral** - Fast and efficient
-        - **codellama** - Good for technical content
-        """)
-    
-    # Usage examples
-    with st.expander("💡 Usage Examples"):
-        st.markdown("""
-        **Try these example queries:**
-        - "Explain Kargil War in Telugu" → AI generates Telugu explanation
-        - "Machine Learning" → Detailed AI summary with translation
-        - "Climate Change" → AI explanatory summary
-        - "Quantum Computing" → Technical AI analysis
+        **4. Refresh this page!**
         
-        **AI Features:**
-        - 🤖 Intelligent summarization (concise/detailed/explanatory)
-        - 🌐 Multi-language translation
-        - 📝 Context-aware explanations
-        - 🔍 Enhanced content understanding
+        ### Recommended Models:
+        - `llama3.2` - Best overall performance
+        - `mistral` - Fast and efficient
+        - `qwen2` - Good for multilingual content
         """)
 
 if __name__ == "__main__":