Update app.py

app.py

@@ -1,141 +1,88 @@
 import gradio as gr
 import requests
-from html import escape
-from typing import List, Tuple
+import os
+from duckduckgo_search import DDGS
+from transformers import pipeline
 
-# API endpoints
-API_URL = "https://aham2api-3.onrender.com/v1/chat/completions"  # Update with your API URL
-MODELS_URL = "https://aham2api-3.onrender.com/v1/models"  # Update with your API URL
+# Initialize the DuckDuckGo search client
+ddgs = DDGS()
 
-# CSS for styling
-css = """
-/* Your existing CSS remains the same */
-"""
+# Initialize the language model for answering
+model_id = "meta-llama/Meta-Llama-3-8B-Instruct"  # You can change this to any model you prefer
+try:
+    answerer = pipeline("text-generation", model=model_id, max_length=512)
+except:
+    # Fallback to a smaller model if the primary one fails
+    answerer = pipeline("text-generation", model="google/flan-t5-base", max_length=512)
 
-def get_available_models() -> List[str]:
-    """Fetch available models from the API."""
+def search_web(query, num_results=5):
+    """Search the web using DuckDuckGo and return results."""
     try:
-        response = requests.get(MODELS_URL, timeout=30)
-        response.raise_for_status()
-        models_data = response.json()
-        return sorted([model['id'] for model in models_data.get('data', [])])
+        results = list(ddgs.text(query, max_results=num_results))
+        return results
     except Exception as e:
-        print(f"Error fetching models: {e}")
-        return [
-            "samura-deepseek-r1",
-            "samura-gpt-4o",
-            "groq-llama3-70b-8192"
-        ]
+        return [{"title": f"Error searching: {str(e)}", "body": "", "href": ""}]
 
-def chat_completion(
-    messages: List[dict],
-    model: str,
-) -> dict:
-    """Send chat completion request to the API."""
-    headers = {"Content-Type": "application/json"}
-    data = {
-        "model": model,
-        "messages": messages,
-        "temperature": 0.7,
-        "max_tokens": 2000,
-        "stream": False
-    }
+def format_search_results(results):
+    """Format search results into a readable text format."""
+    formatted = "### Search Results:\n\n"
+    for i, result in enumerate(results, 1):
+        title = result.get("title", "No title")
+        body = result.get("body", "No description")
+        href = result.get("href", "No link")
+        formatted += f"**{i}. {title}**\n{body}\n[Link]({href})\n\n"
+    return formatted
+
+def generate_answer(query, search_results):
+    """Generate an answer based on the search results."""
+    context = format_search_results(search_results)
+    prompt = f"""You are DeepSearch, a helpful AI assistant with web search capabilities.
     
-    try:
-        response = requests.post(API_URL, headers=headers, json=data, timeout=30)
-        response.raise_for_status()
-        return response.json()
-    except Exception as e:
-        return {"error": str(e)}
+Based on the following search results, please answer the user's question: "{query}"
 
-def format_message(text: str) -> str:
-    """Format message with HTML for display."""
-    return escape(text).replace("\n", "<br>")
+{context}
 
-def chat_interface(
-    message: str,
-    chat_history: List[Tuple[str, str]],
-    model: str,
-) -> Tuple[List[Tuple[str, str]], str]:
-    """Handle chat interface interactions."""
-    if not message.strip():
-        return chat_history, ""
-    
-    # Convert chat history to API format
-    messages = []
-    for user_msg, assistant_msg in chat_history:
-        messages.append({
-            "role": "user",
-            "content": user_msg.replace("<br>", "\n")
-        })
-        if assistant_msg:
-            messages.append({
-                "role": "assistant",
-                "content": assistant_msg.replace("<br>", "\n")
-            })
+Please provide a comprehensive answer using the information from the search results. If the search results don't contain relevant information, say so and provide your best answer based on your knowledge.
+
+Answer:"""
     
-    # Add current message
-    messages.append({
-        "role": "user",
-        "content": message
-    })
+    try:
+        response = answerer(prompt, max_length=800, do_sample=True, temperature=0.7)[0]['generated_text']
+        # Extract just the answer part after the prompt
+        answer = response.split("Answer:")[-1].strip()
+        return answer
+    except Exception as e:
+        return f"Error generating answer: {str(e)}"
+
+def deep_search(message, history):
+    """Main function to handle the chat interaction."""
+    # First, search the web for relevant information
+    search_results = search_web(message)
     
-    # Get API response
-    response = chat_completion(messages=messages, model=model)
+    # If no results, return a message
+    if not search_results:
+        return "I couldn't find any information on that topic. Please try a different question."
     
-    if "error" in response:
-        assistant_message = f"Error: {response['error']}"
-    else:
-        assistant_message = response.get("choices", [{}])[0].get("message", {}).get("content", "No response")
+    # Generate an answer based on the search results
+    answer = generate_answer(message, search_results)
     
-    # Update chat history
-    chat_history.append((format_message(message), format_message(assistant_message)))
-    return chat_history, ""
+    # Return the answer
+    return answer
 
-def create_interface():
-    """Create Gradio chat interface."""
-    available_models = get_available_models()
-    
-    with gr.Blocks(css=css, theme=gr.themes.Default()) as demo:
-        gr.Markdown("# API Chat Interface")
-        
-        model_dropdown = gr.Dropdown(
-            choices=available_models,
-            value=available_models[0] if available_models else "samura-deepseek-r1",
-            label="Select Model"
-        )
-        
-        chatbot = gr.Chatbot(
-            elem_classes=["chatbot"],
-            bubble_full_width=False,
-            height=500
-        )
-        
-        with gr.Row():
-            message = gr.Textbox(
-                placeholder="Type your message here...",
-                show_label=False,
-                container=False,
-                scale=7
-            )
-            submit = gr.Button("Send", variant="primary", scale=1)
-        
-        clear = gr.ClearButton([message, chatbot])
-        
-        submit.click(
-            fn=chat_interface,
-            inputs=[message, chatbot, model_dropdown],
-            outputs=[chatbot, message]
-        )
-        
-        message.submit(
-            fn=chat_interface,
-            inputs=[message, chatbot, model_dropdown],
-            outputs=[chatbot, message]
-        )
-    
-    return demo
+# Create the Gradio interface
+demo = gr.ChatInterface(
+    fn=deep_search,
+    title="DeepSearch Agent",
+    description="Ask me anything! I'll search the web using DuckDuckGo and provide an answer based on the search results.",
+    examples=[
+        "What is the capital of France?",
+        "How does photosynthesis work?",
+        "What are the latest developments in AI?",
+        "Who won the last World Cup?",
+        "What is the recipe for chocolate chip cookies?"
+    ],
+    theme="soft"
+)
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch()
+    demo.launch()