changed

app.py

@@ -1,405 +1,13 @@
-import gradio as gr
-import os
-import torch
-import requests
-import re
-import time
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from bs4 import BeautifulSoup
-import urllib.parse
-from markdown import markdown
-
-# Set environment variables for better performance
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
-
-# Initialize the model and tokenizer
-print("Loading model... Please wait...")
-
-# Model selection - Microsoft Phi-2 (optimized for free tier)
-MODEL_ID = "microsoft/phi-2"
-
-# Load tokenizer
-tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-
-# Load model with optimizations for free tier
-model = AutoModelForCausalLM.from_pretrained(
-    MODEL_ID,
-    torch_dtype=torch.float16,  # Use float16 for efficiency
-    device_map="auto",          # Auto-decide CPU/GPU usage
-    load_in_4bit=True,          # 4-bit quantization for extreme memory efficiency
-    trust_remote_code=True
-)
-
-def search_web(query, max_results=3):
-    """Search the web using direct API access - optimized for reliability"""
-    results = []
-    try:
-        # Try Wikipedia API first (most reliable on free tier)
-        wiki_url = f"https://en.wikipedia.org/w/api.php?action=opensearch&search={urllib.parse.quote(query)}&limit={max_results}&namespace=0&format=json"
-        response = requests.get(wiki_url)
-        
-        if response.status_code == 200:
-            data = response.json()
-            titles = data[1]
-            urls = data[3]
-            
-            for i in range(min(len(titles), len(urls))):
-                # Get summary for each page
-                page_url = f"https://en.wikipedia.org/w/api.php?action=query&prop=extracts&exintro&explaintext&titles={urllib.parse.quote(titles[i])}&format=json"
-                page_response = requests.get(page_url)
-                
-                if page_response.status_code == 200:
-                    page_data = page_response.json()
-                    # Extract page ID
-                    try:
-                        page_id = next(iter(page_data['query']['pages'].keys()))
-                        if page_id != "-1":  # Valid page
-                            extract = page_data['query']['pages'][page_id].get('extract', '')
-                            # Truncate to a reasonable snippet length
-                            snippet = extract[:200] + "..." if len(extract) > 200 else extract
-                            
-                            results.append({
-                                'title': f"Wikipedia - {titles[i]}",
-                                'url': urls[i],
-                                'snippet': snippet
-                            })
-                    except Exception as e:
-                        print(f"Error extracting Wikipedia data: {e}")
-    except Exception as e:
-        print(f"Wikipedia API error: {e}")
-    
-    # If we don't have enough results from Wikipedia, try SerpAPI demo
-    if len(results) < max_results:
-        try:
-            serpapi_url = f"https://serpapi.com/search.json?engine=google&q={urllib.parse.quote(query)}&api_key=demo"
-            response = requests.get(serpapi_url)
-            
-            if response.status_code == 200:
-                data = response.json()
-                if "organic_results" in data:
-                    for result in data["organic_results"]:
-                        if len(results) >= max_results:
-                            break
-                        results.append({
-                            'title': result.get('title', ''),
-                            'url': result.get('link', ''),
-                            'snippet': result.get('snippet', '')
-                        })
-        except Exception as e:
-            print(f"SerpAPI error: {e}")
-    
-    # If we still don't have enough results, use fallback
-    if len(results) < max_results:
-        fallback_results = [
-            {
-                'title': f"Search results for {query}",
-                'url': f"https://www.google.com/search?q={urllib.parse.quote(query)}",
-                'snippet': f"Find information about {query} from various sources."
-            },
-            {
-                'title': f"{query} - Overview",
-                'url': f"https://en.wikipedia.org/wiki/Special:Search?search={urllib.parse.quote(query)}",
-                'snippet': f"Learn about {query} on Wikipedia, the free encyclopedia."
-            },
-            {
-                'title': f"Latest on {query}",
-                'url': f"https://news.google.com/search?q={urllib.parse.quote(query)}",
-                'snippet': f"Recent news and updates about {query}."
-            }
-        ]
-        
-        # Add fallback results until we have enough
-        for result in fallback_results:
-            if len(results) >= max_results:
-                break
-            results.append(result)
-    
-    return results[:max_results]
-
-# Cache for frequently searched queries
-answer_cache = {}
-
-def generate_response(prompt, max_new_tokens=512):
-    """Generate response using Phi-2 - optimized for speed"""
-    try:
-        # Format for Phi-2
-        phi_prompt = f"Instruct: {prompt}\nOutput:"
-        
-        # Tokenize input
-        inputs = tokenizer(phi_prompt, return_tensors="pt").to(model.device)
-        
-        # Generate with efficient settings
-        with torch.no_grad():
-            outputs = model.generate(
-                inputs.input_ids,
-                max_new_tokens=max_new_tokens,
-                temperature=0.7,
-                top_p=0.9,
-                num_beams=1,  # Greedy decoding for speed
-                do_sample=True,
-                pad_token_id=tokenizer.eos_token_id
-            )
-        
-        # Decode response
-        response = tokenizer.decode(outputs[0][inputs.input_ids.size(1):], skip_special_tokens=True).strip()
-        return response
-    
-    except Exception as e:
-        print(f"Error generating response: {e}")
-        return "I couldn't generate a response. Please try again with a different query."
-
-def extract_citations(text, search_results):
-    """Ensure citations are properly added to the text"""
-    if not re.search(r'\[\d+\]', text):
-        # Add citations if not present
-        for i, result in enumerate(search_results, 1):
-            # Try to find snippet content in the answer
-            key_phrases = result['snippet'].split('.')
-            for phrase in key_phrases:
-                if len(phrase) > 20 and phrase.strip() in text:
-                    text = text.replace(phrase, f"{phrase} [{i}]", 1)
-    
-    return text
-
-def generate_related_topics(query, answer):
-    """Generate related topics - optimized for speed"""
-    # Pre-defined topics for common queries
-    query_lower = query.lower()
-    
-    if "quantum" in query_lower and "comput" in query_lower:
-        return [
-            "How does quantum entanglement work?",
-            "What are qubits?",
-            "Real-world applications of quantum computing"
-        ]
-    elif "artificial intelligence" in query_lower or "ai" == query_lower or "machine learning" in query_lower:
-        return [
-            "Differences between AI and machine learning",
-            "How does deep learning work?",
-            "Ethical concerns in artificial intelligence"
-        ]
-    elif "climate" in query_lower or "global warming" in query_lower:
-        return [
-            "How does carbon capture work?",
-            "Impact of climate change on ecosystems",
-            "Renewable energy technologies"
-        ]
-    else:
-        # Generate simple variations for any query
-        return [
-            f"History of {query}",
-            f"Latest developments in {query}",
-            f"How does {query} work?"
-        ]
-
-def search_and_answer(query):
-    """Main function to search and generate answer - optimized for free tier"""
-    try:
-        # Check cache first
-        cache_key = query.lower().strip()
-        if cache_key in answer_cache:
-            return answer_cache[cache_key]
-        
-        # Step 1: Search the web
-        search_results = search_web(query, max_results=3)
-        
-        if not search_results:
-            return {
-                "answer": "I couldn't find relevant information for this query. Please try a different search term.",
-                "sources": [],
-                "related_topics": []
-            }
-        
-        # Step 2: Create context for the model - keep it concise for smaller model
-        context = f"Query: {query}\n\nSearch Results:\n\n"
-        
-        for i, result in enumerate(search_results, 1):
-            context += f"Source {i}:\n"
-            context += f"Title: {result['title']}\n"
-            context += f"Content: {result['snippet']}\n\n"
-        
-        # Step 3: Create prompt for the model - optimized for Phi-2
-        prompt = f"""You are a helpful AI assistant that provides accurate and comprehensive answers based on search results.
-
-{context}
-
-Based on these search results, please provide a concise answer to the query: "{query}"
-Include citations like [1], [2], etc. to reference the sources.
-Be factual and accurate. If the search results don't contain enough information, acknowledge this limitation.
-Format your answer in clear paragraphs with bullet points where appropriate."""
-        
-        # Step 4: Generate answer with optimized settings
-        answer = generate_response(prompt, max_new_tokens=384)  # Shorter for efficiency
-        
-        # Step 5: Ensure citations
-        answer = extract_citations(answer, search_results)
-        
-        # Step 6: Generate related topics efficiently
-        related_topics = generate_related_topics(query, answer)
-        
-        # Store in cache for future use
-        result = {
-            "answer": answer,
-            "sources": search_results,
-            "related_topics": related_topics
-        }
-        answer_cache[cache_key] = result
-        
-        return result
-    
-    except Exception as e:
-        print(f"Error in search_and_answer: {e}")
-        return {
-            "answer": f"An error occurred while processing your query. Please try again.",
-            "sources": [],
-            "related_topics": []
-        }
-
-def format_sources(sources):
-    """Format sources for display"""
-    if not sources:
-        return ""
-    
-    html = ""
-    for i, source in enumerate(sources, 1):
-        html += f"""
-        <div style="margin-bottom: 15px; padding: 15px; background-color: #f8f9fa; 
-                   border-radius: 8px; border-left: 4px solid #1976d2;">
-            <a href="{source['url']}" target="_blank" style="font-weight: bold; 
-                                                            color: #1976d2; text-decoration: none;">
-                {source['title']}
-            </a>
-            <div style="color: #5f6368; font-size: 14px; margin-top: 5px;">{source['url']}</div>
-            <div style="margin-top: 10px;">{source['snippet']}</div>
-        </div>
-        """
-    return html
-
-def format_related(topics):
-    """Format related topics for display"""
-    if not topics:
-        return ""
-    
-    html = "<div style='display: flex; flex-wrap: wrap; gap: 10px; margin-top: 10px;'>"
-    for topic in topics:
-        html += f"""
-        <div style="background-color: #e3f2fd; padding: 8px 16px; border-radius: 20px; 
-                  color: #1976d2; font-size: 14px; cursor: pointer; display: inline-block;"
-             onclick="document.getElementById('query-input').value = '{topic}'; search();">
-            {topic}
-        </div>
-        """
-    html += "</div>"
-    return html
-
-def search_interface(query):
-    """Main function for the Gradio interface"""
-    if not query.strip():
-        return (
-            "Please enter a search query.",
-            "",
-            ""
-        )
-    
-    start_time = time.time()
-    
-    # Perform search and answer generation
-    result = search_and_answer(query)
-    
-    # Format answer with markdown
-    answer_html = markdown(result["answer"])
-    
-    # Format sources
-    sources_html = format_sources(result["sources"])
-    
-    # Format related topics
-    related_html = format_related(result["related_topics"])
-    
-    # Calculate processing time
-    processing_time = time.time() - start_time
-    print(f"Query processed in {processing_time:.2f} seconds")
-    
-    return (
-        answer_html,
-        sources_html,
-        related_html
-    )
-
-# Create the Gradio interface - optimized for loading speed
-css = """
-body {
-    font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-    max-width: 1200px;
-    margin: 0 auto;
-}
-.container {
-    margin-top: 20px;
-}
-.answer {
-    border-radius: 8px;
-    background-color: white;
-    padding: 20px;
-    box-shadow: 0 1px 3px rgba(0,0,0,0.12);
-    margin-bottom: 20px;
-}
-h1 {
-    color: #1976d2;
-    font-size: 2.2rem;
-    font-weight: 600;
-    margin-bottom: 10px;
-}
-h3 {
-    color: #1976d2;
-    font-weight: 500;
-    margin-top: 25px;
-    margin-bottom: 15px;
-}
-"""
-
-with gr.Blocks(css=css) as demo:
-    gr.HTML("""
-    <h1>🔍 AI Search System</h1>
-    <p style="margin-bottom: 20px;">Powered by Microsoft Phi-2 - Ask any question and get accurate answers with sources</p>
-    """)
-    
-    with gr.Row():
-        query_input = gr.Textbox(
-            label="Search Query",
-            placeholder="Enter your search query here...",
-            elem_id="query-input"
-        )
-        search_button = gr.Button("Search 🔍", variant="primary")
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            gr.HTML("<h3>📝 Answer</h3>")
-            answer_output = gr.HTML(elem_classes=["answer"])
-            
-            gr.HTML("<h3>🔗 Related Topics</h3>")
-            related_output = gr.HTML()
-        
-        with gr.Column(scale=1):
-            gr.HTML("<h3>📚 Sources</h3>")
-            sources_output = gr.HTML()
-    
-    search_button.click(
-        fn=search_interface,
-        inputs=[query_input],
-        outputs=[answer_output, sources_output, related_output]
-    )
-    
-    query_input.submit(
-        fn=search_interface,
-        inputs=[query_input],
-        outputs=[answer_output, sources_output, related_output]
-    )
-
-    gr.HTML("""
-    <div style="margin-top: 20px; text-align: center; color: #666;">
-        <p>Built with Phi-2, Gradio, and Hugging Face Spaces</p>
-    </div>
-    """)
-    
-# Ensure quicker startup
-demo.queue(max_size=10)
-demo.launch()
+gradio==3.50.2
+transformers==4.36.2  # Version that definitely supports Phi models
+accelerate==0.25.0
+torch==2.0.1
+bitsandbytes==0.41.1
+
+# Web search dependencies
+requests==2.31.0
+beautifulsoup4==4.12.2
+
+# Utilities
+markdown==3.5.1
+numpy==1.24.3