holmesgpt 0.13.1__py3-none-any.whl → 0.13.2__py3-none-any.whl

holmes/plugins/toolsets/grafana/toolset_grafana_tempo.py

@@ -1,4 +1,5 @@
 import os
+import re
 from typing import Any, Dict, List, cast
 
 import requests  # type: ignore
@@ -35,6 +36,8 @@ from holmes.plugins.toolsets.utils import (
 TEMPO_LABELS_ADD_PREFIX = load_bool("TEMPO_LABELS_ADD_PREFIX", True)
 
 ONE_HOUR_IN_SECONDS = 3600
+DEFAULT_TRACES_TIME_SPAN_SECONDS = DEFAULT_TIME_SPAN_SECONDS  # 7 days
+DEFAULT_TAGS_TIME_SPAN_SECONDS = 8 * ONE_HOUR_IN_SECONDS  # 8 hours
 
 
 class GrafanaTempoLabelsConfig(BaseModel):
@@ -64,6 +67,52 @@ class BaseGrafanaTempoToolset(BaseGrafanaToolset):
     def grafana_config(self) -> GrafanaTempoConfig:
         return cast(GrafanaTempoConfig, self._grafana_config)
 
+    def build_k8s_filters(
+        self, params: Dict[str, Any], use_exact_match: bool
+    ) -> List[str]:
+        """Build TraceQL filters for k8s parameters.
+
+        Args:
+            params: Dictionary containing k8s parameters
+            use_exact_match: If True, uses exact match (=), if False uses regex match (=~)
+
+        Returns:
+            List of TraceQL filter strings
+        """
+        prefix = ""
+        if TEMPO_LABELS_ADD_PREFIX:
+            prefix = "resource."
+
+        filters = []
+        labels = self.grafana_config.labels
+
+        # Define parameter mappings: (param_name, label_attribute)
+        parameter_mappings = [
+            ("service_name", "service"),
+            ("pod_name", "pod"),
+            ("namespace_name", "namespace"),
+            ("deployment_name", "deployment"),
+            ("node_name", "node"),
+        ]
+
+        for param_name, label_attr in parameter_mappings:
+            value = params.get(param_name)
+            if value:
+                # Get the label from the config
+                label = getattr(labels, label_attr)
+
+                # Build the filter based on match type
+                if use_exact_match:
+                    # Escape double quotes in the value for exact match
+                    escaped_value = value.replace('"', '\\"')
+                    filters.append(f'{prefix}{label}="{escaped_value}"')
+                else:
+                    # Escape regex special characters for partial match
+                    escaped_value = re.escape(value)
+                    filters.append(f'{prefix}{label}=~".*{escaped_value}.*"')
+
+        return filters
+
 
 def validate_params(params: Dict[str, Any], expected_params: List[str]):
     for param in expected_params:
@@ -110,7 +159,7 @@ class GetTempoTraces(Tool):
                     required=False,
                 ),
                 "start_datetime": ToolParameter(
-                    description="The beginning time boundary for the trace search period. String in RFC3339 format. If a negative integer, the number of seconds relative to the end_timestamp. Defaults to negative one hour (-3600)",
+                    description=f"The beginning time boundary for the trace search period. String in RFC3339 format. If a negative integer, the number of seconds relative to the end_timestamp. Defaults to -{DEFAULT_TRACES_TIME_SPAN_SECONDS}",
                     type="string",
                     required=False,
                 ),
