hf space

.github/workflows/hf_spaces.yaml

@@ -0,0 +1,20 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push https://HF_USERNAME:[email protected]/spaces/mozilla-ai/surf-spot-finder main

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY demo/requirements.txt ./
+COPY demo/ ./demo/
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "demo/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

demo/constants.py

@@ -0,0 +1,12 @@
+MODEL_OPTIONS = [
+    # "huggingface/novita/deepseek-ai/DeepSeek-V3",
+    # "huggingface/novita/meta-llama/Llama-3.3-70B-Instruct",
+    "gemini/gemini-2.0-flash-lite",
+    "gemini-2.0-flash",
+    # "huggingface/Qwen/Qwen3-32B", # right now throwing an internal error, but novita qwen isn't supporting tool calling
+]
+
+# Novita was the only HF based provider that worked.
+
+# Hugginface API Provider Error:
+# Must alternate between assistant/user, which meant that the 'tool' role made it puke

demo/pickers.py

@@ -0,0 +1,80 @@
+from datetime import datetime, timedelta
+import json
+import requests
+import streamlit as st
+from any_agent import AgentFramework
+from any_agent.tracing.trace import _is_tracing_supported
+
+from constants import MODEL_OPTIONS
+
+
+@st.cache_resource
+def get_area(area_name: str) -> dict:
+    """Get the area from Nominatim.
+
+    Uses the [Nominatim API](https://nominatim.org/release-docs/develop/api/Search/).
+
+    Args:
+        area_name (str): The name of the area.
+
+    Returns:
+        dict: The area found.
+    """
+    response = requests.get(
+        f"https://nominatim.openstreetmap.org/search?q={area_name}&format=json",
+        headers={"User-Agent": "Mozilla/5.0"},
+        timeout=5,
+    )
+    response.raise_for_status()
+    response_json = json.loads(response.content.decode())
+    return response_json
+
+
+def get_user_inputs() -> dict:
+    st.title("Surf Spot Finder")
+    st.write(
+        "This app finds the best surf spots in your area based on the weather forecast."
+    )
+    default_val = "Los Angeles California, US"
+
+    location = st.text_input("Enter a location", value=default_val)
+    if location:
+        location_check = get_area(location)
+        if not location_check:
+            st.error("Invalid location. Please enter a valid location.")
+            return None
+        else:
+            # display a checkmark saying that the location is valid
+            st.success("Valid location")
+    max_driving_hours = st.number_input(
+        "Enter the maximum driving hours", min_value=1, value=2
+    )
+    date = st.date_input(
+        "Select a date in the future", value=datetime.now() + timedelta(days=1)
+    )
+
+    supported_frameworks = [
+        framework for framework in AgentFramework if _is_tracing_supported(framework)
+    ]
+
+    framework = st.selectbox(
+        "Select the agent framework to use",
+        supported_frameworks,
+        index=2,
+        format_func=lambda x: x.name,
+    )
+
+    model_id = st.selectbox(
+        "Select the model to use",
+        MODEL_OPTIONS,
+        index=0,
+        format_func=lambda x: "/".join(x.split("/")[-3:]),
+    )
+
+    return {
+        "location": location,
+        "max_driving_hours": max_driving_hours,
+        "date": date,
+        "framework": framework,
+        "model_id": model_id,
+    }

demo/requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+openai-agents>=0.0.14
+any-agent @ git+https://github.com/mozilla-ai/any-agent
+surf-spot-finder @ git+https://github.com/mozilla-ai/surf-spot-finder
+nest_asyncio

demo/streamlit_app.py

@@ -0,0 +1,26 @@
+import streamlit as st
+import asyncio
+import nest_asyncio
+from pickers import get_user_inputs
+from utils import run_agent
+
+
+nest_asyncio.apply()
+
+
+with st.sidebar:
+    user_inputs = get_user_inputs()
+    is_valid = user_inputs is not None
+    run_button = st.button("Run", disabled=not is_valid)
+
+
+async def main():
+    if run_button:
+        await run_agent(user_inputs)
+    else:
+        st.write("Click run to start!")
+
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    loop.run_until_complete(main())

demo/utils.py

@@ -0,0 +1,94 @@
+import streamlit as st
+from surf_spot_finder.tools import (
+    driving_hours_to_meters,
+    get_area_lat_lon,
+    get_surfing_spots,
+    get_wave_forecast,
+    get_wind_forecast,
+)
+from surf_spot_finder.config import Config
+from any_agent import AgentConfig, AnyAgent, TracingConfig
+from any_agent.evaluation import evaluate, TraceEvaluationResult
+
+
+async def run_agent(user_inputs):
+    st.write("Running surf spot finder...")
+    if "huggingface" in user_inputs["model_id"]:
+        model_args = {
+            "extra_headers": {"X-HF-Bill-To": "mozilla-ai"},
+        }
+    else:
+        model_args = {}
+    agent_config = AgentConfig(
+        model_id=user_inputs["model_id"],
+        model_args=model_args,
+        tools=[
+            get_wind_forecast,
+            get_wave_forecast,
+            get_area_lat_lon,
+            get_surfing_spots,
+            driving_hours_to_meters,
+        ],
+    )
+    config = Config(
+        location=user_inputs["location"],
+        max_driving_hours=user_inputs["max_driving_hours"],
+        date=user_inputs["date"],
+        framework=user_inputs["framework"],
+        main_agent=agent_config,
+        managed_agents=[],
+        evaluation_cases=None,
+    )
+
+    agent = await AnyAgent.create_async(
+        agent_framework=config.framework,
+        agent_config=config.main_agent,
+        managed_agents=config.managed_agents,
+        tracing=TracingConfig(console=True, cost_info=True),
+    )
+
+    query = config.input_prompt_template.format(
+        LOCATION=config.location,
+        MAX_DRIVING_HOURS=config.max_driving_hours,
+        DATE=config.date,
+    )
+    st.write("Running agent with query:\n", query)
+
+    with st.spinner("Running..."):
+        agent_trace = await agent.run_async(query)
+        agent.exit()
+
+    st.write("Final output from agent:\n", agent_trace.final_output)
+
+    # Display the agent trace
+    with st.expander("Agent Trace", expanded=True):
+        st.write(agent_trace.spans)
+
+    if config.evaluation_cases is not None:
+        results = []
+        st.write("Found evaluation cases, running trace evaluation")
+        for i, case in enumerate(config.evaluation_cases):
+            st.write("Evaluating case: ", case)
+            result: TraceEvaluationResult = evaluate(
+                evaluation_case=case,
+                trace=agent_trace,
+                agent_framework=config.framework,
+            )
+            for list_of_checkpoints in [
+                result.checkpoint_results,
+                result.direct_results,
+                result.hypothesis_answer_results,
+            ]:
+                for checkpoint in list_of_checkpoints:
+                    msg = (
+                        f"Checkpoint: {checkpoint.criteria}\n"
+                        f"\tPassed: {checkpoint.passed}\n"
+                        f"\tReason: {checkpoint.reason}\n"
+                        f"\tScore: {'%d/%d' % (checkpoint.points, checkpoint.points) if checkpoint.passed else '0/%d' % checkpoint.points}"
+                    )
+                    st.write(msg)
+            st.write("==========================")
+            st.write("Overall Score: %d%%", 100 * result.score)
+            st.write("==========================")
+            results.append(result)
+    st.write("Surf spot finder finished running.")