Merge pull request #3029 from stbenjam/graphs

chat: support graphing with plotly

Author: openshift-merge-bot[bot]

chat/sippy_agent/agent.py

@@ -263,28 +263,96 @@ def _create_agent_graph(self):
 
 #### Reporting Test Failures
 
-* List up to 5 failing tests explicitly. Summarize extras (e.g., “…and 3 more failed”).
+* List up to 5 failing tests explicitly. Summarize extras (e.g., "…and 3 more failed").
 * Explain what those tests validate and why they might fail.
 
 #### Correlating Failures with Changes
 
 * Do **not** analyze changelog until after identifying test failures.
 * Match failure keywords (e.g., *networking, storage*) to PR components or repos.
-* Only report correlations when there’s a clear thematic link.
+* Only report correlations when there's a clear thematic link.
 
 #### Correlating Failures with Incidents
 
 * Always use `check_known_incidents` when analyzing payload failures.
 * Prefer log evidence, but note correlations if timing and symptoms align.
 
+#### Creating Visualizations
+
+When users request visual representations (e.g., "plot", "graph", "chart", "visualize"), you can create interactive Plotly charts directly in your response.
+
+**How to create a visualization:**
+
+1. After your main text response, include a visualization block using these exact markers:
+   ```
+   VISUALIZATION_START
+   {{
+     "data": [...],
+     "layout": {{...}},
+     "config": {{...}}
+   }}
+   VISUALIZATION_END
+   ```
+
+2. The JSON must be valid Plotly specification with three fields:
+   - **data**: Array of trace objects (required)
+   - **layout**: Layout configuration object (required)
+   - **config**: Optional config object for controls
+
+**Example - Line chart for test success rates over time:**
+```
+Here's the trend for the test over the last 7 days:
+
+VISUALIZATION_START
+{{
+  "data": [
+    {{
+      "x": ["2025-10-08", "2025-10-09", "2025-10-10", "2025-10-11", "2025-10-12", "2025-10-13", "2025-10-14"],
+      "y": [85, 82, 90, 88, 91, 89, 92],
+      "type": "scatter",
+      "mode": "lines+markers",
+      "name": "Success Rate",
+      "line": {{"color": "#4caf50", "width": 3}},
+      "marker": {{"size": 8}}
+    }}
+  ],
+  "layout": {{
+    "title": {{"text": "Test Success Rate - Last 7 Days"}},
+    "xaxis": {{"title": "Date"}},
+    "yaxis": {{"title": "Success Rate (%)", "range": [0, 100]}},
+    "hovermode": "x unified"
+  }}
+}}
+VISUALIZATION_END
+```
+
+**Common chart types:**
+- **Line charts**: `"type": "scatter", "mode": "lines+markers"` - for trends over time
+- **Bar charts**: `"type": "bar"` - for comparisons across categories
+- **Scatter plots**: `"type": "scatter", "mode": "markers"` - for correlations
+- **Multi-series**: Include multiple objects in the `data` array
+
+**Important:**
+- Only create visualizations when the user explicitly requests them or when visual data would significantly enhance understanding
+- Always provide text analysis alongside the visualization
+- Use colors that work in both light and dark modes
+- Keep it simple - don't include excessive styling
+
+**Color Guidelines:**
+- **Success/passing data**: Use green shades
+- **Failure/error data**: Use red shade
+- **Multiple categories**: When showing multiple distinct categories (not success/failure), use colors that make sense for the data
+- Ensure colors have sufficient contrast for readability in both light and dark themes
+
 #### Final Answer Composition
 
 Your final answer must be **comprehensive**:
 
 * List failing jobs and tests.
 * Explain likely causes.
 * Include relevant links (Jobs, PRs, Issues, Incidents).
