updated agent

agent.py

@@ -28,14 +28,6 @@ INSTRUCTIONS FOR USING TOOL RESULTS:
 - Use those results to answer the user’s latest question.
 - Summarize the results naturally. Do NOT restate the log format.
 - NEVER reproduce or invent <tool_results> blocks.
-- NEVER output lines of the form:
-    "You have executed the following tools..."
-    "- tool_name(args_dict) -> result"
-- NEVER fabricate new tool calls or logs.
-
-WHEN THERE ARE NO TOOL RESULTS:
-- Answer based on weather knowledge, common sense, and conversation context.
-- Still avoid any mention of “tools”, “calls”, “executions”, or logs.
 
 YOUR OUTPUT:
 - Your entire reply must be ONLY natural language directed to the user.
@@ -111,25 +103,46 @@ def parse_tool_calls(tool_output: str):
         calls.append((func_name, kwargs))
     return calls
 
-def generate_non_stream(llm, prompt, max_tokens=256, temperature=0.2, top_p=0.95):
-    out = llm(
-        prompt,
+def add_history(user_message, history, system_message):
+    new_history = [{"role": "system", "content": system_message}]
+    if history:
+        for el in history:
+            if el["role"] == "user":
+                user = el["content"][0]["text"]
+                new_history.append({"role": "user", "content": user})
+            elif el["role"] == "assistant":
+                user = el["content"][0]["text"]
+                new_history.append({"role": "assistant", "content": user})
+    new_history.append({"role": "user", "content": user_message})
+    return new_history
+
+def generate_chat(llm, messages, max_tokens=256, temperature=0.2, top_p=0.95):
+    completion_stream = llm.create_chat_completion(
+        messages=messages,
         max_tokens=max_tokens,
         temperature=temperature,
         top_p=top_p,
-        stop=["User:", "System:"],
-        stream=False,
+        stream=True,
     )
-    return out["choices"][0]["text"]
 
-def build_prompt(system_message, history, user_message):
-    prompt = f"System: {system_message}\n"
-    for turn in history:
-        role = turn["role"]
-        content = turn["content"]
-        prompt += f"{role.capitalize()}: {content}\n"
-    prompt += f"User: {user_message}\nAssistant:"
-    return prompt
+    answer = ""
+    for chunk in completion_stream:
+        delta = chunk["choices"][0].get("delta", {})
+        token = delta.get("content", None)
+        if token:
+            answer += token
+            yield answer
+
+def generate_non_stream_chat(llm, messages, max_tokens=256, temperature=0.2, top_p=0.95):
+    res = llm.create_chat_completion(
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        top_p=top_p,
+        stream=False,
+    )
+    # Return just the final text
+    return res["choices"][0]["message"]["content"]
 
 def select_tools_with_llm(llm, user_message: str, tools_schema: list) -> list:
     tool_selection_system = f"""You are an expert in composing functions. You are given a question and a set of possible functions.
@@ -137,24 +150,18 @@ Based on the question, you will need to make one or more function/tool calls to
 If none of the functions can be used, point it out. If the given question lacks the parameters required by the function, also point it out. You should only return the function call in tools call sections.
 
 If you decide to invoke any of the function(s), you MUST put it in the format of [func_name1(params_name1=params_value1, params_name2=params_value2...), func_name2(params)]
-You SHOULD NOT include any other text in the response.
+If you call a function, you SHOULD NOT include any other text in the response.
 
 Here is a list of functions in JSON format that you can invoke:
 
 {json.dumps(tools_schema, indent=2)}
 """
-    prompt = (
-        f"System: {tool_selection_system}\n"
-        f"User: {user_message}\n"
-        f"Assistant:"
-    )
-    raw = generate_non_stream(
-        llm,
-        prompt,
-        max_tokens=256,
-        temperature=0.2,
-        top_p=0.95,
-    )
+    
+    messages = [
+        {"role": "system", "content": tool_selection_system},
+        {"role": "user", "content": user_message},
+    ]
+    raw = generate_non_stream_chat(llm, messages)
     return parse_tool_calls(raw), raw
 
 def call_tools(tool_calls, tool_registry):
@@ -177,7 +184,7 @@ def call_tools(tool_calls, tool_registry):
         results.append({"name": func_name, "args": kwargs, "result": res})
     return results
 
-def respond(message, history, system_message, llm, tools=None):
+def respond(user_message, history, system_message, llm, tools=None):
     if tools is None:
         tools = []
     
@@ -186,12 +193,8 @@ def respond(message, history, system_message, llm, tools=None):
     tools_schema = [function_to_json(f) for f in tools]
 
     # 2. Let the LLM select tools based on the message
-    tool_calls, initial_message = select_tools_with_llm(llm, message, tools_schema)
+    tool_calls, initial_message = select_tools_with_llm(llm, user_message, tools_schema)
 
-    # We wanted to use the inital_message above in the response, for example
-    # when parameters are missing but the model was too bad at making such responses
-    # that it had to be omitted for now.
-    
     # 3. Call tools if needed, otherwise respond
     if tool_calls and tools:
         tool_results = call_tools(tool_calls, tool_registry)
@@ -199,22 +202,11 @@ def respond(message, history, system_message, llm, tools=None):
         for tr in tool_results:
             tool_info_str += f"- {tr['name']}({tr['args']}) -> {tr['result']}\n"
         final_system_message = f"{system_message}{LAST_SYSTEM_MESSAGE} {tool_info_str}</tool_results>\n"
-    else:
-        final_system_message = system_message
 
-    # Call the LLM again with the results from the tools used
-    prompt = build_prompt(final_system_message, history, message)
+        messages = add_history(user_message, history, final_system_message)
 
-    stream = llm(
-        prompt,
-        max_tokens=256,
-        temperature=0.7,
-        top_p=0.9,
-        stop=["User:", "System:"],
-        stream=True,
-    )
-    partial = ""
-    for out in stream:
-        token = out["choices"][0]["text"]
-        partial += token
-        yield partial
+        stream = generate_chat(llm, messages, temperature=0.7, top_p=0.95)
+        for out in stream:
+            yield out
+    else:
+        return initial_message

app.py

@@ -20,10 +20,9 @@ except Exception as e:
     print(f"--- INSTALLATION FAILED: {e} ---")
 
 import gradio as gr
-import wikipedia  # This will now work
-from agent import respond, build_prompt
+import wikipedia
+from agent import respond, generate_chat, add_history
 from llama_cpp import Llama
-import random
 
 # ---------------- CONFIG ----------------
 BASE_REPO_ID = "unsloth/Llama-3.2-3B-Instruct-GGUF"
@@ -31,6 +30,9 @@ BASE_FILENAME = "Llama-3.2-3B-Instruct-Q4_K_M.gguf"
 
 FT_REPO_ID = "JoarP/Llama-3.2-3B-FineTome5K-gguf"
 FT_FILENAME = "v1"
+
+FT_REPO_ID_2 = "JoarP/Llama-3.2-3B-Finetuning"
+FT_FILENAME_2 = "FuncCall-Synthetic-Small"
 N_CTX = 2048
 N_THREADS = 2
 
@@ -54,15 +56,23 @@ try:
     )
     AVAILABLE_MODELS["Llama 3.2 3B"] = llm_base
 
