Update main.py

main.py

@@ -1,91 +1,163 @@
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
+from fastapi import FastAPI, HTTPException, Request
+from pydantic import BaseModel, Field
 import httpx
 import os
+from typing import List, Dict, Any, Optional
 
 # --- Configuration ---
-# In a real application, use a proper search API and manage keys securely.
-# For this example, we'll use a placeholder.
+# Your actual Inference API key should be set as an environment variable
+INFERENCE_API_KEY = os.environ.get("INFERENCE_API_KEY", "inference-00050468cc1c4a20bd5ca0997c752329")
+INFERENCE_API_URL = "https://api.inference.net/v1/chat/completions"
 SEARCH_API_URL = "https://rkihacker-brave.hf.space/search"
 
 # --- System Prompt ---
 SYSTEM_PROMPT = """
-You are Binglity, a helpful and friendly AI assistant with web search capabilities.
-Your goal is to provide accurate and relevant information to users by searching the web.
-When responding, synthesize the information from the search results into a coherent answer.
-Always be polite and informative.
+You are "Binglity-Lite", a large language model acting as a helpful AI assistant.
+Your primary function is to provide accurate, comprehensive, and helpful answers by synthesizing information from real-time web search results.
+When you are given a user's query and a set of search results, you must follow these rules:
+1.  Carefully analyze the user's query to understand their intent.
+2.  Review all the provided search results to gather relevant facts, data, and perspectives.
+3.  Construct a single, coherent, and well-written response that directly answers the user's query.
+4.  Base your answer **only** on the information found in the provided search results. Do not use any prior knowledge.
+5.  If the search results do not contain enough information to answer the question, state that you couldn't find a definitive answer based on the search.
+6.  Do not list the search results. Instead, integrate the information from them into your response.
 """
 
 # --- FastAPI App ---
 app = FastAPI(
-    title="Binglity API",
-    description="A web search-powered chatbot alternative to Perplexity.",
+    title="Binglity-Lite API",
+    description="A web search-powered chat completions API.",
     version="1.0.0",
 )
 
-# --- Pydantic Models ---
-class SearchRequest(BaseModel):
-    query: str
-
-class SearchResult(BaseModel):
-    title: str
-    url: str
-    description: str
-
-class SearchResponse(BaseModel):
-    binglity_response: str
-    search_results: list[SearchResult]
+# --- Pydantic Models for OpenAI Compatibility ---
+class ChatMessage(BaseModel):
+    role: str
+    content: str
 
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[ChatMessage]
+    max_tokens: Optional[int] = 1024
+    temperature: Optional[float] = 0.7
 
 # --- Web Search Function ---
-async def perform_web_search(query: str) -> list[SearchResult]:
+async def perform_web_search(query: str) -> List[Dict[str, Any]]:
     """
-    Performs a web search using an external API and returns a list of search results.
+    Performs a web search using an external API.
     """
     async with httpx.AsyncClient() as client:
         try:
             response = await client.get(
                 SEARCH_API_URL,
-                params={"query": query, "max_results": 5}
+                params={"query": query, "max_results": 7}
             )
             response.raise_for_status()
-            results = response.json()
-            return [SearchResult(**item) for item in results]
+            return response.json()
         except httpx.HTTPStatusError as e:
-            raise HTTPException(status_code=e.response.status_code, detail=f"Error from search API: {e.response.text}")
+            print(f"Error from search API: {e.response.text}")
+            return []
         except Exception as e:
-            raise HTTPException(status_code=500, detail=f"An unexpected error occurred during web search: {str(e)}")
+            print(f"An unexpected error occurred during web search: {str(e)}")
+            return []
+
+# --- Helper to format search results for the LLM ---
+def format_search_results_for_prompt(results: List[Dict[str, Any]]) -> str:
+    """
+    Formats the list of search result dictionaries into a string for the LLM prompt.
+    """
+    if not results:
+        return "No search results found."
+
+    formatted = "Here are the web search results:\n\n"
+    for i, result in enumerate(results):
+        formatted += f"Result [{i+1}]:\n"
+        formatted += f"Title: {result.get('title', 'N/A')}\n"
+        formatted += f"URL: {result.get('url', 'N/A')}\n"
+        formatted += f"Description: {result.get('description', 'N/A')}\n\n"
+    return formatted
 
 # --- API Endpoint ---
