holmesgpt 0.16.2a0__py3-none-any.whl → 0.18.4__py3-none-any.whl

holmes/plugins/toolsets/prometheus/prometheus_instructions.jinja2

@@ -1,6 +1,14 @@
 
 # Prometheus/PromQL queries
 
+{%- if config and config.prometheus_url and "coralogix" in config.prometheus_url %}
+You are using Coralogix Prometheus.
+* Metrics/labels may differ; discover names with `get_metric_names` first.
+* For high-cardinality, wrap with `topk(5, <query>)`.
+* Always include explicit time ranges for range queries.
+* Example: `container_cpu_utilization{namespace="test-173"}` can fail if the label is named differently (e.g., `k8s_namespace_name`) or the metric is named differently. Do not assume names—only use labels you have seen returned or been told exist.
+{%- endif %}
+
 ## Efficient Metric Discovery (when needed)
 * When you need to discover metrics, use `get_metric_names` with filters - it's the fastest method
 * Combine multiple patterns with regex OR (|) to reduce API calls:
@@ -26,7 +34,7 @@
 * Use prometheus to execute promql queries with the tools `execute_prometheus_instant_query` and `execute_prometheus_range_query`
 * To create queries, use 'start_timestamp' and 'end_timestamp' as graphs start and end times
 * ALWAYS embed the execution results into your answer
-* You only need to embed the partial result in your response. Include the "tool_name" and "random_key". For example: << {"type": "promql", "tool_name": "execute_prometheus_range_query", "random_key": "92jf2hf"} >>
+* You only need to embed the partial result in your response. Include the "tool_name" and "tool_call_id". For example: << {"type": "promql", "tool_name": "execute_prometheus_range_query", "tool_call_id": "92jf2hf"} >>
 * Use these tools to generate charts that users can see. Here are standard metrics but you can use different ones:
 ** For memory consumption: `container_memory_working_set_bytes`
 ** For CPU usage: `container_cpu_usage_seconds_total`
@@ -67,9 +75,9 @@
 * When embedding multiple graphs, always add line spacing between them
     For example:
 
-    <<{"type": "promql", "tool_name": "execute_prometheus_range_query", "random_key": "lBaA"}>>
+    <<{"type": "promql", "tool_name": "execute_prometheus_range_query", "tool_call_id": "lBaA"}>>
 
-    <<{"type": "promql", "tool_name": "execute_prometheus_range_query", "random_key": "IKtq"}>>
+    <<{"type": "promql", "tool_name": "execute_prometheus_range_query", "tool_call_id": "IKtq"}>>
 
 {%- if config and config.additional_labels and config.additional_labels.keys()|list|length > 0 %}
 * ALWAYS add the following additional labels to ALL PromQL queries:

holmes/plugins/toolsets/rabbitmq/api.py

@@ -1,11 +1,11 @@
-from enum import Enum
 import logging
+from enum import Enum
 from typing import Any, Dict, List, Optional, Set
 from urllib.parse import urljoin, urlparse
 
 import backoff
-from pydantic import BaseModel
 import requests  # type: ignore
+from pydantic import BaseModel, ConfigDict, model_validator
 from requests.auth import HTTPBasicAuth  # type: ignore
 
 # --- Enums and Pydantic Models (Mostly Unchanged) ---
@@ -17,12 +17,31 @@ class ClusterConnectionStatus(str, Enum):
 
 
 class RabbitMQClusterConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
     id: str = "rabbitmq"  # must be unique
     management_url: str  # e.g., http://rabbitmq-service:15672
     username: Optional[str] = None
     password: Optional[str] = None
     request_timeout_seconds: int = 30
-    verify_certs: bool = True
+    verify_ssl: bool = True
+
+    @model_validator(mode="after")
+    def handle_deprecated_fields(self):
+        extra = self.model_extra or {}
+        deprecated = []
+
+        # Map old name to new name
+        if "verify_certs" in extra:
+            self.verify_ssl = extra["verify_certs"]
+            deprecated.append("verify_certs -> verify_ssl")
+
+        if deprecated:
+            logging.warning(
+                f"RabbitMQ config uses deprecated field names: {', '.join(deprecated)}. "
+                "Please update your configuration."
+            )
+        return self
 
     # For internal use
     connection_status: Optional[ClusterConnectionStatus] = None
