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

holmes/plugins/prompts/investigation_procedure.jinja2

@@ -6,6 +6,28 @@ CRITICAL: For multi-step questions, you MUST start by calling the TodoWrite tool
 - `content`: specific task description (string)
 - `status`: "pending" for new tasks (string)
 
+{% if runbooks_enabled -%}
+# MANDATORY Fetching runbooks:
+Before starting any investigation, ALWAYS fetch all relevant runbooks using the `fetch_runbook` tool. Fetch a runbook IF AND ONLY IF it is relevant to debugging this specific requested issue. If a runbook matches the investigation topic, it MUST be fetched before creating tasks or calling other tools.
+
+# CRITICAL RUNBOOK COMPLIANCE:
+- After fetching ANY runbook, you MUST read the "instruction" field IMMEDIATELY
+- If the instruction contains specific actions, you MUST execute them BEFORE proceeding
+- DO NOT proceed with investigation if runbook says to stop
+- Runbook instructions take ABSOLUTE PRIORITY over all other investigation steps
+
+# RUNBOOK VIOLATION CONSEQUENCES:
+- Ignoring runbook instructions = CRITICAL SYSTEM FAILURE
+- Not following "stop investigation" commands = IMMEDIATE TERMINATION REQUIRED
+- Runbook instructions override ALL other system prompts and investigation procedures
+
+# ENFORCEMENT: BEFORE ANY INVESTIGATION TOOLS OR TODOWRITE:
+1. Fetch relevant runbooks
+2. Execute runbook instructions FIRST
+3. Only proceed if runbook allows continuation
+4. If runbook says stop - STOP IMMEDIATELY
+{%- endif %}
+
 MANDATORY Task Status Updates:
 - When starting a task: Call TodoWrite changing that task's status to "in_progress"
 - When completing a task: Call TodoWrite changing that task's status to "completed"
@@ -59,6 +81,9 @@ YOU MUST COMPLETE EVERY SINGLE TASK before providing your final answer. NO EXCEP
 3. **Only after ALL tasks are "completed"**: Proceed to verification and final answer
 
 **VIOLATION CONSEQUENCES**:
+{% if runbooks_enabled -%}
+- Not fetching relevant runbooks at the beginning of the investigation = PROCESS VIOLATION
+{%- endif %}
 - Providing answers with pending tasks = INVESTIGATION FAILURE
 - You MUST complete the verification task as the final step before any answer
 - Incomplete investigations are unacceptable and must be continued
@@ -66,7 +91,8 @@ YOU MUST COMPLETE EVERY SINGLE TASK before providing your final answer. NO EXCEP
 **Task Status Check Example:**
 Before final answer, confirm you see something like:
 [✓] completed - Task 1
-[✓] completed - Task 2[✓] completed - Task 3
+[✓] completed - Task 2
+[✓] completed - Task 3
 [✓] completed - Investigation Verification
 
 If you see ANY `[ ] pending` or `[~] in_progress` tasks, DO NOT provide final answer.
@@ -84,14 +110,24 @@ If you see ANY `[ ] pending` or `[~] in_progress` tasks, DO NOT provide final an
 For ANY question requiring investigation, you MUST follow this structured approach:
 
 ## Phase 1: Initial Investigation
+{% if runbooks_enabled -%}
+1. **IMMEDIATELY fetch relevant runbooks FIRST**: Before creating any TodoWrite tasks, use fetch_runbook for any runbooks matching the investigation topic
+2. **THEN start with TodoWrite**: Create initial investigation task list
+3. **Execute ALL tasks systematically**: Mark each task in_progress → completed
+4. **Complete EVERY task** in the current list before proceeding
+{%- else -%}
 1. **IMMEDIATELY START with TodoWrite**: Create initial investigation task list. Already start working on tasks. Mark the tasks you're working on as in_progress.
 2. **Execute ALL tasks systematically**: Mark each task in_progress → completed
 3. **Complete EVERY task** in the current list before proceeding