@@ -133,10 +182,11 @@ class GetTempoTraces(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         api_key = self._toolset.grafana_config.api_key
         headers = self._toolset.grafana_config.headers
-        labels = self._toolset.grafana_config.labels
 
         invalid_params_error = validate_params(
             params, ["service_name", "pod_name", "deployment_name"]
@@ -151,28 +201,10 @@ class GetTempoTraces(Tool):
         start, end = process_timestamps_to_int(
             params.get("start_datetime"),
             params.get("end_datetime"),
-            default_time_span_seconds=DEFAULT_TIME_SPAN_SECONDS,
+            default_time_span_seconds=DEFAULT_TRACES_TIME_SPAN_SECONDS,
         )
 
-        prefix = ""
-        if TEMPO_LABELS_ADD_PREFIX:
-            prefix = "resource."
-
-        filters = []
-        if params.get("service_name"):
-            filters.append(f'{prefix}{labels.service}="{params.get("service_name")}"')
-        if params.get("pod_name"):
-            filters.append(f'{prefix}{labels.pod}="{params.get("pod_name")}"')
-        if params.get("namespace_name"):
-            filters.append(
-                f'{prefix}{labels.namespace}="{params.get("namespace_name")}"'
-            )
-        if params.get("deployment_name"):
-            filters.append(
-                f'{prefix}{labels.deployment}="{params.get("deployment_name")}"'
-            )
-        if params.get("node_name"):
-            filters.append(f'{prefix}{labels.node}="{params.get("node_name")}"')
+        filters = self._toolset.build_k8s_filters(params, use_exact_match=True)
 
         filters.append(f'duration>{get_param_or_raise(params, "min_duration")}')
 
@@ -207,7 +239,7 @@ class GetTempoTags(Tool):
             description="List the tags available in Tempo",
             parameters={
                 "start_datetime": ToolParameter(
-                    description="The beginning time boundary for the search period. String in RFC3339 format. If a negative integer, the number of seconds relative to the end_timestamp. Defaults to negative 8 hours (-3600)",
+                    description=f"The beginning time boundary for the search period. String in RFC3339 format. If a negative integer, the number of seconds relative to the end_timestamp. Defaults to -{DEFAULT_TAGS_TIME_SPAN_SECONDS}",
                     type="string",
                     required=False,
                 ),
@@ -220,13 +252,15 @@ class GetTempoTags(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         api_key = self._toolset.grafana_config.api_key
         headers = self._toolset.grafana_config.headers
         start, end = process_timestamps_to_int(
             start=params.get("start_datetime"),
             end=params.get("end_datetime"),
-            default_time_span_seconds=8 * ONE_HOUR_IN_SECONDS,
+            default_time_span_seconds=DEFAULT_TAGS_TIME_SPAN_SECONDS,
         )
 
         base_url = get_base_url(self._toolset.grafana_config)
@@ -246,9 +280,7 @@ class GetTempoTags(Tool):
                 params=params,
             )
         except requests.exceptions.RequestException as e:
-            raise Exception(
-                f"Failed to retrieve trace by ID after retries: {e} \n for URL: {url}"
-            )
+            raise Exception(f"Failed to retrieve tags: {e} \n for URL: {url}")
 
     def get_parameterized_one_liner(self, params: Dict) -> str:
         return f"{toolset_name_for_one_liner(self._toolset.name)}: Fetched Tempo tags"
@@ -269,7 +301,9 @@ class GetTempoTraceById(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         labels_mapping = self._toolset.grafana_config.labels
         labels = list(labels_mapping.model_dump().values())
 
@@ -291,14 +325,247 @@ class GetTempoTraceById(Tool):
         return f"{toolset_name_for_one_liner(self._toolset.name)}: Fetched Tempo Trace (trace_id={params.get('trace_id')})"
 
 
+class FetchTracesSimpleComparison(Tool):
+    def __init__(self, toolset: BaseGrafanaTempoToolset):
+        super().__init__(
+            name="fetch_tempo_traces_comparative_sample",
+            description="""Fetches statistics and representative samples of fast, slow, and typical traces for performance analysis. Requires either a `base_query` OR at least one of `service_name`, `pod_name`, `namespace_name`, `deployment_name`, `node_name`.
+
+Important: call this tool first when investigating performance issues via traces. This tool provides comprehensive analysis for identifying patterns.
+
+Examples:
+- For service latency: service_name="payment" (matches "payment-service" too)
+- For namespace issues: namespace_name="production"
+- Combined: service_name="auth", namespace_name="staging\"""",
+            parameters={
+                "service_name": ToolParameter(
+                    description="Service to analyze (partial match supported)",
+                    type="string",
+                    required=False,
+                ),
+                "pod_name": ToolParameter(
+                    description="Filter traces by pod name (partial match supported)",
+                    type="string",
+                    required=False,
+                ),
+                "namespace_name": ToolParameter(
+                    description="Kubernetes namespace to filter traces",
+                    type="string",
+                    required=False,
+                ),
+                "deployment_name": ToolParameter(
+                    description="Filter traces by deployment name (partial match supported)",
+                    type="string",
+                    required=False,
+                ),
+                "node_name": ToolParameter(
+                    description="Filter traces by node name",
+                    type="string",
+                    required=False,
+                ),
+                "base_query": ToolParameter(
+                    description="Custom TraceQL filter",
+                    type="string",
+                    required=False,
+                ),
+                "sample_count": ToolParameter(
+                    description="Number of traces to fetch from each category (fastest/slowest). Default 3",
+                    type="integer",
+                    required=False,
+                ),
+                "start_datetime": ToolParameter(
+                    description=f"The beginning time boundary for the trace search period. String in RFC3339 format. If a negative integer, the number of seconds relative to the end_timestamp. Defaults to -{DEFAULT_TRACES_TIME_SPAN_SECONDS}",
+                    type="string",
+                    required=False,
+                ),
+                "end_datetime": ToolParameter(
+                    description="The ending time boundary for the trace search period. String in RFC3339 format. Defaults to NOW().",
+                    type="string",
+                    required=False,
+                ),
+            },
+        )
+        self._toolset = toolset
+
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
+        try:
+            # Build query
+            if params.get("base_query"):
+                base_query = params["base_query"]
+            else:
+                # Use the shared utility with partial matching (regex)
+                filters = self._toolset.build_k8s_filters(params, use_exact_match=False)
+
+                # Validate that at least one parameter was provided
+                invalid_params_error = validate_params(
+                    params,
+                    [
+                        "service_name",
+                        "pod_name",
+                        "namespace_name",
+                        "deployment_name",
+                        "node_name",
+                    ],
+                )
+                if invalid_params_error:
+                    return StructuredToolResult(
+                        status=ToolResultStatus.ERROR,
+                        error=invalid_params_error,
+                        params=params,
+                    )
+
+                base_query = " && ".join(filters)
+
+            sample_count = params.get("sample_count", 3)
+
+            start, end = process_timestamps_to_int(
+                params.get("start_datetime"),
+                params.get("end_datetime"),
+                default_time_span_seconds=DEFAULT_TRACES_TIME_SPAN_SECONDS,
+            )
+
+            base_url = get_base_url(self._toolset.grafana_config)
+
+            # Step 1: Get all trace summaries
+            stats_query = f"{{{base_query}}}"
+            all_traces_response = query_tempo_traces(
+                base_url=base_url,
+                api_key=self._toolset.grafana_config.api_key,
+                headers=self._toolset.grafana_config.headers,
+                query=stats_query,
+                start=start,
+                end=end,
+                limit=1000,
+            )
+
+            traces = all_traces_response.get("traces", [])
+            if not traces:
+                return StructuredToolResult(
+                    status=ToolResultStatus.SUCCESS,
+                    data="No traces found matching the query",
+                    params=params,
+                )
+
+            # Step 2: Sort traces by duration
+            sorted_traces = sorted(traces, key=lambda x: x.get("durationMs", 0))
+
+            # Step 3: Calculate basic statistics
+            durations = [t.get("durationMs", 0) for t in sorted_traces]
+            stats = {
+                "trace_count": len(durations),
+                "min_ms": durations[0],
+                "p25_ms": durations[len(durations) // 4]
+                if len(durations) >= 4
+                else durations[0],
+                "p50_ms": durations[len(durations) // 2],
+                "p75_ms": durations[3 * len(durations) // 4]
+                if len(durations) >= 4
+                else durations[-1],
+                "p90_ms": durations[int(len(durations) * 0.9)]
+                if len(durations) >= 10
+                else durations[-1],
+                "p99_ms": durations[int(len(durations) * 0.99)]
+                if len(durations) >= 100
+                else durations[-1],
+                "max_ms": durations[-1],
+            }
+
+            # Step 4: Select representative traces to fetch
+            fastest_indices = list(range(min(sample_count, len(sorted_traces))))
+            slowest_indices = list(
+                range(max(0, len(sorted_traces) - sample_count), len(sorted_traces))
+            )
+
+            # Add median trace
+            median_idx = len(sorted_traces) // 2
+
+            # Step 5: Fetch full trace details
+            def fetch_full_trace(trace_summary):
+                trace_id = trace_summary.get("traceID")
+                if not trace_id:
+                    return None
+
+                try:
+                    url = f"{base_url}/api/traces/{trace_id}"
+                    response = requests.get(
+                        url,
+                        headers=build_headers(
+                            api_key=self._toolset.grafana_config.api_key,
+                            additional_headers=self._toolset.grafana_config.headers,
+                        ),
+                        timeout=5,
+                    )
+                    response.raise_for_status()
+                    return {
+                        "traceID": trace_id,
+                        "durationMs": trace_summary.get("durationMs", 0),
+                        "rootServiceName": trace_summary.get(
+                            "rootServiceName", "unknown"
+                        ),
+                        "traceData": response.json(),  # Raw trace data
+                    }
+                except requests.exceptions.RequestException as e:
+                    error_msg = f"Failed to fetch full trace: {str(e)}"
+                    if hasattr(e, "response") and e.response is not None:
+                        error_msg += f" (Status: {e.response.status_code})"
+                    return {
+                        "traceID": trace_id,
+                        "durationMs": trace_summary.get("durationMs", 0),
+                        "error": error_msg,
+                    }
+                except (ValueError, KeyError) as e:
+                    return {
+                        "traceID": trace_id,
+                        "durationMs": trace_summary.get("durationMs", 0),
+                        "error": f"Failed to parse trace data: {str(e)}",
+                    }
+
+            # Fetch the selected traces
+            result = {
+                "statistics": stats,
+                "all_trace_durations_ms": durations,  # All durations for distribution analysis
+                "fastest_traces": [
+                    fetch_full_trace(sorted_traces[i]) for i in fastest_indices
+                ],
+                "median_trace": fetch_full_trace(sorted_traces[median_idx]),
+                "slowest_traces": [
+                    fetch_full_trace(sorted_traces[i]) for i in slowest_indices
+                ],
+            }
+
+            # Return as YAML for readability
+            return StructuredToolResult(
+                status=ToolResultStatus.SUCCESS,
+                data=yaml.dump(result, default_flow_style=False, sort_keys=False),
+                params=params,
+            )
+
+        except Exception as e:
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                error=f"Error fetching traces: {str(e)}",
+                params=params,
+            )
+
+    def get_parameterized_one_liner(self, params: Dict) -> str:
+        return f"{toolset_name_for_one_liner(self._toolset.name)}: Simple Tempo Traces Comparison"
+
+
 class GrafanaTempoToolset(BaseGrafanaTempoToolset):
     def __init__(self):
         super().__init__(
             name="grafana/tempo",
             description="Fetches kubernetes traces from Tempo",
             icon_url="https://grafana.com/static/assets/img/blog/tempo.png",
-            docs_url="https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/grafanatempo.html",
-            tools=[GetTempoTraces(self), GetTempoTraceById(self), GetTempoTags(self)],
+            docs_url="https://holmesgpt.dev/data-sources/builtin-toolsets/grafanatempo/",
+            tools=[
+                FetchTracesSimpleComparison(self),
+                GetTempoTraces(self),
+                GetTempoTraceById(self),
+                GetTempoTags(self),
+            ],
         )
         template_file_path = os.path.abspath(
             os.path.join(os.path.dirname(__file__), "toolset_grafana_tempo.jinja2")

holmes/plugins/toolsets/helm.yaml

@@ -1,7 +1,7 @@
 toolsets:
   helm/core:
     description: "Read access to cluster's Helm charts and releases"
-    docs_url: "https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/helm.html"
+    docs_url: "https://holmesgpt.dev/data-sources/builtin-toolsets/helm/"
     icon_url: "https://helm.sh/img/helm.svg"
     tags:
       - core

holmes/plugins/toolsets/internet/internet.py

@@ -186,7 +186,9 @@ class FetchWebpage(Tool):
             toolset=toolset,  # type: ignore
         )
 
-    def _invoke(self, params: Any) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         url: str = params["url"]
 
         additional_headers = (
@@ -268,7 +270,7 @@ class InternetToolset(InternetBaseToolset):
             tools=[
                 FetchWebpage(self),
             ],
-            docs_url="https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/internet.html",
+            docs_url="https://holmesgpt.dev/data-sources/builtin-toolsets/internet/",
             tags=[
                 ToolsetTag.CORE,
             ],

holmes/plugins/toolsets/internet/notion.py

@@ -44,7 +44,9 @@ class FetchNotion(Tool):
             return f"https://api.notion.com/v1/blocks/{notion_id}/children"
         return url  # Return original URL if no match is found
 
-    def _invoke(self, params: Any) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         url: str = params["url"]
 
         # Get headers from the toolset configuration
@@ -118,7 +120,7 @@ class NotionToolset(InternetBaseToolset):
             name="notion",
             description="Fetch notion webpages",
             icon_url="https://upload.wikimedia.org/wikipedia/commons/thumb/e/e9/Notion-logo.svg/2048px-Notion-logo.svg.png",
-            docs_url="https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/notion.html",
+            docs_url="https://holmesgpt.dev/data-sources/builtin-toolsets/notion/",
             tools=[
                 FetchNotion(self),
             ],

holmes/plugins/toolsets/investigator/core_investigation.py

@@ -3,10 +3,7 @@ import os
 from typing import Any, Dict
 
 from uuid import uuid4
-from holmes.core.todo_manager import (
-    get_todo_manager,
-)
-
+from holmes.core.todo_tasks_formatter import format_tasks
 from holmes.core.tools import (
     Toolset,
     ToolsetTag,
@@ -35,11 +32,6 @@ class TodoWriteTool(Tool):
                 },
             ),
         ),
-        "investigation_id": ToolParameter(
-            description="This investigation identifier. This is a uuid that represents the investigation session id.",
-            type="string",
-            required=True,
-        ),
     }
 
     # Print a nice table to console/log
@@ -82,7 +74,9 @@ class TodoWriteTool(Tool):
 
         logging.info(separator)
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         try:
             todos_data = params.get("todos", [])
 
@@ -99,14 +93,8 @@ class TodoWriteTool(Tool):
 
             logging.info(f"Tasks: {len(tasks)}")
 
-            # Store tasks in session storage
-            todo_manager = get_todo_manager()
-            session_id = params.get("investigation_id", "")
-            todo_manager.update_session_tasks(session_id, tasks)
-
             self.print_tasks_table(tasks)
-
-            formatted_tasks = todo_manager.format_tasks_for_prompt(session_id)
+            formatted_tasks = format_tasks(tasks)
 
             response_data = f"✅ Investigation plan updated with {len(tasks)} tasks. Tasks are now stored in session and will appear in subsequent prompts.\n\n"
             if formatted_tasks:

holmes/plugins/toolsets/investigator/investigator_instructions.jinja2

@@ -59,12 +59,8 @@ The user will primarily request you perform reliability troubleshooting and inci
 
 You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.
 
-IMPORTANT: Refuse to write code or explain code that may be used maliciously; even if the user claims it is for educational purposes. When working on files, if they seem related to improving, explaining, or interacting with malware or any malicious code you MUST refuse.
-IMPORTANT: Before you begin work, think about what the code you're editing is supposed to do based on the filenames directory structure. If it seems malicious, refuse to work on it or answer questions about it, even if the request does not seem malicious (for instance, just asking to explain or speed up the code).
-
 IMPORTANT: Always use the TodoWrite tool to plan and track tasks throughout the conversation.
 
-
 # TodoWrite
 Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
@@ -221,7 +217,7 @@ The assistant did not use the todo list because this is a single command executi
 2. **Task Management**:
    - Update task status in real-time as you work
    - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-   - Only have ONE task in_progress at any time
+   - If tasks are not dependent on one another, handle multiple tasks in parallel and mark them in_progress.
 
 3. **Task Completion Requirements**:
    - ONLY mark a task as completed when you have FULLY accomplished it

holmes/plugins/toolsets/kafka.py

@@ -153,7 +153,9 @@ class ListKafkaConsumers(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
             client = self.get_kafka_client(kafka_cluster_name)
@@ -226,7 +228,9 @@ class DescribeConsumerGroup(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         group_id = params["group_id"]
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
@@ -282,7 +286,9 @@ class ListTopics(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
             client = self.get_kafka_client(kafka_cluster_name)
@@ -338,7 +344,9 @@ class DescribeTopic(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         topic_name = params["topic_name"]
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
@@ -461,7 +469,9 @@ class FindConsumerGroupsByTopic(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         topic_name = params["topic_name"]
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
@@ -549,7 +559,9 @@ class ListKafkaClusters(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(self, params: Dict) -> StructuredToolResult:
+    def _invoke(
+        self, params: dict, user_approved: bool = False
+    ) -> StructuredToolResult:
         cluster_names = list(self.toolset.clients.keys())
         return StructuredToolResult(
             status=ToolResultStatus.SUCCESS,
@@ -571,7 +583,7 @@ class KafkaToolset(Toolset):
             name="kafka/admin",
             description="Fetches metadata from multiple Kafka clusters",
             prerequisites=[CallablePrerequisite(callable=self.prerequisites_callable)],
-            docs_url="https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/kafka.html",
+            docs_url="https://holmesgpt.dev/data-sources/builtin-toolsets/kafka/",
             icon_url="https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcT-cR1JrBgJxB_SPVKUIRwtiHnR8qBvLeHXjQ&s",
             tags=[ToolsetTag.CORE],
             tools=[

holmes/plugins/toolsets/kubernetes.yaml

@@ -1,7 +1,7 @@
 toolsets:
   kubernetes/core:
     description: "Read access to cluster resources (excluding secrets and other sensitive data)"
-    docs_url: "https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/kubernetes.html#core"
+    docs_url: "https://holmesgpt.dev/data-sources/builtin-toolsets/kubernetes/"
     icon_url: "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRPKA-U9m5BxYQDF1O7atMfj9EMMXEoGu4t0Q&s"
     tags:
       - core
@@ -197,7 +197,7 @@ toolsets:
 
   kubernetes/live-metrics:
     description: "Provides real-time metrics for pods and nodes"
-    docs_url: "https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/kubernetes.html#live-metrics"
+    docs_url: "https://holmesgpt.dev/data-sources/builtin-toolsets/kubernetes/"
     icon_url: "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRPKA-U9m5BxYQDF1O7atMfj9EMMXEoGu4t0Q&s"
     llm_instructions: |
       The kubectl_top_pods or kubectl_top_nodes do not return time series data or metrics that can be used for graphs
@@ -219,7 +219,7 @@ toolsets:
 
   kubernetes/kube-prometheus-stack:
     description: "Fetches prometheus definition"
-    docs_url: "https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/kubernetes.html#prometheus-stack"
+    docs_url: "https://holmesgpt.dev/data-sources/builtin-toolsets/kubernetes/"
     icon_url: "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRPKA-U9m5BxYQDF1O7atMfj9EMMXEoGu4t0Q&s"
     tags:
       - core
@@ -230,7 +230,7 @@ toolsets:
 
   kubernetes/krew-extras: # To make this work, install kube-lineage with krew
     description: "Fetches children/dependents and parents/dependencies resources using kube-lineage installed via `kubectl krew`"
-    docs_url: "https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/kubernetes.html#resource-lineage-extras-with-krew"
+    docs_url: "https://holmesgpt.dev/data-sources/builtin-toolsets/kubernetes/"
     icon_url: "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRPKA-U9m5BxYQDF1O7atMfj9EMMXEoGu4t0Q&s"
     tags:
       - cli
@@ -246,7 +246,7 @@ toolsets:
 
   kubernetes/kube-lineage-extras: # To make this work, build kube-lineage from source
     description: "Fetches children/dependents and parents/dependencies resources using kube-lineage"
-    docs_url: "https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/kubernetes.html#resource-lineage-extras"
+    docs_url: "https://holmesgpt.dev/data-sources/builtin-toolsets/kubernetes/"
     icon_url: "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRPKA-U9m5BxYQDF1O7atMfj9EMMXEoGu4t0Q&s"
     tags:
       - cluster