@@ -111,7 +130,7 @@ def make_request(
             params=params,
             json=data,
             timeout=config.request_timeout_seconds,
-            verify=config.verify_certs,
+            verify=config.verify_ssl,
         )
         response.raise_for_status()
         return response.json()

holmes/plugins/toolsets/rabbitmq/toolset_rabbitmq.py

@@ -1,21 +1,21 @@
-import os
 import logging
+import os
 from typing import Any, List, Optional, Tuple
+from urllib.parse import urljoin
 
 from pydantic import BaseModel
+from requests import RequestException  # type: ignore
+
 from holmes.core.tools import (
     CallablePrerequisite,
     StructuredToolResult,
+    StructuredToolResultStatus,
     Tool,
     ToolInvokeContext,
     ToolParameter,
-    StructuredToolResultStatus,
     Toolset,
     ToolsetTag,
 )
-from requests import RequestException  # type: ignore
-from urllib.parse import urljoin
-
 from holmes.plugins.toolsets.rabbitmq.api import (
     ClusterConnectionStatus,
     RabbitMQClusterConfig,

holmes/plugins/toolsets/robusta/robusta.py

@@ -1,19 +1,19 @@
-import os
-
 import logging
+import os
+from typing import Any, Dict, List, Optional
 
-from typing import Optional, Dict, Any, List
 from holmes.common.env_vars import load_bool
-from holmes.core.supabase_dal import SupabaseDal, FindingType
+from holmes.core.supabase_dal import FindingType, SupabaseDal
 from holmes.core.tools import (
     StaticPrerequisite,
+    StructuredToolResult,
+    StructuredToolResultStatus,
     Tool,
     ToolInvokeContext,
     ToolParameter,
     Toolset,
     ToolsetTag,
 )
-from holmes.core.tools import StructuredToolResult, StructuredToolResultStatus
 
 PULL_EXTERNAL_FINDINGS = load_bool("PULL_EXTERNAL_FINDINGS", False)
 

holmes/plugins/toolsets/runbook/runbook_fetcher.py

@@ -1,22 +1,23 @@
 import logging
 import os
 import textwrap
-from typing import Any, Dict, List, Optional
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union, cast
+
 from holmes.core.supabase_dal import SupabaseDal
 from holmes.core.tools import (
     StructuredToolResult,
+    StructuredToolResultStatus,
     Tool,
     ToolInvokeContext,
     ToolParameter,
-    StructuredToolResultStatus,
     Toolset,
     ToolsetTag,
 )
-
 from holmes.plugins.runbooks import (
+    DEFAULT_RUNBOOK_SEARCH_PATH,
     get_runbook_by_path,
     load_runbook_catalog,
-    DEFAULT_RUNBOOK_SEARCH_PATH,
 )
 from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
@@ -32,8 +33,11 @@ class RunbookFetcher(Tool):
         toolset: "RunbookToolset",
         additional_search_paths: Optional[List[str]] = None,
         dal: Optional[SupabaseDal] = None,
+        custom_catalog_paths: Optional[List[Union[str, Path]]] = None,
     ):
-        catalog = load_runbook_catalog(dal=dal)
+        catalog = load_runbook_catalog(
+            dal=dal, custom_catalog_paths=custom_catalog_paths
+        )
         available_runbooks = []
         if catalog:
             available_runbooks = catalog.list_available_runbooks()
@@ -232,12 +236,26 @@ class RunbookToolset(Toolset):
         if additional_search_paths:
             config["additional_search_paths"] = additional_search_paths
 
+        # Compute custom catalog paths from additional search paths
+        custom_catalog_paths = None
+        if additional_search_paths:
+            custom_catalog_paths = [
+                os.path.join(search_path, "catalog.json")
+                for search_path in additional_search_paths
+                if os.path.isfile(os.path.join(search_path, "catalog.json"))
+            ]
+
         super().__init__(
             name="runbook",
             description="Fetch runbooks",
             icon_url="https://platform.robusta.dev/demos/runbook.svg",
             tools=[
-                RunbookFetcher(self, additional_search_paths, dal),
+                RunbookFetcher(
+                    self,
+                    additional_search_paths,
+                    dal,
+                    cast(Optional[List[Union[str, Path]]], custom_catalog_paths),
+                ),
             ],
             docs_url="https://holmesgpt.dev/data-sources/",
             tags=[
@@ -245,6 +263,7 @@ class RunbookToolset(Toolset):
             ],
             is_default=True,
             config=config,
+            enabled=True,
         )
 
     def get_example_config(self) -> Dict[str, Any]:

holmes/plugins/toolsets/servicenow_tables/servicenow_tables.py

@@ -1,6 +1,6 @@
 import os
 from abc import ABC
-from typing import Dict, Optional, cast, Type, ClassVar, Tuple, Any
+from typing import Any, ClassVar, Dict, Optional, Tuple, Type, cast
 from urllib.parse import urljoin
 
 import requests  # type: ignore

holmes/plugins/toolsets/utils.py

@@ -1,7 +1,7 @@
 import datetime
 import math
-import time
 import re
+import time
 from typing import Dict, Optional, Tuple, Union
 
 from dateutil import parser

holmes/utils/config_utils.py

@@ -2,7 +2,7 @@
 Configuration utility functions for HolmesGPT.
 """
 
-from typing import List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Optional
 
 if TYPE_CHECKING:
     from holmes.core.transformers import Transformer

holmes/utils/connection_utils.py

@@ -0,0 +1,31 @@
+import logging
+import socket
+
+from holmes.common.env_vars import KEEPALIVE_CNT, KEEPALIVE_IDLE, KEEPALIVE_INTVL
+
+
+def patch_socket_create_connection(
+    idle: int = KEEPALIVE_IDLE,
+    intvl: int = KEEPALIVE_INTVL,
+    cnt: int = KEEPALIVE_CNT,
+) -> None:
+    orig = socket.create_connection
+
+    def new_create_connection(address, timeout=None, source_address=None, **kwargs):
+        logging.debug(
+            f"Creating patched connection to {address} with timeout {timeout} and source address {source_address}"
+        )
+        s = orig(address, timeout=timeout, source_address=source_address, **kwargs)
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+
+        # Linux-only tuning (these attrs won't exist on macOS/Windows)
+        if hasattr(socket, "TCP_KEEPIDLE"):
+            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, int(idle))
+        if hasattr(socket, "TCP_KEEPINTVL"):
+            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, int(intvl))
+        if hasattr(socket, "TCP_KEEPCNT"):
+            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, int(cnt))
+        return s
+
+    logging.info("Patching socket.create_connection to force keepalive")
+    socket.create_connection = new_create_connection

holmes/utils/console/result.py

@@ -17,6 +17,7 @@ def handle_result(
     issue: Issue,
     show_tool_output: bool,
     add_separator: bool,
+    log_costs: bool = False,
 ):
     if destination == DestinationType.CLI:
         if show_tool_output and result.tool_calls:
@@ -30,6 +31,15 @@ def handle_result(
 
         console.print(f"[bold {AI_COLOR}]AI:[/bold {AI_COLOR}]", end=" ")
         console.print(Markdown(result.result))  # type: ignore
+
+        if log_costs and result.total_cost > 0:
+            console.print(
+                f"\n[bold yellow]💰 Total Cost:[/bold yellow] ${result.total_cost:.6f}"
+            )
+            console.print(
+                f"[dim]Tokens: {result.prompt_tokens:,} prompt + {result.completion_tokens:,} completion = {result.total_tokens:,} total[/dim]"
+            )
+
         if add_separator:
             console.print(Rule())
 

holmes/utils/file_utils.py

@@ -1,6 +1,7 @@
 import json
-import os
 import logging
+import os
+
 import yaml  # type: ignore
 
 

holmes/utils/global_instructions.py

@@ -1,6 +1,7 @@
-from typing import Optional, List, TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict, List, Optional
+
 from pydantic import BaseModel
-from holmes.plugins.prompts import load_and_render_prompt
+
 from holmes.plugins.runbooks import RunbookCatalog
 
 if TYPE_CHECKING:
@@ -34,24 +35,14 @@ def _format_resource_instructions(
     return items
 
 
-def add_runbooks_to_user_prompt(
-    user_prompt: str,
+def generate_runbooks_args(
     runbook_catalog: Optional[RunbookCatalog],
     global_instructions: Optional[Instructions] = None,
     issue_instructions: Optional[List[str]] = None,
     resource_instructions: Optional["ResourceInstructions"] = None,  # type: ignore
-) -> str:
-    if (
-        not runbook_catalog
-        and not issue_instructions
-        and not resource_instructions
-        and not global_instructions
-    ):
-        return user_prompt
-
+) -> Dict[str, str]:
     catalog_str = runbook_catalog.to_prompt_string() if runbook_catalog else ""
 
-    # Combine and format all instructions
     combined_instructions = []
     if issue_instructions:
         combined_instructions.extend(issue_instructions)
@@ -71,15 +62,8 @@ def add_runbooks_to_user_prompt(
         else ""
     )
 
-    rendered = load_and_render_prompt(
-        "builtin://_runbook_instructions.jinja2",
-        context={
-            "runbook_catalog": catalog_str,
-            "custom_instructions": issue_block,
-            "global_instructions": global_block,
-        },
-    )
-
-    if user_prompt and not user_prompt.endswith("\n"):
-        user_prompt += "\n"
-    return f"{user_prompt}\n{rendered}"
+    return {
+        "runbook_catalog": catalog_str,
+        "custom_instructions": issue_block,
+        "global_instructions": global_block,
+    }

holmes/utils/holmes_status.py

@@ -1,9 +1,10 @@
 import json
-from holmes.core.supabase_dal import SupabaseDal
-from holmes.config import Config
-from holmes import get_version  # type: ignore
 import logging
 
+from holmes import get_version  # type: ignore
+from holmes.config import Config
+from holmes.core.supabase_dal import SupabaseDal
+
 
 def update_holmes_status_in_db(dal: SupabaseDal, config: Config):
     logging.info("Updating status of holmes")

holmes/utils/log.py

@@ -0,0 +1,15 @@
+"""Logging utilities for Holmes."""
+
+import logging
+from typing import Any
+
+
+class EndpointFilter(logging.Filter):
+    """Filter out log records for specific endpoint paths."""
+
+    def __init__(self, path: str, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self._path = path
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return record.getMessage().find(self._path) == -1

holmes/utils/markdown_utils.py

@@ -1,9 +1,8 @@
 # based on https://github.com/kostyachum/python-markdown-plain-text/blob/main/markdown_plain_text/extention.py
 # MIT licensed
-from markdown import Extension, Markdown  # type: ignore
+from xml.etree.ElementTree import Comment, ElementTree, ProcessingInstruction
 
-from xml.etree.ElementTree import ProcessingInstruction
-from xml.etree.ElementTree import Comment, ElementTree
+from markdown import Extension, Markdown  # type: ignore
 
 
 def _serialize_plain_text(write, elem):

holmes/utils/memory_limit.py

@@ -0,0 +1,58 @@
+"""
+Memory limit utilities for tool subprocess execution.
+"""
+
+import logging
+
+from holmes.common.env_vars import TOOL_MEMORY_LIMIT_MB
+
+logger = logging.getLogger(__name__)
+
+
+def get_ulimit_prefix() -> str:
+    """
+    Get the ulimit command prefix for memory protection.
+
+    Returns a shell command prefix that sets virtual memory limit.
+    The '|| true' ensures we continue even if ulimit is not supported.
+    """
+    memory_limit_kb = TOOL_MEMORY_LIMIT_MB * 1024
+    return f"ulimit -v {memory_limit_kb} || true; "
+
+
+def check_oom_and_append_hint(output: str, return_code: int) -> str:
+    """
+    Check if a command was OOM killed and append a helpful hint.
+
+    Args:
+        output: The command output
+        return_code: The command's return code
+
+    Returns:
+        Output with OOM hint appended if OOM was detected
+    """
+    # Common OOM indicators:
+    # - Return code 137 (128 + 9 = SIGKILL, commonly OOM)
+    # - Return code -9 (SIGKILL on some systems)
+    # - "Killed" in output (Linux OOM killer message)
+    # - "MemoryError" (Python)
+    # - "Cannot allocate memory" (various tools)
+    is_oom = (
+        return_code in (137, -9)
+        or "Killed" in output
+        or "MemoryError" in output
+        or "Cannot allocate memory" in output
+        or "bad_alloc" in output
+    )
+
+    if is_oom:
+        hint = (
+            f"\n\n[OOM] Command was killed due to memory limits (current limit: {TOOL_MEMORY_LIMIT_MB} MB). "
+            f"Try querying the data differently to reduce memory usage - add filters to narrow the results, "
+            f"use smaller time ranges, or try alternative tools that may be more memory-efficient. "
+            f"If you cannot succeed with a modified query, you may recommend the user increase the limit "
+            f"by setting the TOOL_MEMORY_LIMIT_MB environment variable (Tool memory limit, MB)."
+        )
+        return output + hint
+
+    return output

holmes/utils/sentry_helper.py

@@ -1,4 +1,7 @@
+from typing import Optional
+
 import sentry_sdk
+
 from holmes.core.models import ToolCallResult, TruncationMetadata
 
 
@@ -39,3 +42,23 @@ def capture_structured_output_incorrect_tool_call():
         "Structured output incorrect tool call",
         level="warning",
     )
+
+
+def capture_sections_none(content: Optional[str]):
+    # Limit display length to avoid sending huge payloads to Sentry
+    _MAX_DISPLAY_LENGTH = 1500
+    display_content = ""
+    if content:
+        if len(content) > _MAX_DISPLAY_LENGTH * 2:
+            # Show first and last portions of content
+            display_content = f"{content[:_MAX_DISPLAY_LENGTH]}...\n\n...{content[-_MAX_DISPLAY_LENGTH:]}"
+        else:
+            display_content = content
+
+    with sentry_sdk.push_scope() as scope:
+        scope.set_extra("content", display_content)
+        scope.set_extra("content_length", len(content) if content else 0)
+        sentry_sdk.capture_message(
+            "Holmes answer couldn't be parsed into sections",
+            level="warning",
+        )

holmes/utils/stream.py

@@ -1,15 +1,17 @@
 import json
+import logging
 from enum import Enum
-from typing import Generator, Optional, List, Union
-import litellm
-from pydantic import BaseModel, Field
-from holmes.core.investigation_structured_output import process_response_into_sections
 from functools import partial
-import logging
+from typing import Generator, List, Optional, Union
+
+import litellm
 from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
 from litellm.types.utils import ModelResponse, TextCompletionResponse
+from pydantic import BaseModel, Field
 
+from holmes.core.investigation_structured_output import process_response_into_sections
 from holmes.core.llm import TokenCountMetadata, get_llm_usage
+from holmes.utils import sentry_helper
 
 
 class StreamEvents(str, Enum):
@@ -63,6 +65,11 @@ def stream_investigate_formatter(
                     message.data.get("content")
                 )
 
+                if sections is None:
+                    sentry_helper.capture_sections_none(
+                        content=message.data.get("content"),
+                    )
+
                 yield create_sse_message(
                     StreamEvents.ANSWER_END.value,
                     {

holmes/utils/tags.py

@@ -1,9 +1,10 @@
+import json
 import logging
-from typing import Optional
-from typing_extensions import Dict, List
 import re
-import json
 from copy import deepcopy
+from typing import Optional
+
+from typing_extensions import Dict, List
 
 
 def stringify_tag(tag: Dict[str, str]) -> Optional[str]:

holmes/version.py

@@ -8,10 +8,12 @@ import os
 import subprocess
 import sys
 import threading
-from typing import Optional, NamedTuple
 from functools import cache
+from typing import NamedTuple, Optional
+
 import requests  # type: ignore
 from pydantic import BaseModel, ConfigDict
+
 from holmes.common.env_vars import ROBUSTA_API_ENDPOINT
 
 # For relative imports to work in Python 3.6 - see https://stackoverflow.com/a/49375740

{holmesgpt-0.16.2a0.dist-info → holmesgpt-0.18.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holmesgpt
-Version: 0.16.2a0
+Version: 0.18.4
 Summary: 
 Author: Natan Yellin
 Author-email: natan@robusta.dev
@@ -28,6 +28,7 @@ Requires-Dist: google-cloud-aiplatform (>=1.38)
 Requires-Dist: httpx[socks] (<0.28)
 Requires-Dist: humanize (>=4.9.0,<5.0.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: jq (>=1.10.0,<2.0.0)
 Requires-Dist: kubernetes (>=32.0.1,<33.0.0)
 Requires-Dist: litellm (==1.77.1)
 Requires-Dist: markdown (>=3.6,<4.0)
@@ -58,6 +59,9 @@ Description-Content-Type: text/markdown
 
 HolmesGPT is an AI agent for investigating problems in your cloud, finding the root cause, and suggesting remediations. It has dozens of built-in integrations for cloud providers, observability tools, and on-call systems.
 
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/11586/badge)](https://www.bestpractices.dev/projects/11586)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/HolmesGPT/holmesgpt/badge)](https://scorecard.dev/viewer/?uri=github.com/HolmesGPT/holmesgpt)
+
 >🎉 **HolmesGPT is now a CNCF Sandbox Project!**  
 HolmesGPT was originally created by [Robusta.Dev](https://home.robusta.dev/) and is a CNCF sandbox project.
 
@@ -70,7 +74,7 @@ Find more about HolmesGPT's maintainers and adopters [here](./ADOPTERS.md).
     <a href="#installation"><strong>Installation</strong></a> |
     <a href="#supported-llm-providers"><strong>LLM Providers</strong></a> |
     <a href="https://www.youtube.com/watch?v=TfQfx65LsDQ"><strong>YouTube Demo</strong></a> |
-    <a href="https://deepwiki.com/robusta-dev/holmesgpt"><img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki"></a>
+    <a href="https://deepwiki.com/HolmesGPT/holmesgpt"><img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki"></a>
   </p>
 </div>
 
@@ -248,27 +252,25 @@ Because HolmesGPT relies on LLMs, it relies on [a suite of pytest based evaluati
 
 
 ## License
-Distributed under the Apache 2.0 License. See [LICENSE](https://github.com/robusta-dev/holmesgpt/blob/master/LICENSE) for more information.
+Distributed under the Apache 2.0 License. See [LICENSE](https://github.com/HolmesGPT/holmesgpt/blob/master/LICENSE) for more information.
 <!-- Change License -->
 
 ## Community
 
 Join our community to discuss the HolmesGPT roadmap and share feedback:
 
-📹 **First Community Meetup Recording:** [Watch on YouTube](https://youtu.be/slQRc6nlFQU)
-- **Topics:** Roadmap discussion, community feedback, and Q&A
-- **Resources:** [📝 Meeting Notes](https://docs.google.com/document/d/1sIHCcTivyzrF5XNvos7ZT_UcxEOqgwfawsTbb9wMJe4/edit?tab=t.0) | [📋 Community Page](https://holmesgpt.dev/community/)
+- [Community Meetups](https://docs.google.com/document/d/1q3L2iUd8tNu-NmZ6QIVOJcCLHrile9CC5QguOGTn_tg/edit?tab=t.0#heading=h.ihdnrt5bstrv)
 
 ## Support
 
-If you have any questions, feel free to message us on [robustacommunity.slack.com](https://bit.ly/robusta-slack)
+If you have any questions, feel free to message us on [HolmesGPT Slack Channel](https://cloud-native.slack.com/archives/C0A1SPQM5PZ)
 
 ## How to Contribute
 
 Please read our [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines and instructions.
 
-For help, contact us on [Slack](https://bit.ly/robusta-slack) or ask [DeepWiki AI](https://deepwiki.com/robusta-dev/holmesgpt) your questions.
+For help, contact us on [Slack](https://cloud-native.slack.com/archives/C0A1SPQM5PZ) or ask [DeepWiki AI](https://deepwiki.com/HolmesGPT/holmesgpt) your questions.
 
-Please make sure to follow the CNCF code of conduct - [details here](https://github.com/robusta-dev/holmesgpt/blob/master/CODE_OF_CONDUCT.md).
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/robusta-dev/holmesgpt)
+Please make sure to follow the CNCF code of conduct - [details here](https://github.com/HolmesGPT/holmesgpt/blob/master/CODE_OF_CONDUCT.md).
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/HolmesGPT/holmesgpt)