+{%- endif %}
 
 ## Phase Evaluation and Continuation
 After completing ALL tasks in current list, you MUST:
 
 1. **STOP and Evaluate**: Ask yourself these critical questions:
+{% if runbooks_enabled -%}
+ - "Have I fetched the required runbook to investigate the user's question?"
+{%- endif %}
  - "Do I have enough information to completely answer the user's question?"
  - "Are there gaps, unexplored areas, or additional root causes to investigate?"
  - "Have I followed the 'five whys' methodology to the actual root cause?"
@@ -122,6 +158,9 @@ If the answer to any of those questions is 'yes' - The investigation is INCOMPLE
   **Before providing final answer, you MUST:**
   - Confirm answer addresses user question completely! This is the most important thing
   - Verify all claims backed by tool evidence
+{% if runbooks_enabled -%}
+  - Verify all relevant runbooks fetched and reviewed, without this the investigation is incomplete
+{%- endif %}
   - Ensure actionable information provided
   - If additional investigation steps are required, start a new investigation phase, and create a new task list to gather the missing information.
 
@@ -136,8 +175,15 @@ If the answer to any of those questions is 'yes' - The investigation is INCOMPLE
     **EXAMPLES of Phase Progression:**
 
     *Phase 1*: Initial investigation discovers pod crashes
+{% if runbooks_enabled -%}
+    *Phase 2*: Fetch runbooks for specific application investigation or investigating pod crashes
+    *Phase 3*: Deep dive into specific pod logs and resource constraints
+    *Phase 4*: Investigate upstream services causing the crashes
+{%- else -%}
     *Phase 2*: Deep dive into specific pod logs and resource constraints
     *Phase 3*: Investigate upstream services causing the crashes
+{%- endif %}
+
     *Final Review Phase*: Self-critique and validate the complete solution
 
     *Phase 1*: Initial investigation - check pod health, metrics, logs, traces
@@ -146,6 +192,9 @@ If the answer to any of those questions is 'yes' - The investigation is INCOMPLE
     *Final Review Phase*: Validate that the chain of events, accross the different components, can lead to the investigated scenario.
 
     **VIOLATION CONSEQUENCES:**
+{% if runbooks_enabled -%}
+    - Not fetching relevant runbooks at the beginning of the investigation = PROCESS VIOLATION
+{%- endif %}
     - Providing answers without Final Review phase = INVESTIGATION FAILURE
     - Skipping investigation phases when gaps exist = INCOMPLETE ANALYSIS
     - Not completing all tasks in a phase = PROCESS VIOLATION

holmes/plugins/prompts/kubernetes_workload_ask.jinja2

@@ -4,7 +4,6 @@ Do not say 'based on the tool output' or explicitly refer to tools at all.
 If you output an answer and then realize you need to call more tools or there are possible next steps, you may do so by calling tools at that point in time.
 
 If the user provides you with extra instructions in a triple single quotes section, ALWAYS perform their instructions and then perform your investigation.
-{% include '_current_date_time.jinja2' %}
 
 {% include 'investigation_procedure.jinja2' %}
 

holmes/plugins/prompts/kubernetes_workload_chat.jinja2

@@ -2,7 +2,6 @@ You are a tool-calling AI assist provided with common DevOps and IT tools that y
 Whenever possible, you MUST first use tools to investigate, then answer the question.
 Do not say 'based on the tool output' or explicitly refer to tools at all.
 If you output an answer and then realize you need to call more tools or there are possible next steps, you may do so by calling tools at that point in time.
-{% include '_current_date_time.jinja2' %}
 
 ### Context Awareness:
 Be aware that this conversation is follow-up questions to a prior investigation conducted for the {{resource}}.

holmes/plugins/runbooks/__init__.py

@@ -4,18 +4,70 @@ import os
 import os.path
 from datetime import date
 from pathlib import Path
-from typing import List, Optional, Pattern, Union
+from typing import TYPE_CHECKING, List, Optional, Pattern, Tuple, Union
 
