Update app.py

app.py

@@ -1,176 +1,112 @@
 import os
 import json
 import gradio as gr
-from huggingface_hub import InferenceClient
-from typing import Dict, Any, List
+from dotenv import load_dotenv
+from huggingface_hub import login
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+from llama_index.core.agent import ReActAgent
+from llama_index.core.tools import FunctionTool
 
-# Define a static weather tool function
-def get_current_weather(location, unit="fahrenheit"):
-    """Get the current weather in a given location"""
-    if "tokyo" in location.lower():
+# Load environment variables
+load_dotenv()
+
+# Get Hugging Face token
+hf_token = os.getenv("HUGGINGFACE_TOKEN")
+if not hf_token:
+    raise ValueError("Hugging Face token not found. Configure HUGGINGFACE_TOKEN in your environment variables")
+
+# Authenticate with Hugging Face
+login(token=hf_token)
+
+# Define weather function with static data
+def get_current_weather(location: str, unit: str = "fahrenheit") -> dict:
+    """
+    Get the current weather in a given location
+    
+    Args:
+        location (str): The city name, e.g. San Francisco, Tokyo
+        unit (str): The unit of temperature, either celsius or fahrenheit
+        
+    Returns:
+        dict: Weather information including location, temperature and unit
+    """
+    location = location.lower()
+    
+    if "tokyo" in location:
         return {"location": "Tokyo", "temperature": "10", "unit": "celsius"}
-    elif "san francisco" in location.lower():
+    elif "san francisco" in location:
         return {"location": "San Francisco", "temperature": "72", "unit": "fahrenheit"}
-    elif "paris" in location.lower():
+    elif "paris" in location:
         return {"location": "Paris", "temperature": "22", "unit": "celsius"}
     else:
         return {"location": location, "temperature": "unknown", "unit": unit}
 
-class HfApiModel:
-    def __init__(self, max_tokens=2096, temperature=0.5, model_id='Qwen/Qwen2.5-Coder-32B-Instruct', token=None):
-        self.max_tokens = max_tokens
-        self.temperature = temperature
-        self.model_id = model_id
-        self.client = InferenceClient(model=model_id, token=token)
-    
-    def generate_with_function_calling(self, messages, functions):
-        try:
-            # Format messages for the model
-            response = self.client.chat_completion(
-                messages=messages,
-                max_tokens=self.max_tokens,
-                temperature=self.temperature,
-                tools=functions,
-                tool_choice="auto"
-            )
-            
-            return response
-        except Exception as e:
-            print(f"Error in generate: {str(e)}")
-            return {"error": str(e)}
-    
-    def call_function(self, function_name, arguments):
-        if function_name == "get_current_weather":
-            location = arguments.get("location", "")
-            unit = arguments.get("unit", "fahrenheit")
-            return get_current_weather(location, unit)
-        return {"error": f"Function {function_name} not found"}
-
-# Initialize the model
-def init_model():
-    token = os.environ.get("HUGGINGFACE_TOKEN")
-    return HfApiModel(
-        max_tokens=2096,
-        temperature=0.5,
-        model_id='Qwen/Qwen2.5-Coder-32B-Instruct'
-    )
+# Create a tool for the agent
+weather_tool = FunctionTool.from_defaults(
+    name="get_current_weather",
+    fn=get_current_weather,
+    description="Get the current weather in a given location"
+)
 
-# Define the weather function schema
-weather_function = {
-    "type": "function",
-    "function": {
-        "name": "get_current_weather",
-        "description": "Get the current weather in a given location",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "location": {
-                    "type": "string",
-                    "description": "The city and state, e.g. San Francisco, CA"
-                },
-                "unit": {
-                    "type": "string",
-                    "enum": ["celsius", "fahrenheit"],
-                    "description": "The unit of temperature to use. Infer this from the user's location."
-                }
-            },
-            "required": ["location"]
-        }
-    }
-}
+# Configure the language model
+llm = HuggingFaceInferenceAPI(
+    model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
+    temperature=0.7,
+    max_tokens=512,
+    token=hf_token,
+)
 
