add llamaindex

Author: maxkorp

typescript-sdk/apps/dojo/e2e/tests/llamaIndexTests/backendToolRenderingPage.spec.ts

@@ -0,0 +1,54 @@
+import { test, expect } from "@playwright/test";
+
+test("[LlamaIndex] Backend Tool Rendering displays weather cards", async ({ page }) => {
+  // Set shorter default timeout for this test
+  test.setTimeout(30000); // 30 seconds total
+
+  await page.goto("/llama-index/feature/backend_tool_rendering");
+
+  // Verify suggestion buttons are visible
+  await expect(page.getByRole("button", { name: "Weather in San Francisco" })).toBeVisible({
+    timeout: 5000,
+  });
+
+  // Click first suggestion and verify weather card appears
+  await page.getByRole("button", { name: "Weather in San Francisco" }).click();
+
+  // Wait for either test ID or fallback to "Current Weather" text
+  const weatherCard = page.getByTestId("weather-card");
+  const currentWeatherText = page.getByText("Current Weather");
+
+  // Try test ID first, fallback to text
+  try {
+    await expect(weatherCard).toBeVisible({ timeout: 10000 });
+  } catch (e) {
+    // Fallback to checking for "Current Weather" text
+    await expect(currentWeatherText.first()).toBeVisible({ timeout: 10000 });
+  }
+
+  // Verify weather content is present (use flexible selectors)
+  const hasHumidity = await page
+    .getByText("Humidity")
+    .isVisible()
+    .catch(() => false);
+  const hasWind = await page
+    .getByText("Wind")
+    .isVisible()
+    .catch(() => false);
+  const hasCityName = await page
+    .locator("h3")
+    .filter({ hasText: /San Francisco/i })
+    .isVisible()
+    .catch(() => false);
+
+  // At least one of these should be true
+  expect(hasHumidity || hasWind || hasCityName).toBeTruthy();
+
+  // Click second suggestion
+  await page.getByRole("button", { name: "Weather in New York" }).click();
+  await page.waitForTimeout(2000);
+
+  // Verify at least one weather-related element is still visible
+  const weatherElements = await page.getByText(/Weather|Humidity|Wind|Temperature/i).count();
+  expect(weatherElements).toBeGreaterThan(0);
+});

typescript-sdk/apps/dojo/src/agents.ts

@@ -281,6 +281,9 @@ export const agentsIntegrations: AgentIntegrationConfig[] = [
         shared_state: new LlamaIndexAgent({
           url: `${envVars.llamaIndexUrl}/shared_state/run`,
         }),
+        backend_tool_rendering: new LlamaIndexAgent({
+          url: `${envVars.llamaIndexUrl}/backend_tool_rendering/run`,
+        }),
       };
     },
   },

typescript-sdk/integrations/llamaindex/server-py/pyproject.toml

@@ -15,6 +15,7 @@ dependencies = [
     "jsonpatch>=1.33",
     "uvicorn>=0.27.0",
     "fastapi>=0.100.0",
+    "httpx>=0.24.0",
 ]
 authors = [
     { name = "Logan Markewich", email = "[email protected]" },

typescript-sdk/integrations/llamaindex/server-py/server/__init__.py

@@ -6,14 +6,16 @@
 from .routers.human_in_the_loop import human_in_the_loop_router
 from .routers.agentic_generative_ui import agentic_generative_ui_router
 from .routers.shared_state import shared_state_router
+from .routers.backend_tool_rendering import backend_tool_rendering_router
 
 app = FastAPI(title="AG-UI Llama-Index Endpoint")
 
 app.include_router(agentic_chat_router, prefix="/agentic_chat")
 app.include_router(human_in_the_loop_router, prefix="/human_in_the_loop")
 app.include_router(agentic_generative_ui_router, prefix="/agentic_generative_ui")
-app.include_router(shared_state_router, prefix="/shared_state")
 
+app.include_router(shared_state_router, prefix="/shared_state")
+app.include_router(backend_tool_rendering_router, prefix="/backend_tool_rendering")
 def main():
 
     """Main function to start the FastAPI server."""

typescript-sdk/integrations/llamaindex/server-py/server/routers/backend_tool_rendering.py

@@ -0,0 +1,124 @@
+"""Backend Tool Rendering feature."""
+
+from __future__ import annotations
+
+from datetime import datetime
+import json
+from textwrap import dedent
+from zoneinfo import ZoneInfo
+
+import httpx
+from llama_index.llms.openai import OpenAI
+from llama_index.protocols.ag_ui.router import get_ag_ui_workflow_router
+
+
+def get_weather_condition(code: int) -> str:
+    """Map weather code to human-readable condition.
+
+    Args:
+        code: WMO weather code.
+
+    Returns:
+        Human-readable weather condition string.
+    """
+    conditions = {
+        0: "Clear sky",
+        1: "Mainly clear",
+        2: "Partly cloudy",
+        3: "Overcast",
+        45: "Foggy",
+        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 snow fall",
+        73: "Moderate snow fall",
+        75: "Heavy snow fall",
+        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 conditions.get(code, "Unknown")
+
+
+async def get_weather(location: str) -> str:
+    """Get current weather for a location.
+
+    Args:
+        location: City name.
+
+    Returns:
+        Dictionary with weather information including temperature, feels like,
+        humidity, wind speed, wind gust, conditions, and location name.
+    """
+    async with httpx.AsyncClient() as client:
+        # Geocode the location
+        geocoding_url = (
+            f"https://geocoding-api.open-meteo.com/v1/search?name={location}&count=1"
+        )
+        geocoding_response = await client.get(geocoding_url)
+        geocoding_data = geocoding_response.json()
+
+        if not geocoding_data.get("results"):
+            raise ValueError(f"Location '{location}' not found")
+
+        result = geocoding_data["results"][0]
+        latitude = result["latitude"]
+        longitude = result["longitude"]
+        name = result["name"]
+
+        # Get weather data
+        weather_url = (
+            f"https://api.open-meteo.com/v1/forecast?"
+            f"latitude={latitude}&longitude={longitude}"
+            f"&current=temperature_2m,apparent_temperature,relative_humidity_2m,"
+            f"wind_speed_10m,wind_gusts_10m,weather_code"
+        )
+        weather_response = await client.get(weather_url)
+        weather_data = weather_response.json()
+
+        current = weather_data["current"]
+
+        return json.dumps({
+            "temperature": current["temperature_2m"],
+            "feelsLike": current["apparent_temperature"],
+            "humidity": current["relative_humidity_2m"],
+            "windSpeed": current["wind_speed_10m"],
+            "windGust": current["wind_gusts_10m"],
+            "conditions": get_weather_condition(current["weather_code"]),
+            "location": name,
+        })
+
+
+# Create the router with weather tools
+backend_tool_rendering_router = get_ag_ui_workflow_router(
+    llm=OpenAI(model="gpt-4o-mini"),
+    backend_tools=[get_weather],
+    system_prompt=dedent(
+        """
+        You are a helpful weather assistant that provides accurate weather information.
+
+      Your primary function is to help users get weather details for specific locations. When responding:
+      - Always ask for a location if none is provided
+      - If the location name isn’t in English, please translate it
+      - If giving a location with multiple parts (e.g. "New York, NY"), use the most relevant part (e.g. "New York")
+      - Include relevant details like humidity, wind conditions, and precipitation
+      - Keep responses concise but informative
+
+      Use the get_weather tool to fetch current weather data.
+        """
+    ),
+)