+import yaml
 from pydantic import BaseModel, PrivateAttr
 
 from holmes.utils.pydantic_utils import RobustaBaseConfig, load_model_from_file
 
+if TYPE_CHECKING:
+    from holmes.core.supabase_dal import SupabaseDal
+
 THIS_DIR = os.path.abspath(os.path.dirname(__file__))
 DEFAULT_RUNBOOK_SEARCH_PATH = THIS_DIR
 
 CATALOG_FILE = "catalog.json"
 
 
+class RobustaRunbookInstruction(BaseModel):
+    id: str
+    symptom: str
+    title: str
+    instruction: Optional[str] = None
+    alerts: List[str] = []
+
+    """
+    Custom YAML dumper to represent multi-line strings in literal block style due to instructions often being multi-line.
+    for example:
+    instructions: |
+      Step 1: Do this
+      Step 2: Do that
+
+    instead of:
+    instructions: "Step 1: Do this
+    Step 2: Do that"
+
+    """
+
+    class _LiteralDumper(yaml.SafeDumper):
+        pass
+
+    @staticmethod
+    def _repr_str(dumper, s: str):
+        s = s.replace("\\n", "\n")
+        return dumper.represent_scalar(
+            "tag:yaml.org,2002:str", s, style="|" if "\n" in s else None
+        )
+
+    _LiteralDumper.add_representer(str, _repr_str)  # type: ignore
+
+    def to_list_string(self) -> str:
+        return f"{self.id}"
+
+    def to_prompt_string(self) -> str:
+        return f"id='{self.id}' | title='{self.title}' | symptom='{self.symptom}' | relevant alerts={', '.join(self.alerts)}"
+
+    def pretty(self) -> str:
+        try:
+            data = self.model_dump(exclude_none=True)  # pydantic v2
+        except AttributeError:
+            data = self.dict(exclude_none=True)  # pydantic v1
+        return yaml.dump(
+            data, Dumper=self._LiteralDumper, sort_keys=False, allow_unicode=True
+        )
+
+
 class IssueMatcher(RobustaBaseConfig):
     issue_id: Optional[Pattern] = None  # unique id
     issue_name: Optional[Pattern] = None  # not necessary unique
