Upload 2 files

app.py

@@ -0,0 +1,405 @@
+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()

requirements.txt

@@ -0,0 +1,13 @@
+gradio==3.50.2
+torch==2.0.1
+transformers==4.35.2
+accelerate==0.25.0
+bitsandbytes==0.40.2
+markdown==3.5.1
+
+# Web search dependencies (minimized)
+requests==2.31.0
+beautifulsoup4==4.12.2
+
+# Utilities (minimized)
+numpy==1.24.3