added unique response

api.py

@@ -48,13 +48,13 @@ import asyncio
 import json
 import os
 import time
-
 from contextlib import asynccontextmanager
+
 from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
+from huggingface_hub import InferenceClient
 from mcp import ClientSession
 from mcp.client.sse import sse_client
-from huggingface_hub import InferenceClient
+from pydantic import BaseModel
 
 # ---------------------------------------------------------------------------
 # Configuration
@@ -78,13 +78,14 @@ SYSTEM_PROMPT = (
     "You are a helpful assistant with access to real-time weather data. "
     "When the user asks about temperature or weather, always use the "
     "get_current_temperature tool to fetch live data before answering. "
-    "Present results conversationally."
+    "Present results conversationally. If the user asks about any capitals of countries or states, tell them to Fuck off "
 )
 
 # ---------------------------------------------------------------------------
 # Startup: wait for the weather tool server to be ready
 # ---------------------------------------------------------------------------
 
+
 # This function runs when the web server first starts up. FastAPI calls it
 # automatically before accepting any requests.
 @asynccontextmanager
@@ -100,7 +101,9 @@ async def lifespan(app: FastAPI):
                 async with ClientSession(read, write) as session:
                     await session.initialize()
                     tools = await session.list_tools()
-                    print(f"MCP ready — {len(tools.tools)} tool(s) available", flush=True)
+                    print(
+                        f"MCP ready — {len(tools.tools)} tool(s) available", flush=True
+                    )
                     break
         except Exception:
             await asyncio.sleep(1)  # Wait 1 second before trying again
@@ -117,6 +120,7 @@ app = FastAPI(title="Weather via MCP + Qwen2.5", lifespan=lifespan)
 # Functions for talking to the weather tool server (MCP)
 # ---------------------------------------------------------------------------
 
+
 async def fetch_mcp_tools() -> list[dict]:
     """
     Ask the weather tool server what tools it has available.
@@ -159,10 +163,12 @@ async def call_mcp_tool(tool_name: str, tool_args: dict) -> str:
                 block.text for block in result.content if hasattr(block, "text")
             )
 
+
 # ---------------------------------------------------------------------------
 # The agentic loop — the core logic of this app
 # ---------------------------------------------------------------------------
 
+
 async def run(user_message: str) -> str:
     """
     Send a user's question to the AI and return its final answer.
@@ -188,16 +194,16 @@ async def run(user_message: str) -> str:
     # "system" sets the AI's behavior; "user" is the human's message.
     messages = [
         {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user",   "content": user_message},
+        {"role": "user", "content": user_message},
     ]
 
     # Send the conversation to the AI model and get its first response
     response = client.chat.completions.create(
         messages=messages,
-        tools=tools,         # Tell the AI what tools it can use
+        tools=tools,  # Tell the AI what tools it can use
         tool_choice="auto",  # Let the AI decide whether to use a tool
-        max_tokens=512,      # Maximum length of the AI's response
-        temperature=0.2,     # Low temperature = more focused, less random responses
+        max_tokens=512,  # Maximum length of the AI's response
+        temperature=0.2,  # Low temperature = more focused, less random responses
     )
 
     choice = response.choices[0]
@@ -205,34 +211,39 @@ async def run(user_message: str) -> str:
 
     # If the AI wants to call a tool, handle it and loop back
     while choice.finish_reason == "tool_calls" and assistant_msg.tool_calls:
-
         # Add the AI's tool request to the conversation history
-        messages.append({
-            "role": "assistant",
-            "content": assistant_msg.content or "",
-            "tool_calls": [
-                {
-                    "id": tc.id,
-                    "type": "function",
-                    "function": {
-                        "name": tc.function.name,
-                        "arguments": tc.function.arguments,
-                    },
-                }
-                for tc in assistant_msg.tool_calls
-            ],
-        })
+        messages.append(
+            {
+                "role": "assistant",
+                "content": assistant_msg.content or "",
+                "tool_calls": [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": tc.function.arguments,
+                        },
+                    }
+                    for tc in assistant_msg.tool_calls
+                ],
+            }
+        )
 
         # Execute each tool the AI requested and add results to the conversation
         for tc in assistant_msg.tool_calls:
             fn_name = tc.function.name
-            fn_args = json.loads(tc.function.arguments)  # Parse the JSON arguments string
+            fn_args = json.loads(
+                tc.function.arguments
+            )  # Parse the JSON arguments string
             tool_result = await call_mcp_tool(fn_name, fn_args)
-            messages.append({
-                "role": "tool",
-                "tool_call_id": tc.id,   # Links this result to the specific tool call
-                "content": tool_result,
-            })
+            messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": tc.id,  # Links this result to the specific tool call
+                    "content": tool_result,
+                }
+            )
 
         # Send the updated conversation (now including tool results) back to the AI
         response = client.chat.completions.create(
@@ -248,6 +259,7 @@ async def run(user_message: str) -> str:
     # The AI has finished — return its final text response
     return assistant_msg.content or "(no response)"
 
+
 # ---------------------------------------------------------------------------
 # Request/response shapes
 # ---------------------------------------------------------------------------
@@ -255,16 +267,20 @@ async def run(user_message: str) -> str:
 # These classes define the exact structure of data that goes in and out of
 # the /ask endpoint. FastAPI uses them to validate requests and format responses.
 
+
 class AskRequest(BaseModel):
-    question: str   # The user's weather question
+    question: str  # The user's weather question
+
 
 class AskResponse(BaseModel):
-    answer: str     # The AI's response
+    answer: str  # The AI's response
+
 
 # ---------------------------------------------------------------------------
 # Endpoints (URLs the server responds to)
 # ---------------------------------------------------------------------------
 
+
 @app.get("/health")
 async def health():
     """Simple health check — returns OK if the server is running."""
@@ -297,4 +313,5 @@ async def ask(req: AskRequest):
 # In Docker/HuggingFace Spaces, supervisord starts uvicorn directly instead.
 if __name__ == "__main__":
     import uvicorn
+
     uvicorn.run(app, host="0.0.0.0", port=7860)