-# Processing function for Gradio
-def process_message(message, history):
-    # Initialize model on first run
-    if not hasattr(process_message, "model"):
-        process_message.model = init_model()
+# Create the agent with an appropriate system prompt
+agent = ReActAgent.from_tools(
+    [weather_tool],
+    llm=llm,
+    verbose=False,
+    system_prompt="""
+    You are a helpful weather assistant that can provide current weather information for various cities.
     
-    # Format conversation history for the model
-    formatted_history = []
-    for human, assistant in history:
-        formatted_history.append({"role": "user", "content": human})
-        if assistant:  # Check if assistant response exists
-            formatted_history.append({"role": "assistant", "content": assistant})
+    Your capabilities:
+    1. Get current weather information for cities like Tokyo, San Francisco, and Paris
+    2. Provide temperature in either celsius or fahrenheit
     
-    # Add the current message
-    messages = formatted_history + [{"role": "user", "content": message}]
+    When handling user requests:
+    1. If a user asks about weather in Tokyo, San Francisco, or Paris, use the get_current_weather function
+    2. For other locations, inform the user that we only have data for Tokyo, San Francisco, and Paris
     
-    try:
-        # Get response from the model
-        response = process_message.model.generate_with_function_calling(
-            messages=messages,
-            functions=[weather_function]
-        )
-        
-        # Check if there's a function call
-        if hasattr(response, "choices") and response.choices:
-            message_content = response.choices[0].message
-            
-            # Check if the model wants to call a function
-            if hasattr(message_content, "tool_calls") and message_content.tool_calls:
-                tool_call = message_content.tool_calls[0]
-                function_name = tool_call.function.name
-                function_args = json.loads(tool_call.function.arguments)
-                
-                # Call the function
-                function_result = process_message.model.call_function(function_name, function_args)
-                
-                # Add the function result to messages
-                messages.append({
-                    "role": "assistant",
-                    "content": None,
-                    "tool_calls": [{
-                        "id": tool_call.id,
-                        "type": "function",
-                        "function": {
-                            "name": function_name,
-                            "arguments": tool_call.function.arguments
-                        }
-                    }]
-                })
-                
-                messages.append({
-                    "role": "tool",
-                    "tool_call_id": tool_call.id,
-                    "content": json.dumps(function_result)
-                })
-                
-                # Get final response
-                final_response = process_message.model.generate_with_function_calling(
-                    messages=messages,
-                    functions=[weather_function]
-                )
-                
-                if hasattr(final_response, "choices") and final_response.choices:
-                    return final_response.choices[0].message.content
-                return "Error processing function result"
-            
-            # If no function call, return the content directly
-            if hasattr(message_content, "content"):
-                return message_content.content
-            
-        return "I couldn't process that request properly. Please try again."
+    Always provide clear, concise responses with the location, temperature, and unit of measurement.
     
-    except Exception as e:
-        return f"Error: {str(e)}"
+    Example responses:
+    - "The current weather in Tokyo is 10°C."
+    - "San Francisco's temperature is currently 72°F."
+    - "Paris is experiencing a temperature of 22°C today."
+    
+    Keep responses friendly and helpful, focusing on the weather information requested.
+    """
+)
+
+def respond(message, history):
+    # Execute the agent with user input
+    response = agent.chat(message)
+    return str(response)
 
-# Set up the Gradio interface
-with gr.Blocks(title="Qwen Weather Assistant") as demo:
-    gr.Markdown("# Qwen Weather Assistant")
-    gr.Markdown("This demo uses Qwen2.5-Coder-32B-Instruct with function calling. You can ask about the weather for any city!")
-    gr.Markdown("### Example cities with data: Tokyo, San Francisco, Paris")
+# Create Gradio interface
+with gr.Blocks(title="Weather Assistant") as demo:
+    gr.Markdown("# 🌤️ Weather Assistant")
+    gr.Markdown("### Ask about the weather in Tokyo, San Francisco, or Paris")
     
     chatbot = gr.ChatInterface(
-        process_message,
+        respond,
         examples=[
             "What's the weather like in Tokyo?",
-            "Can you tell me the current weather in San Francisco?",
-            "I'm planning a trip to Paris. How's the weather there?",
-            "What should I wear in Tokyo based on the weather?"
+            "How's the weather in San Francisco?",
+            "Tell me about the current weather in Paris",
+            "What should I wear in Tokyo based on the weather?",
+            "Is it warm in San Francisco?"
         ],
-        title="Chat with Qwen Weather Assistant"
+        title="Chat with Weather Assistant"
     )
+    
+    gr.Markdown("### Built with LlamaIndex and Qwen2.5-Coder-32B-Instruct")
 
-# Launch the app
+# Launch the application
 if __name__ == "__main__":
     demo.launch()