+    print("Loading model...")
+    llm_ft_2 = Llama.from_pretrained(
+        repo_id=FT_REPO_ID_2,
+        filename=FT_FILENAME_2,
+        n_ctx=N_CTX,
+        n_threads=N_THREADS,
+    )
+    AVAILABLE_MODELS["FuncCall FT - Llama 3.2 3B"] = llm_ft_2
+
 except Exception as e:
     print(f"Error loading model: {e}")
     raise e
 
 
 #--------------- TO RUN LOCALLY ----------------- 
-
 # llm = Llama(
-#     model_path="works.gguf",
+#     model_path="works2.gguf",
 #     n_ctx=N_CTX,
 #     n_threads=None,
 # )
@@ -72,7 +82,7 @@ except Exception as e:
 # }
 # ------------- FAST RESPONSE WITHOUT AGENT --------------
 
-def respond_fast(message, history, model_choice):
+def respond_fast(user_message, history, model_choice):
     """
     Fast path: no tools, no agent. Just a single LLM call with the
     given system message and chat history.
@@ -82,52 +92,16 @@ def respond_fast(message, history, model_choice):
     if llm is None:
         llm = next(iter(AVAILABLE_MODELS.values()))
 
-    # Conversion logic
-    formatted_history = format_history(history)
-
-    # Build a simple chat-style prompt
-    prompt = build_prompt("You are a helpful assistant. Just chat with the user.", formatted_history, message)
+    history = add_history(user_message, history, "You are a helpful assistant. Just chat with the user.")
 
     # Single streaming generation
-    stream = llm(
-        prompt,
-        max_tokens=256,
-        temperature=0.7,
-        top_p=0.9,
-        stop=["User:", "System:"],
-        stream=True,
-    )
-
-    partial = ""
+    stream = generate_chat(llm, history, max_tokens=256, temperature=0.2, top_p=0.95)
     for out in stream:
-        token = out["choices"][0]["text"]
-        partial += token
-        yield partial
-
-# ------------- HELP FUNCTION ------------------
-
-def format_history(history):
-    formatted_history = []
-    for turn in history:
-        role = turn.get("role", "user")
-        raw_content = turn.get("content", "")
-        block = raw_content[0]
-        content = block["text"]
-        formatted_history.append({
-            "role": role,
-            "content": content
-        })
-    return formatted_history
+        yield out
 
 
 # ------------- TOOLS DEFINITIONS --------------
-def get_weather(location: str) -> str:
-    """Returns weather. Args: location (city)."""
-    return random.choice(["cloudy", "rainy", "sunny", "foobar"])
-
-def get_temperature(location: str) -> str:
-    """Returns temperature. Args: location (city)."""
-    return random.choice(["-10", "0", "20", "30"])
+from weather import get_current_weather, get_current_temperature
 
 def multiply(a: int, b: int) -> int:
     """Multiplies two integers. Args: a, b."""
@@ -152,7 +126,7 @@ def search_wikipedia(query: str) -> str:
 AGENTS = {
     "Weather": {
         "system_message": "You are a helpful weather assistant",
-        "tools": [get_weather, get_temperature] 
+        "tools": [get_current_weather, get_current_temperature] 
     },
     "Math": {
         "system_message": "You are a helpful math assistant",
@@ -164,7 +138,7 @@ AGENTS = {
     },
 }
 
-# ------------- WRAPPER FUNCTION ----------------
+# ------------- WRAPPER FUNCTION FOR AGENTS ----------------
 def app_respond(message, history, model_choice, agent_choice):
     """Pass the selected agent to our agentic framwork"""
     llm = AVAILABLE_MODELS.get(model_choice)
@@ -173,12 +147,9 @@ def app_respond(message, history, model_choice, agent_choice):
     
     agent_config = AGENTS.get(agent_choice)
 
-    # Conversion logic
-    formatted_history = format_history(history)
-
     for chunk in respond(
         message, 
-        formatted_history, # Pass the converted history
+        history,
         system_message=agent_config["system_message"],
         llm=llm,
         tools=agent_config["tools"] 

requirements.txt

@@ -1,3 +1,6 @@
 gradio
 huggingface_hub
-
+openmeteo-requests
+requests-cache
+retry-requests
+geopy

weather.py

@@ -0,0 +1,98 @@
+import openmeteo_requests
+import pandas as pd
+import requests_cache
+from retry_requests import retry
+from geopy.geocoders import Nominatim
+
+def call_openmeteo_current(city: str, variable: str) -> str:
+    # Setup the Open-Meteo API client with cache and retry on error
+    cache_session = requests_cache.CachedSession('.cache', expire_after = 3600)
+    retry_session = retry(cache_session, retries = 5, backoff_factor = 0.2)
+    openmeteo = openmeteo_requests.Client(session = retry_session)
+
+    url = "https://api.open-meteo.com/v1/forecast"
+
+    lat, lon = get_coordinates(city)
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "current": variable,
+    }
+    responses = openmeteo.weather_api(url, params=params)
+    response = responses[0]
+    current = response.Current()
+    variable = current.Variables(0).Value()
+    return variable
+
+def get_current_weather(city: str) -> str:
+    """Get the summary of the current weather in a city."""
+    weather = call_openmeteo_current(city, "weather_code")
+    weather_str = weather_code_to_description(weather)
+    return weather_str
+
+def get_current_temperature(city: str) -> str:
+    """Get the current temperature in a city."""
+    temperature = call_openmeteo_current(city, "temperature_2m")
+    return str(round(temperature))
+
+def get_current_wind_speed(city: str) -> str:
+    """Get the current wind speed (10m) in a city."""
+    wind = call_openmeteo_current(city, "wind_speed_10m")
+    return str(round(wind)) + " m/s" 
+
+def get_coordinates(city: str):
+    geolocator = Nominatim(user_agent="NewApp")
+    location = geolocator.geocode(city)
+    return location.latitude, location.longitude
+
+
+def weather_code_to_description(code: float | int) -> str:
+    """
+    Convert Open-Meteo (WMO) weather codes to human-readable descriptions.
+    Accepts int or float values (e.g., 1.0 -> 1).
+    """
+    code = int(code)
+
+    WEATHER_CODE_MAP = {
+        0: "Clear sky",
+
+        1: "Mainly clear",
+        2: "Partly cloudy",
+        3: "Overcast",
+
+        45: "Fog",
+        48: "Depositing rime fog",
+
+        51: "Light drizzle",
+        53: "Moderate drizzle",
+        55: "Dense drizzle",
+
+        56: "Light freezing drizzle",
+        57: "Dense freezing drizzle",
+
+        61: "Slight rain",
+        63: "Moderate rain",
+        65: "Heavy rain",
+
+        66: "Light freezing rain",
+        67: "Heavy freezing rain",
+
+        71: "Slight snowfall",
+        73: "Moderate snowfall",
+        75: "Heavy snowfall",
+
+        77: "Snow grains",
+
+        80: "Slight rain showers",
+        81: "Moderate rain showers",
+        82: "Violent rain showers",
+
+        85: "Slight snow showers",
+        86: "Heavy snow showers",
+
+        95: "Thunderstorm",
+        96: "Thunderstorm with slight hail",
+        99: "Thunderstorm with heavy hail",
+    }
+
+    return WEATHER_CODE_MAP.get(code, f"Unknown weather code: {code}")