-* Suggest the next logical step (e.g., *“Would you like me to analyze the logs?”*).
+* Include visualizations when requested or when they add significant value.
+* Suggest the next logical step (e.g., *"Would you like me to analyze the logs?"*).
 """
 
         # Apply persona modification (always prepend if present)

chat/sippy_agent/api_models.py

@@ -33,12 +33,21 @@ class ThinkingStep(BaseModel):
     observation: str
 
 
+class Visualization(BaseModel):
+    """A Plotly visualization specification."""
+
+    data: List[Dict[str, Any]]  # Plotly data traces
+    layout: Dict[str, Any]  # Plotly layout configuration
+    config: Optional[Dict[str, Any]] = None  # Optional Plotly config
+
+
 class ChatResponse(BaseModel):
     """Response model for chat endpoint."""
 
     response: str
     thinking_steps: Optional[List[ThinkingStep]] = None
     tools_used: Optional[List[str]] = None
+    visualizations: Optional[List[Visualization]] = None
     error: Optional[str] = None
 
 

chat/sippy_agent/web_server.py

@@ -26,6 +26,7 @@
     HealthResponse,
     PersonaInfo,
     PersonasResponse,
+    Visualization,
 )
 from . import metrics
 from .metrics_server import start_metrics_server, stop_metrics_server
@@ -192,41 +193,15 @@ async def chat(request: ChatRequest):
                         request.message, request.chat_history
                     )
 
-                    if isinstance(result, dict) and "thinking_steps" in result:
-                        # Convert thinking steps to API format
-                        thinking_steps = []
-                        for i, step in enumerate(result["thinking_steps"], 1):
-                            thinking_steps.append(
-                                ThinkingStep(
-                                    step_number=i,
-                                    thought=step.get("thought", ""),
-                                    action=step.get("action", ""),
-                                    action_input=step.get("action_input", ""),
-                                    observation=step.get("observation", ""),
-                                )
-                            )
-
-                        response_text = result["output"]
-                        
-                        # Track response size
-                        response_size = len(response_text.encode('utf-8'))
-                        metrics.message_size_bytes.labels(direction="response").observe(response_size)
-                        
-                        return ChatResponse(
-                            response=response_text,
-                            thinking_steps=thinking_steps,
-                            tools_used=self._extract_tools_used(
-                                result["thinking_steps"]
-                            ),
-                        )
-                    else:
-                        # Track response size
-                        response_size = len(result.encode('utf-8'))
-                        metrics.message_size_bytes.labels(direction="response").observe(response_size)
-                        
-                        return ChatResponse(
-                            response=result, thinking_steps=None, tools_used=None
-                        )
+                    # Process the response using common method
+                    processed = self._process_agent_response(result)
+                    
+                    return ChatResponse(
+                        response=processed["response_text"],
+                        thinking_steps=processed["thinking_steps"],
+                        tools_used=processed["tools_used"],
+                        visualizations=processed["visualizations"],
+                    )
 
                 finally:
                     # Restore original settings
@@ -367,27 +342,19 @@ async def thinking_callback(
                                 ),
                             )
 
-                            # Send final response
-                            if isinstance(result, dict) and "output" in result:
-                                response_text = result["output"]
-                                tools_used = self._extract_tools_used(
-                                    result.get("thinking_steps", [])
-                                )
-                            else:
-                                response_text = result
-                                tools_used = []
-                            
-                            # Track response size
-                            response_size = len(response_text.encode('utf-8'))
-                            metrics.message_size_bytes.labels(direction="response").observe(response_size)
+                            # Process the response using common method
+                            processed = self._process_agent_response(result)
 
                             await self.websocket_manager.send_message(
                                 websocket,
                                 StreamMessage(
                                     type="final_response",
                                     data={
-                                        "response": response_text,
-                                        "tools_used": tools_used,
+                                        "response": processed["response_text"],
+                                        "tools_used": processed["tools_used"],
+                                        "visualizations": [
+                                            v.model_dump() for v in processed["visualizations"]
+                                        ] if processed["visualizations"] else [],
                                         "timestamp": datetime.now().isoformat(),
                                     },
                                 ),
@@ -483,6 +450,157 @@ def _extract_tools_used(self, thinking_steps: List[Dict[str, Any]]) -> List[str]
                 tools.add(action)
         return list(tools)
 
+    def _extract_visualizations_from_text(self, text: str) -> List[Visualization]:
+        """Extract visualization specifications from text content.
+
+        Looks for JSON blocks between VISUALIZATION_START and VISUALIZATION_END markers.
+        """
+        visualizations = []
+
+        if not text or not isinstance(text, str):
+            return visualizations
+
+        # Find all visualization blocks in the text
+        start_marker = "VISUALIZATION_START"
+        end_marker = "VISUALIZATION_END"
+
+        current_pos = 0
+        while True:
+            start_idx = text.find(start_marker, current_pos)
+            if start_idx == -1:
+                break
+
+            end_idx = text.find(end_marker, start_idx)
+            if end_idx == -1:
+                logger.warning("Found VISUALIZATION_START without matching VISUALIZATION_END")
+                break
+
+            try:
+                # Extract JSON between markers
+                viz_start = start_idx + len(start_marker)
+                viz_json = text[viz_start:end_idx].strip()
+
+                # Parse the JSON
+                viz_data = json.loads(viz_json)
+
+                # Get layout and add AI-generated annotation
+                layout = viz_data.get("layout", {})
+                
+                # Ensure top margin is sufficient for the title and subtitle
+                if "margin" not in layout:
+                    layout["margin"] = {}
+                if "t" not in layout["margin"] or layout["margin"]["t"] < 80:
+                    layout["margin"]["t"] = 80
+                
+                # Add AI-generated caption as an annotation below the title
+                if "annotations" not in layout:
+                    layout["annotations"] = []
+                
+                # Position the caption in the margin area, closer to the title
+                # y > 1.0 places it in the top margin area
+                layout["annotations"].append({
+                    "text": "<i>Generated with AI by Sippy Chat</i>",
+                    "xref": "paper",
+                    "yref": "paper",
+                    "x": 0.5,
+                    "y": 1.00,  # Just above the plot area in the margin
+                    "xanchor": "center",
+                    "yanchor": "bottom",
+                    "showarrow": False,
+                    "font": {"size": 10, "color": "#666666"}
+                })
+
+                # Create Visualization object
+                visualization = Visualization(
+                    data=viz_data.get("data", []),
+                    layout=layout,
+                    config=viz_data.get("config"),
+                )
+                visualizations.append(visualization)
+
+                logger.info(f"Extracted visualization from response text")
+            except (json.JSONDecodeError, ValueError, KeyError) as e:
+                logger.warning(f"Failed to parse visualization: {e}")
+
+            # Move past this visualization block
+            current_pos = end_idx + len(end_marker)
+
+        return visualizations
+
+    def _extract_visualizations(self, response_text: str) -> List[Visualization]:
+        """Extract visualizations from response text only (not from tool observations)."""
+        visualizations = []
+
+        # Extract from main response text only
+        if response_text:
+            visualizations.extend(self._extract_visualizations_from_text(response_text))
+
+        return visualizations
+
+    def _strip_visualization_markers(self, text: str) -> str:
+        """Remove VISUALIZATION_START...VISUALIZATION_END blocks from text."""
+        if not text or not isinstance(text, str):
+            return text
+        
+        # Remove all visualization blocks (non-greedy match)
+        cleaned = re.sub(
+            r'VISUALIZATION_START[\s\S]*?VISUALIZATION_END',
+            '',
+            text,
+            flags=re.MULTILINE
+        )
+        return cleaned.strip()
+
+    def _process_agent_response(self, result: Any) -> Dict[str, Any]:
+        """
+        Process agent response and extract all components.
+        
+        Args:
+            result: The result from agent.achat() - can be dict with thinking_steps or simple string
+            
+        Returns:
+            Dict containing: response_text, thinking_steps (API format), tools_used, visualizations
+        """
+        if isinstance(result, dict) and "thinking_steps" in result:
+            # Response with thinking steps
+            response_text = result["output"]
+            thinking_steps = result["thinking_steps"]
+            tools_used = self._extract_tools_used(thinking_steps)
+            
+            # Convert thinking steps to API format
+            api_thinking_steps = []
+            for i, step in enumerate(thinking_steps, 1):
+                api_thinking_steps.append(
+                    ThinkingStep(
+                        step_number=i,
+                        thought=step.get("thought", ""),
+                        action=step.get("action", ""),
+                        action_input=step.get("action_input", ""),
+                        observation=step.get("observation", ""),
+                    )
+                )
+            thinking_steps = api_thinking_steps
+        else:
+            # Simple response without thinking steps
+            response_text = result
+            thinking_steps = None
+            tools_used = []
+        
+        # Track response size metrics
+        response_size = len(response_text.encode('utf-8'))
+        metrics.message_size_bytes.labels(direction="response").observe(response_size)
+        
+        # Extract visualizations and strip markers from response
+        visualizations = self._extract_visualizations(response_text)
+        clean_response = self._strip_visualization_markers(response_text)
+        
+        return {
+            "response_text": clean_response,
+            "thinking_steps": thinking_steps,
+            "tools_used": tools_used,
+            "visualizations": visualizations or None,
+        }
+
     def run(self, host: str = "0.0.0.0", port: int = 8000, reload: bool = False):
         """Run the web server."""
         # Start separate metrics server if port is specified