Describe your changes here

app.py

@@ -1,64 +1,131 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from google import genai
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from time import sleep
+from typing import List
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+# Constants (ensure you secure these in production)
+GOOGLE_SEARCH_API_KEY = "AIzaSyB06LrMInO1PDO6OoUFockguFuBX9EXJM8"
+GOOGLE_SEARCH_ENGINE_ID = "a0172f6639ea44605"
+GEMINI_API_KEY = "AIzaSyDeJRqHsnRYtuCufX2VB8nH7_r35jZxk20"
+MAX_SEARCH_RESULTS = 10
 
+# --- Your original functions (unchanged) ---
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+def initialize_apis():
+    try:
+        gemini_client = genai.Client(api_key=GEMINI_API_KEY)
+        search_service = build("customsearch", "v1", developerKey=GOOGLE_SEARCH_API_KEY)
+        test_search = search_service.cse().list(q="test", cx=GOOGLE_SEARCH_ENGINE_ID, num=1).execute()
+        if not test_search.get('items'):
+            print("⚠️ Warning: Test search returned no results. Check CX configuration.")
+        return gemini_client, search_service
+    except Exception as e:
+        raise Exception(f"Initialization failed: {str(e)}")
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+def execute_search(search_service, query: str) -> List[str]:
+    print(f"🔍 Searching for: {query}")
+    try:
+        response = search_service.cse().list(q=query, cx=GOOGLE_SEARCH_ENGINE_ID, num=MAX_SEARCH_RESULTS).execute()
+        print(f"Response keys: {list(response.keys())}")
+        items = response.get('items', [])
+        print(f"Found {len(items)} results")
+        return [item["link"] for item in items]
+    except HttpError as e:
+        print(f"HTTP Error {e.resp.status}: {e._get_reason()}")
+        return []
+    except Exception as e:
+        print(f"Search failed: {str(e)}")
+        return []
 
-    messages.append({"role": "user", "content": message})
+def plan_research_strategy(client: genai.Client, research_topic: str) -> List[str]:
+    prompt = f"""Generate 3-5 Google search queries to research: {research_topic}
+- Use general web search terms
+- Avoid special characters
+- Use common terminology
+Format as a numbered list."""
+    try:
+        response = client.models.generate_content(model="gemini-2.0-flash", contents=[prompt])
+        raw_queries = response.text.split("\n")
+        valid_queries = []
+        for q in raw_queries:
+            clean_q = q.split(". ", 1)[-1].strip()
+            if clean_q and len(clean_q) < 150:
+                valid_queries.append(clean_q)
+        print(f"Generated queries: {valid_queries}")
+        return valid_queries
+    except Exception as e:
+        raise Exception(f"Error generating queries: {e}")
 
-    response = ""
+def understand_user_request(client: genai.Client, user_request: str) -> str:
+    prompt = f"""You are a research assistant. The user provides: {user_request}. 
+First, summarize the request.
+Second, identify ambiguities needing clarification. 
+If needed, ask questions. Else confirm understanding.
+Format response as:
+Summary: [summary]
+Clarification Needed: [Yes/No]
+Questions: [questions or None]"""
+    try:
+        response = client.models.generate_content(model="gemini-2.0-flash", contents=[prompt])
+        analysis = response.text
+        print(f"Analysis: {analysis}")
+        summary = analysis.split("Summary:")[1].split("Clarification Needed:")[0].strip()
+        clarification_needed = analysis.split("Clarification Needed:")[1].split("Questions:")[0].strip()
+        questions = analysis.split("Questions:")[1].strip()
+        if clarification_needed.lower() == "yes":
+            raise Exception(f"Clarification needed: {questions}")
+        print("Understood the request.")
+        return summary
+    except Exception as e:
+        raise Exception(f"Error analyzing request: {e}")
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+def extract_content_from_url(url: str) -> str:
+    print(f"Extracting content from {url} (simulated)...")
+    sleep(0.5)
+    return f"Content from {url} [placeholder]"
 
-        response += token
-        yield response
+def summarize_information(client: genai.Client, information: str) -> str:
+    prompt = f"""Summarize the following into a detailed report:
+{information}"""
+    try:
+        response = client.models.generate_content(model="gemini-2.0-flash", contents=[prompt])
+        return response.text
+    except Exception as e:
+        print(f"Error summarizing: {e}")
+        return "Summary unavailable"
 
+# --- FastAPI app definition ---
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+app = FastAPI()
 
+class RequestPayload(BaseModel):
+    research_request: str
 
+@app.post("/predict")
+def predict(payload: RequestPayload):
+    try:
+        gemini_client, search_service = initialize_apis()
+        research_topic = understand_user_request(gemini_client, payload.research_request)
+        queries = plan_research_strategy(gemini_client, research_topic)
+        if not queries:
+            raise HTTPException(status_code=400, detail="No valid queries generated")
+        all_content = []
+        for query in queries:
+            results = execute_search(search_service, query)
+            for url in results:
+                content = extract_content_from_url(url)
+                all_content.append(content)
+        if not all_content:
+            raise HTTPException(status_code=400, detail="No content gathered from searches")
+        summary = summarize_information(gemini_client, "\n".join(all_content))
+        return {"summary": summary}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# If running locally (for testing), use:
 if __name__ == "__main__":
-    demo.launch()
+    import uvicorn
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=True)