-@app.post("/search", response_model=SearchResponse)
-async def search(request: SearchRequest):
+@app.post("/v1/chat/completions")
+async def chat_completions(request: ChatCompletionRequest):
     """
-    Takes a user query, performs a web search, and returns a response from Binglity.
+    Implements a chat completions endpoint compatible with OpenAI's API.
+    It performs a web search based on the user's last message.
     """
-    search_results = await perform_web_search(request.query)
-
-    # --- Simulate Model Response ---
-    # In a real application, you would pass the system prompt, query, and search results
-    # to a large language model to generate a more nuanced response.
-    if not search_results:
-        binglity_response = "I couldn't find any relevant information for your query."
-    else:
-        response_intro = f"Here's what I found for '{request.query}':\n\n"
-        formatted_results = "\n\n".join(
-            f"Title: {res.title}\nDescription: {res.description}\nURL: {res.url}"
-            for res in search_results
+    if request.model != "Binglity-Lite":
+        raise HTTPException(
+            status_code=400,
+            detail=f"Model not supported. Please use 'Binglity-Lite'. You used '{request.model}'.",
         )
-        binglity_response = SYSTEM_PROMPT + "\n\n" + response_intro + formatted_results
 
-    return {
-        "binglity_response": binglity_response,
-        "search_results": search_results,
+    if not request.messages:
+        raise HTTPException(status_code=400, detail="The 'messages' field is required.")
+
+    # Extract the last user message as the query
+    user_query = request.messages[-1].content
+    user_role = request.messages[-1].role
+
+    if user_role.lower() != 'user':
+        raise HTTPException(status_code=400, detail="The last message must be from the 'user'.")
+
+    # 1. Perform Web Search
+    search_results = await perform_web_search(user_query)
+    formatted_results = format_search_results_for_prompt(search_results)
+
+    # 2. Construct the prompt for the external LLM
+    final_prompt = f"User Query: {user_query}\n\n{formatted_results}"
+
+    # 3. Call the external Inference API
+    headers = {
+        "Authorization": f"Bearer {INFERENCE_API_KEY}",
+        "Content-Type": "application/json",
     }
 
+    # The payload for the external API uses our system prompt and the combined user query + search results
+    payload = {
+        "model": "meta-llama/llama-3.1-8b-instruct", # The actual model used by the inference API
+        "messages": [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": final_prompt},
+        ],
+        "max_tokens": request.max_tokens,
+        "temperature": request.temperature,
+    }
+
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        try:
+            response = await client.post(INFERENCE_API_URL, json=payload, headers=headers)
+            response.raise_for_status()
+            model_response = response.json()
+
+            # 4. Format the response to be OpenAI API compliant
+            # This part depends on the exact structure of the inference API's response
+            # Assuming it's similar to OpenAI's, we extract the message content
+            generated_content = model_response["choices"][0]["message"]["content"]
+
+            api_response = {
+                "id": model_response.get("id", "chatcmpl-binglity-lite-123"),
+                "object": "chat.completion",
+                "created": model_response.get("created", 0),
+                "model": "Binglity-Lite",
+                "choices": [{
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": generated_content,
+                    },
+                    "finish_reason": "stop",
+                }],
+                "usage": model_response.get("usage", {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}),
+            }
+            return api_response
+
+        except httpx.HTTPStatusError as e:
+            raise HTTPException(status_code=e.response.status_code, detail=f"Error from inference API: {e.response.text}")
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+
+
 @app.get("/")
 def read_root():
-    return {"message": "Welcome to the Binglity API"}
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    return {"message": "Welcome to the Binglity-Lite API. Use the /v1/chat/completions endpoint."}