Main commit

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "cSpell.words": [
+        "guestinforetriever",
+        "huggingface",
+        "langchain",
+        "smolagents"
+    ]
+}

app.py

@@ -1,5 +1,40 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
+import os
+from typing import Optional
+
+from datasets import load_dataset
+from langchain.schema import Document
+from tools.guestinforetriever import GuestInfoRetrieverTool
+from tools.search_tool import SearchTool
+from tools.weather_tool import WeatherTool
+
+
+# Load dataset and initialize tools once at module import
+try:
+    ds = load_dataset("agents-course/unit3-invitees")
+    docs = []
+    for split in ds.keys():
+        for item in ds[split]:
+            # attempt to use common text fields, fallback to stringified item
+            text = None
+            for key in ("text", "content", "body", "description", "name"):
+                if key in item and item[key]:
+                    text = item[key]
+                    break
+            if text is None:
+                text = str(item)
+            docs.append(Document(page_content=str(text), metadata={"source": f"{split}"}))
+
+    guest_tool = GuestInfoRetrieverTool(docs)
+    search_tool = SearchTool(docs)
+except Exception:
+    # dataset load failed; provide empty fallback tools
+    docs = []
+    guest_tool = None
+    search_tool = None
+
+weather_tool = WeatherTool()
 
 
 def respond(
@@ -9,21 +44,60 @@ def respond(
     max_tokens,
     temperature,
     top_p,
-    hf_token: gr.OAuthToken,
+    hf_token: Optional[gr.OAuthToken],
 ):
     """
     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(token=hf_token.token, model="openai/gpt-oss-20b")
+    # simple command routing for tools
+    text = message.strip()
+    if text.lower().startswith("/guest "):
+        query = text[len("/guest "):].strip()
+        if guest_tool:
+            yield guest_tool.forward(query)
+        else:
+            yield "Guest retriever not available (dataset failed to load)."
+        return
 
-    messages = [{"role": "system", "content": system_message}]
+    if text.lower().startswith("/search "):
+        query = text[len("/search "):].strip()
+        if search_tool:
+            yield search_tool.forward(query)
+        else:
+            yield "Search tool not available (dataset failed to load)."
+        return
 
-    messages.extend(history)
+    if text.lower().startswith("/weather "):
+        location = text[len("/weather "):].strip()
+        yield weather_tool.forward(location)
+        return
 
+    # Default: call the HF chat model
+    # Prefer the Gradio OAuth token, fall back to env var `HUGGINGFACEHUB_API_TOKEN`.
+    hf_token_value = None
+    if hf_token and getattr(hf_token, "token", None):
+        hf_token_value = hf_token.token
+    else:
+        hf_token_value = os.environ.get("HUGGINGFACEHUB_API_TOKEN")
+
+    if not hf_token_value:
+        yield (
+            "Missing Hugging Face API token. Please run `huggingface-cli login` or set the"
+            " environment variable `HUGGINGFACEHUB_API_TOKEN` with a valid token (starts with 'hf_')."
+        )
+        return
+
+    try:
+        client = InferenceClient(token=hf_token_value, model="openai/gpt-oss-20b")
+    except Exception as e:
+        yield f"Failed to initialize Hugging Face InferenceClient: {e}"
+        return
+
+    messages = [{"role": "system", "content": system_message}]
+    messages.extend(history)
     messages.append({"role": "user", "content": message})
 
     response = ""
-
     for message in client.chat_completion(
         messages,
         max_tokens=max_tokens,

requirements.txt

@@ -0,0 +1,8 @@
+gradio>=3.0
+huggingface-hub>=0.14.0
+datasets>=2.0.0
+langchain>=0.0.200
+langchain-community>=0.0.10
+smolagents>=0.1.0
+requests>=2.28.0
+rank-bm25>=0.2.2

tools/guestinforetriever.py

@@ -0,0 +1,53 @@
+from smolagents import Tool
+from langchain_community.retrievers import BM25Retriever
+from langchain.schema import Document
+from datasets import load_dataset
+from typing import List, Optional
+
+
+class GuestInfoRetrieverTool(Tool):
+    name = "guest_info_retriever"
+    description = "Retrieves detailed information about gala guests based on their name or relation."
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The name or relation of the guest you want information about."
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, docs: List[Document]):
+        # docs should be a list of `langchain.schema.Document`
+        self.is_initialized = True
+        self.retriever = BM25Retriever.from_documents(docs)
+
+    def forward(self, query: str) -> str:
+        results = self.retriever.get_relevant_documents(query)
+        if results:
+            return "\n\n".join([doc.page_content for doc in results[:3]])
+        else:
+            return "No matching guest information found."
+
+    @classmethod
+    def from_hf_dataset(cls, dataset_name: str, text_field: str = "text") -> "GuestInfoRetrieverTool":
+        """Load a Hugging Face dataset and construct a BM25 retriever.
+
+        Args:
+            dataset_name: dataset identifier, e.g. 'agents-course/unit3-invitees'
+            text_field: field in the dataset entries containing the text to index.
+        """
+        ds = load_dataset(dataset_name)
+        # assume first split and concatenate text fields
+        records = []
+        for split in ds.keys():
+            for item in ds[split]:
+                if text_field in item and item[text_field]:
+                    records.append(Document(page_content=str(item[text_field]), metadata={"source": dataset_name}))
+                else:
+                    # fallback: stringify whole item
+                    records.append(Document(page_content=str(item), metadata={"source": dataset_name}))
+
+        return cls(records)
+
+
+# Note: factories instead of eager initialization — caller should instantiate with docs or use `from_hf_dataset`.

tools/search_tool.py

@@ -0,0 +1,21 @@
+from smolagents import Tool
+from langchain_community.retrievers import BM25Retriever
+from langchain.schema import Document
+from typing import List
+
+
+class SearchTool(Tool):
+    name = "search"
+    description = "Performs a general search over provided documents. Use `/search <query>` to call."
+    inputs = {"query": {"type": "string", "description": "Search query"}}
+    output_type = "string"
+
+    def __init__(self, docs: List[Document]):
+        self.retriever = BM25Retriever.from_documents(docs)
+
+    def forward(self, query: str) -> str:
+        results = self.retriever.get_relevant_documents(query)
+        if not results:
+            return "No results found."
+
+        return "\n\n".join([f"- {r.page_content}" for r in results[:5]])

tools/weather_tool.py

@@ -0,0 +1,41 @@
+from smolagents import Tool
+import requests
+
+
+class WeatherTool(Tool):
+    name = "weather"
+    description = "Returns current weather information for a given location. Use `/weather <location>` to call."
+    inputs = {"location": {"type": "string", "description": "City or location name"}}
+    output_type = "string"
+
+    def __init__(self, timeout: int = 5):
+        self.timeout = timeout
+
+    def forward(self, location: str) -> str:
+        # Use Open-Meteo geocoding + weather APIs (no API key required)
+        try:
+            geo = requests.get(
+                "https://geocoding-api.open-meteo.com/v1/search",
+                params={"name": location, "count": 1},
+                timeout=self.timeout,
+            ).json()
+
+            if not geo.get("results"):
+                return f"Could not find location: {location}"
+
+            loc = geo["results"][0]
+            lat, lon = loc["latitude"], loc["longitude"]
+
+            weather = requests.get(
+                "https://api.open-meteo.com/v1/forecast",
+                params={"latitude": lat, "longitude": lon, "current_weather": True},
+                timeout=self.timeout,
+            ).json()
+
+            cw = weather.get("current_weather")
+            if not cw:
+                return f"No weather data available for {location} (lat={lat}, lon={lon})"
+
+            return f"Weather for {loc.get('name', location)}, {loc.get('country','')}: {cw.get('temperature')}°C, wind {cw.get('windspeed')} km/h, conditions code {cw.get('weathercode')}"
+        except Exception as e:
+            return f"Weather lookup failed: {e}"