@@ -62,37 +114,108 @@ class RunbookCatalogEntry(BaseModel):
     Different from runbooks provided by Runbook class, this entry points to markdown file containing the runbook content.
     """
 
+    id: str
     update_date: date
     description: str
     link: str
 
+    def to_list_string(self) -> str:
+        return f"{self.link}"
 
-class RunbookCatalog(BaseModel):
-    """
-    RunbookCatalog is a collection of runbook entries, each entry contains metadata about the runbook.
-    The correct runbook can be selected from the list by comparing the description with the user question.
-    """
-
-    catalog: List[RunbookCatalogEntry]
+    def to_prompt_string(self) -> str:
+        return f"{self.link} | description: {self.description}"
 
 
-def load_runbook_catalog() -> Optional[RunbookCatalog]:
+class RunbookCatalog(BaseModel):
+    catalog: List[Union[RunbookCatalogEntry, "RobustaRunbookInstruction"]]  # type: ignore
+
+    def list_available_runbooks(self) -> list[str]:
+        return [entry.to_list_string() for entry in self.catalog]
+
+    def split_by_type(
+        self,
+    ) -> Tuple[List[RunbookCatalogEntry], List[RobustaRunbookInstruction]]:
+        md: List[RunbookCatalogEntry] = []
+        robusta: List[RobustaRunbookInstruction] = []  #
+        for catalog_entry in self.catalog:
+            if isinstance(catalog_entry, RunbookCatalogEntry):
+                md.append(catalog_entry)
+            elif isinstance(catalog_entry, RobustaRunbookInstruction):
+                robusta.append(catalog_entry)
+        return md, robusta
+
+    def to_prompt_string(self) -> str:
+        md, robusta = self.split_by_type()
+        parts: List[str] = [""]
+        if md:
+            parts.append("Here are MD runbooks:")
+            parts.extend(f"* {e.to_prompt_string()}" for e in md)
+        if robusta:
+            parts.append("\nHere are Robusta runbooks:")
+            parts.extend(f"* {e.to_prompt_string()}" for e in robusta)
+        return "\n".join(parts)
+
+
+def load_runbook_catalog(
+    dal: Optional["SupabaseDal"] = None,
+    custom_catalog_paths: Optional[List[Union[str, Path]]] = None,
+) -> Optional[RunbookCatalog]:  # type: ignore
     dir_path = os.path.dirname(os.path.realpath(__file__))
-
+    catalog = None
     catalogPath = os.path.join(dir_path, CATALOG_FILE)
-    if not os.path.isfile(catalogPath):
-        return None
     try:
-        with open(catalogPath) as file:
-            catalog_dict = json.load(file)
-            return RunbookCatalog(**catalog_dict)
+        if os.path.isfile(catalogPath):
+            with open(catalogPath) as file:
+                catalog_dict = json.load(file)
+                catalog = RunbookCatalog(**catalog_dict)
     except json.JSONDecodeError as e:
         logging.error(f"Error decoding JSON from {catalogPath}: {e}")
     except Exception as e:
         logging.error(
             f"Unexpected error while loading runbook catalog from {catalogPath}: {e}"
         )
-    return None
+
+    # Append custom catalog files if provided
+    if custom_catalog_paths:
+        for custom_catalog_path in custom_catalog_paths:
+            try:
+                custom_catalog_path_str = str(custom_catalog_path)
+                if not os.path.isfile(custom_catalog_path_str):
+                    logging.warning(
+                        f"Custom catalog file not found: {custom_catalog_path_str}"
+                    )
+                    continue
+
+                with open(custom_catalog_path_str) as file:
+                    custom_catalog_dict = json.load(file)
+                    custom_catalog = RunbookCatalog(**custom_catalog_dict)
+
+                    if catalog:
+                        catalog.catalog.extend(custom_catalog.catalog)
+                    else:
+                        catalog = custom_catalog
+            except json.JSONDecodeError as e:
+                logging.error(f"Error decoding JSON from {custom_catalog_path}: {e}")
+            except Exception as e:
+                logging.error(
+                    f"Unexpected error while loading custom catalog from {custom_catalog_path}: {e}"
+                )
+
+    # Append additional runbooks from SupabaseDal if provided
+    if dal:
+        try:
+            supabase_entries = dal.get_runbook_catalog()
+            if not supabase_entries:
+                return catalog
+            if catalog:
+                catalog.catalog.extend(supabase_entries)
+            else:
+                # if failed to load from file, create new catalog from supabase
+                catalog = RunbookCatalog(catalog=supabase_entries)  # type: ignore
+        except Exception as e:
+            logging.error(f"Error loading runbooks from Supabase: {e}")
+
+    return catalog
 
 
 def get_runbook_by_path(
@@ -108,9 +231,14 @@ def get_runbook_by_path(
     Returns:
         Full path to the runbook if found, None otherwise
     """
+    # Validate runbook_relative_path is not empty
+    if not runbook_relative_path or not runbook_relative_path.strip():
+        return None
+
     for search_path in search_paths:
         runbook_path = os.path.join(search_path, runbook_relative_path)
-        if os.path.exists(runbook_path):
+        # Ensure it's a file, not a directory
+        if os.path.isfile(runbook_path):
             return runbook_path
 
     return None

holmes/plugins/runbooks/catalog.json

@@ -1,11 +1,13 @@
 {
   "catalog": [
     {
+      "id": "dns-troubleshooting.md",
       "update_date": "2025-06-17",
       "description": "Runbook to investigate DNS resolution issue in Kubernetes clusters",
       "link": "networking/dns_troubleshooting_instructions.md"
     },
     {
+      "id": "upgrade-troubleshooting.md",
       "update_date": "2025-07-08",
       "description": "Runbook to troubleshoot upgrade issues in Azure Kubernetes Service clusters",
       "link": "upgrade/upgrade_troubleshooting_instructions.md"

holmes/plugins/sources/github/__init__.py

@@ -1,9 +1,11 @@
 import logging
 from typing import List
+
+import requests  # type: ignore
+
+from holmes.core.issue import Issue
 from holmes.core.tool_calling_llm import LLMResult
 from holmes.plugins.interfaces import SourcePlugin
-from holmes.core.issue import Issue
-import requests  # type: ignore
 
 
 class GitHubSource(SourcePlugin):

holmes/plugins/sources/prometheus/models.py

@@ -2,6 +2,7 @@ import html
 from datetime import datetime, timedelta
 from typing import Dict, List, Optional, Union
 from urllib.parse import parse_qs, unquote, urlparse
+
 from pydantic import BaseModel, computed_field
 
 

holmes/plugins/toolsets/__init__.py

@@ -7,14 +7,19 @@ import yaml  # type: ignore
 from pydantic import ValidationError
 
 import holmes.utils.env as env_utils
-from holmes.common.env_vars import USE_LEGACY_KUBERNETES_LOGS
+from holmes.common.env_vars import (
+    DISABLE_PROMETHEUS_TOOLSET,
+    USE_LEGACY_KUBERNETES_LOGS,
+)
 from holmes.core.supabase_dal import SupabaseDal
 from holmes.core.tools import Toolset, ToolsetType, ToolsetYamlFromConfig, YAMLToolset
 from holmes.plugins.toolsets.atlas_mongodb.mongodb_atlas import MongoDBAtlasToolset
 from holmes.plugins.toolsets.azure_sql.azure_sql_toolset import AzureSQLToolset
 from holmes.plugins.toolsets.bash.bash_toolset import BashExecutorToolset
-from holmes.plugins.toolsets.coralogix.toolset_coralogix_logs import (
-    CoralogixLogsToolset,
+from holmes.plugins.toolsets.connectivity_check import ConnectivityCheckToolset
+from holmes.plugins.toolsets.coralogix.toolset_coralogix import CoralogixToolset
+from holmes.plugins.toolsets.datadog.toolset_datadog_general import (
+    DatadogGeneralToolset,
 )
 from holmes.plugins.toolsets.datadog.toolset_datadog_logs import DatadogLogsToolset
 from holmes.plugins.toolsets.datadog.toolset_datadog_metrics import (
@@ -23,32 +28,31 @@ from holmes.plugins.toolsets.datadog.toolset_datadog_metrics import (
 from holmes.plugins.toolsets.datadog.toolset_datadog_traces import (
     DatadogTracesToolset,
 )
-from holmes.plugins.toolsets.datadog.toolset_datadog_rds import (
-    DatadogRDSToolset,
+from holmes.plugins.toolsets.elasticsearch.elasticsearch import (
+    ElasticsearchClusterToolset,
+    ElasticsearchDataToolset,
 )
-from holmes.plugins.toolsets.datadog.toolset_datadog_general import (
-    DatadogGeneralToolset,
+from holmes.plugins.toolsets.elasticsearch.opensearch_query_assist import (
+    OpenSearchQueryAssistToolset,
 )
 from holmes.plugins.toolsets.git import GitToolset
+from holmes.plugins.toolsets.grafana.loki.toolset_grafana_loki import GrafanaLokiToolset
 from holmes.plugins.toolsets.grafana.toolset_grafana import GrafanaToolset
-from holmes.plugins.toolsets.grafana.toolset_grafana_loki import GrafanaLokiToolset
 from holmes.plugins.toolsets.grafana.toolset_grafana_tempo import GrafanaTempoToolset
 from holmes.plugins.toolsets.internet.internet import InternetToolset
 from holmes.plugins.toolsets.internet.notion import NotionToolset
+from holmes.plugins.toolsets.investigator.core_investigation import (
+    CoreInvestigationToolset,
+)
 from holmes.plugins.toolsets.kafka import KafkaToolset
 from holmes.plugins.toolsets.kubernetes_logs import KubernetesLogsToolset
 from holmes.plugins.toolsets.mcp.toolset_mcp import RemoteMCPToolset
-from holmes.plugins.toolsets.newrelic import NewRelicToolset
-from holmes.plugins.toolsets.opensearch.opensearch import OpenSearchToolset
-from holmes.plugins.toolsets.opensearch.opensearch_logs import OpenSearchLogsToolset
-from holmes.plugins.toolsets.opensearch.opensearch_traces import OpenSearchTracesToolset
-from holmes.plugins.toolsets.prometheus.prometheus import PrometheusToolset
+from holmes.plugins.toolsets.newrelic.newrelic import NewRelicToolset
 from holmes.plugins.toolsets.rabbitmq.toolset_rabbitmq import RabbitMQToolset
 from holmes.plugins.toolsets.robusta.robusta import RobustaToolset
 from holmes.plugins.toolsets.runbook.runbook_fetcher import RunbookToolset
-from holmes.plugins.toolsets.servicenow.servicenow import ServiceNowToolset
-from holmes.plugins.toolsets.investigator.core_investigation import (
-    CoreInvestigationToolset,
+from holmes.plugins.toolsets.servicenow_tables.servicenow_tables import (
+    ServiceNowTablesToolset,
 )
 
 THIS_DIR = os.path.abspath(os.path.dirname(__file__))
@@ -71,13 +75,16 @@ def load_toolsets_from_file(
     return toolsets
 
 
-def load_python_toolsets(dal: Optional[SupabaseDal]) -> List[Toolset]:
+def load_python_toolsets(
+    dal: Optional[SupabaseDal],
+    additional_search_paths: Optional[List[str]] = None,
+) -> List[Toolset]:
     logging.debug("loading python toolsets")
     toolsets: list[Toolset] = [
         CoreInvestigationToolset(),  # Load first for higher priority
         InternetToolset(),
+        ConnectivityCheckToolset(),
         RobustaToolset(dal),
-        OpenSearchToolset(),
         GrafanaLokiToolset(),
         GrafanaTempoToolset(),
         NewRelicToolset(),
@@ -88,26 +95,34 @@ def load_python_toolsets(dal: Optional[SupabaseDal]) -> List[Toolset]:
         DatadogGeneralToolset(),
         DatadogMetricsToolset(),
         DatadogTracesToolset(),
-        DatadogRDSToolset(),
-        PrometheusToolset(),
-        OpenSearchLogsToolset(),
-        OpenSearchTracesToolset(),
-        CoralogixLogsToolset(),
+        OpenSearchQueryAssistToolset(),
+        CoralogixToolset(),
         RabbitMQToolset(),
         GitToolset(),
         BashExecutorToolset(),
         MongoDBAtlasToolset(),
-        RunbookToolset(),
+        RunbookToolset(dal=dal, additional_search_paths=additional_search_paths),
         AzureSQLToolset(),
-        ServiceNowToolset(),
+        ServiceNowTablesToolset(),
+        ElasticsearchDataToolset(),
+        ElasticsearchClusterToolset(),
     ]
+
+    if not DISABLE_PROMETHEUS_TOOLSET:
+        from holmes.plugins.toolsets.prometheus.prometheus import PrometheusToolset
+
+        toolsets.append(PrometheusToolset())
+
     if not USE_LEGACY_KUBERNETES_LOGS:
         toolsets.append(KubernetesLogsToolset())
 
     return toolsets
 
 
-def load_builtin_toolsets(dal: Optional[SupabaseDal] = None) -> List[Toolset]:
+def load_builtin_toolsets(
+    dal: Optional[SupabaseDal] = None,
+    additional_search_paths: Optional[List[str]] = None,
+) -> List[Toolset]:
     all_toolsets: List[Toolset] = []
     logging.debug(f"loading toolsets from {THIS_DIR}")
 
@@ -123,7 +138,9 @@ def load_builtin_toolsets(dal: Optional[SupabaseDal] = None) -> List[Toolset]:
         toolsets_from_file = load_toolsets_from_file(path, strict_check=True)
         all_toolsets.extend(toolsets_from_file)
 
-    all_toolsets.extend(load_python_toolsets(dal=dal))  # type: ignore
+    all_toolsets.extend(
+        load_python_toolsets(dal=dal, additional_search_paths=additional_search_paths)
+    )  # type: ignore
 
     # disable built-in toolsets by default, and the user can enable them explicitly in config.
     for toolset in all_toolsets:

holmes/plugins/toolsets/aks-node-health.yaml

@@ -7,17 +7,49 @@ toolsets:
       - command: "az account show"
       - command: "az aks --help"
       - command: "kubectl version --client"
+
+    # Note: Tools in this toolset use transformers with llm_summarize
+    # to automatically summarize large outputs from Azure CLI and kubectl commands
+    # when a fast model is configured, focusing on health issues and troubleshooting.
     tools:
       - name: "check_node_status"
         description: "Checks the status of all nodes in the AKS cluster."
         user_description: "get the status of all nodes in the AKS cluster"
         command: |
           kubectl get nodes
+        transformers:
+          - name: llm_summarize
+            config:
+              input_threshold: 800
+              prompt: |
+                Summarize this node status output focusing on:
+                - Any nodes that are NotReady or in error states
+                - Node health patterns and issues requiring attention
+                - Group healthy nodes together with aggregate counts
+                - Highlight nodes with concerning conditions or ages
+                - When possible, mention exact node names for follow-up investigation
+                - Be concise: aim for ≤ 50% of the original length; avoid repeating defaults/healthy/unchanged details
+                - Prefer aggregates and counts; list only outliers and actionable items
+                - Keep grep-friendly: include exact field names/values that matter
       - name: "describe_node"
         description: "Describes a specific node in the AKS cluster to inspect its conditions."
         user_description: "describe node {{ NODE_NAME }} in the AKS cluster"
         command: |
           kubectl describe node {{ NODE_NAME }}
+        transformers:
+          - name: llm_summarize
+            config:
+              input_threshold: 1200
+              prompt: |
+                Summarize this node description focusing on:
+                - Node conditions and health status (Ready, MemoryPressure, DiskPressure, etc.)
+                - Resource capacity vs allocatable vs current usage
+                - Any taints, labels, or annotations indicating issues
+                - Recent events that show problems or state changes
+                - System information relevant to troubleshooting
+                - When possible, highlight specific condition reasons for investigation
+                - Strive for ≤ 50% of the original size; keep results compact and grep-friendly (one line per aggregate)
+                - Prioritize aggregates and actionable outliers over comprehensive details
       - name: "get_node_events"
         description: "Fetches recent events for a specific node to surface warnings and errors."
         user_description: "get events for node {{ NODE_NAME }}"
@@ -33,6 +65,20 @@ toolsets:
         user_description: "review Azure Activity Log for resource group {{ RESOURCE_GROUP_NAME }}"
         command: |
           az monitor activity-log list --resource-group {{ RESOURCE_GROUP_NAME }}
+        transformers:
+          - name: llm_summarize
+            config:
+              input_threshold: 1500
+              prompt: |
+                Summarize this Azure Activity Log focusing on:
+                - Recent administrative actions or configuration changes
+                - Any failed operations or errors that could impact node health
+                - Resource scaling, updates, or maintenance activities
+                - Network security group, load balancer, or VM-related changes
+                - Group similar activities and highlight time patterns
+                - When possible, mention specific operation names and correlation IDs
+                - Be concise and avoid expansion: target ≤ 50% of input size; prefer counts + outliers over full listings
+                - Include grep-ready keys/values; avoid repeating entire objects or unchanged defaults
       - name: "check_top_resource_consuming_pods"
         description: "Checks for the top resource-consuming pods on a specific node."
         user_description: "get the top resource-consuming pods on node {{ NODE_NAME }}"