wip

Author: onmete

examples/olsconfig.yaml

@@ -60,7 +60,6 @@ ols_config:
 #    product_docs_index_path: "./vector_db/ocp_product_docs/4.15"
 #    product_docs_index_id: ocp-product-docs-4_15
 #    embeddings_model_path: "./embeddings_model"
-  introspection_enabled: true  # Default is false, OLS tool calling
   conversation_cache:
     type: memory
     memory:
@@ -117,4 +116,4 @@ dev_config:
   # uvicorn_port_number: 8081
   # llm_params:
   #   temperature_override: 0
-  # k8s_auth_token: optional_token_when_no_available_kube_config
+  # k8s_auth_token: optional_token_when_no_available_kube_config

ols/app/models/config.py

@@ -913,7 +913,6 @@ class OLSConfig(BaseModel):
     """OLS configuration."""
 
     conversation_cache: Optional[ConversationCacheConfig] = None
-    introspection_enabled: Optional[bool] = False
     logging_config: Optional[LoggingConfig] = None
     reference_content: Optional[ReferenceContent] = None
     authentication_config: AuthenticationConfig = AuthenticationConfig()
@@ -944,7 +943,6 @@ def __init__(
         if data is None:
             return
 
-        self.introspection_enabled = data.get("introspection_enabled", False)
         self.conversation_cache = ConversationCacheConfig(
             data.get("conversation_cache", None)
         )
@@ -994,7 +992,6 @@ def __eq__(self, other: object) -> bool:
         if isinstance(other, OLSConfig):
             return (
                 self.conversation_cache == other.conversation_cache
-                and self.introspection_enabled == other.introspection_enabled
                 and self.logging_config == other.logging_config
                 and self.reference_content == other.reference_content
                 and self.default_provider == other.default_provider
@@ -1111,13 +1108,21 @@ def validate_token_is_set_when_needed(self) -> Self:
         return self
 
 
+class Tool(BaseModel):
+    """Tool definition."""
+
+    name: str
+    type: Literal["tool-set"]
+
+
 class Config(BaseModel):
     """Global service configuration."""
 
     llm_providers: LLMProviders = LLMProviders()
     ols_config: OLSConfig = OLSConfig()
     dev_config: DevConfig = DevConfig()
     user_data_collector_config: Optional[UserDataCollectorConfig] = None
+    tools: list[Tool] = []
 
     def __init__(
         self,
@@ -1148,7 +1153,9 @@ def __init__(
         self.user_data_collector_config = UserDataCollectorConfig(
             **data.get("user_data_collector_config", {})
         )
+        self.tools = [Tool(**tool) for tool in data.get("tools", [])]
 
+    # TODO: tyhle comparison jsou uplne zbytecne - smazat
     def __eq__(self, other: object) -> bool:
         """Compare two objects for equality."""
         if isinstance(other, Config):

ols/plugins/__init__.py

@@ -25,4 +25,4 @@ def import_modules_from_dir(dir_name: str) -> None:
 
 
 # import_modules_from_dir("providers")
-# import_modules_from_dir("tools")
+import_modules_from_dir("tools")

ols/src/tools/oc_cli.py renamed to ols/plugins/tools/openshift.py

@@ -17,6 +17,8 @@
 from langchain.tools import tool
 from langchain_core.tools import InjectedToolArg
 
+from ols.src.tools.tools import ToolSetProvider, register_tool_provider_as
+
 logger = logging.getLogger(__name__)
 
 
@@ -60,41 +62,12 @@ def run_oc(args: list[str]) -> subprocess.CompletedProcess:
         ["oc", *args],  # noqa: S607
         capture_output=True,
         text=True,
-        check=False,
+        check=True,
         shell=False,
     )
     return res
 
 
-def token_works_for_oc(token: str) -> bool:
-    """Check if the token can be used with `oc` CLI.
-
-    Args:
-        token: OpenShift user token.
-
-    Returns:
-        True if user token works, False otherwise.
-    """
-    r = run_oc(["version", f"--token={token}"])
-
-    if r.returncode == 0:
-        logger.info("Token is usable for oc CLI")
-        return True
-
-    logger.error(
-        "Unable to use the token for oc CLI; stdout: %s, stderr: %s",
-        r.stdout,
-        r.stderr,
-    )
-    return False
-
-
-def stdout_or_stderr(result: subprocess.CompletedProcess) -> str:
-    """Return stdout if return code is 0, otherwise return stderr."""
-    return result.stdout if result.returncode == 0 else result.stderr
-
-
-# NOTE: tools description comes from oc cli --help for each subcommand (shortened)
 @tool
 def oc_get(oc_get_args: list[str], token: Annotated[str, InjectedToolArg]) -> str:
     """Display one or many resources from OpenShift cluster.
@@ -130,7 +103,7 @@ def oc_get(oc_get_args: list[str], token: Annotated[str, InjectedToolArg]) -> st
         oc get rc,services
     """
     result = run_oc(["get", *sanitize_oc_args(oc_get_args), "--token", token])
-    return stdout_or_stderr(result)
+    return result.stdout
 
 
 @tool
@@ -165,7 +138,7 @@ def oc_describe(
         oc describe pods frontend
     """  # noqa: E501
     result = run_oc(["describe", *sanitize_oc_args(oc_describe_args), "--token", token])
-    return stdout_or_stderr(result)
+    return result.stdout
 
 
 @tool
@@ -193,7 +166,7 @@ def oc_logs(oc_logs_args: list[str], token: Annotated[str, InjectedToolArg]) ->
         oc logs -f pod/backend -c ruby-container
     """  # noqa: E501
     result = run_oc(["logs", *sanitize_oc_args(oc_logs_args), "--token", token])
-    return stdout_or_stderr(result)
+    return result.stdout
 
 
 @tool
@@ -219,7 +192,7 @@ def oc_status(oc_status_args: list[str], token: Annotated[str, InjectedToolArg])
         oc --suggest
     """
     result = run_oc(["status", *sanitize_oc_args(oc_status_args), "--token", token])
-    return stdout_or_stderr(result)
+    return result.stdout
 
 
 @tool
@@ -237,7 +210,7 @@ def show_pods(token: Annotated[str, InjectedToolArg]) -> str:
         kube-system  kube-apiserver-proxy-ip-10-0-130-91.ec2.internal  2m          13Mi
     """
     result = run_oc([*["adm", "top", "pods", "-A"], "--token", token])
-    return stdout_or_stderr(result)
+    return result.stdout
 
 
 @tool
@@ -270,4 +243,36 @@ def oc_adm_top(
     result = run_oc(
         ["adm", "top", *sanitize_oc_args(oc_adm_top_args), "--token", token]
     )
-    return stdout_or_stderr(result)
+    return result.stdout
+
+
+@register_tool_provider_as("openshift")
+class OCToolProvider(ToolSetProvider):
+    """Provider for OpenShift CLI tools."""
+
+    @property
+    def tools(self):
+        """Get all OC tools."""
+        return {
+            "oc_get": oc_get,
+            "oc_describe": oc_describe,
+            "oc_logs": oc_logs,
+            "oc_adm_top": oc_adm_top,
+            "oc_status": oc_status,
+            "show_pods": show_pods,
+        }
+
+    # TODO: needs rebase for #2391
+    def execute_tool(self, tool_name, tool_args, context) -> tuple[str, str]:
+        """Execute an OC tool with the given arguments and context."""
+        tool = self.tools[tool_name]
+        if not context.user_token:
+            return "Error: No user token provided", "error"
+
+        # add token to arguments
+        args_with_token = {**tool_args, "token": context.user_token}
+
+        try:
+            return tool.invoke(args_with_token), "success"
+        except Exception as e:
+            return f"Error: {e}", "error"

ols/src/query_helpers/docs_summarizer.py

@@ -4,9 +4,8 @@
 from typing import Any, AsyncGenerator, Optional
 
 from langchain.globals import set_debug
-from langchain_core.messages import AIMessage, BaseMessage
+from langchain_core.messages import AIMessage, BaseMessage, ToolMessage
 from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.tools.base import BaseTool
 from llama_index.core import VectorStoreIndex
 
 from ols import config
@@ -16,13 +15,34 @@
 from ols.customize import reranker
 from ols.src.prompts.prompt_generator import GeneratePrompt
 from ols.src.query_helpers.query_helper import QueryHelper
-from ols.src.tools.oc_cli import token_works_for_oc
-from ols.src.tools.tools import execute_oc_tool_calls, oc_tools
+from ols.src.tools.tools import ToolProvidersRegistry, ToolsContext
 from ols.utils.token_handler import TokenHandler
 
 logger = logging.getLogger(__name__)
 
 
+def execute_tools(tool_calls, tools_provider_map, tools_context):
+    """Execute tools based on the tool calls and context."""
+    tool_messages = []
+    for tool_call in tool_calls:
+        tool_name = tool_call.get("name", "").lower()
+        tool_args = tool_call.get("args", {})
+        tool_id = tool_call.get("id")
+
+        tool_provider = tools_provider_map.get(tool_name)
+        if tool_provider is None:
+            logger.error("Error: unknown tool '%s'", tool_name)
+            continue
+
+        tool_result, status = tool_provider.execute_tool(
+            tool_name, tool_args, tools_context
+        )
+        tool_messages.append(
+            ToolMessage(tool_result, status=status, tool_call_id=tool_id)
+        )
+    return tool_messages
+
+
 class DocsSummarizer(QueryHelper):
     """A class for summarizing documentation context."""
 
@@ -31,7 +51,11 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self._prepare_llm()
         self.verbose = config.ols_config.logging_config.app_log_level == logging.DEBUG
-        self._introspection_enabled = config.ols_config.introspection_enabled
+
+        self.tool_providers = [
+            ToolProvidersRegistry.tool_providers[tool_provider.name]
+            for tool_provider in config.config.tools
+        ]
 
         # disabled - leaks token to logs when set to True
         set_debug(False)
@@ -87,7 +111,7 @@ def _prepare_prompt(
             ["sample"],
             [AIMessage("sample")],
             self._system_prompt,
-            self._introspection_enabled,
+            True if self.tool_providers else False,
         ).generate_prompt(self.model)
         available_tokens = token_handler.calculate_and_check_available_tokens(
             temp_prompt.format(**temp_prompt_input),
@@ -120,7 +144,7 @@ def _prepare_prompt(
             rag_context,
             history,
             self._system_prompt,
-            self._introspection_enabled,
+            True if self.tool_providers else False,
         ).generate_prompt(self.model)
 
         # Tokens-check: We trigger the computation of the token count
@@ -161,19 +185,6 @@ def _invoke_llm(
             )
         return out, generic_token_counter.token_counter
 
-    def _get_available_tools(self, user_token: Optional[str]) -> dict[str, BaseTool]:
-        """Get available tools based on introspection and user token."""
-        if not self._introspection_enabled:
-            return {}
-
-        logger.info("Introspection enabled - using default tools selection")
-
-        if user_token and user_token.strip() and token_works_for_oc(user_token):
-            logger.info("Authenticated to 'oc' CLI; adding 'oc' tools")
-            return oc_tools
-
-        return {}
-
     def create_response(
         self,
         query: str,
@@ -189,22 +200,30 @@ def create_response(
         messages = final_prompt.model_copy()
         tool_calls = []
 
-        # TODO: for the specific tools type (oc) we need specific additional
-        # context (user_token) to get the tools, we need to think how to make
-        # it more generic to avoid low-level code changes with new tools type
-        tools_map = self._get_available_tools(user_token)
+        tools_context = ToolsContext(user_token=user_token)
+
+        # map to hold all tools for registering to llm
+        tools_map = {}
+
+        # map to tell what tool belongs to what tool provider
+        tools_provider_map = {}
+
+        for tool_provider in self.tool_providers:
+            tools = tool_provider.tools
+            tools_map.update(tools)
+            for tool in tools.keys():
+                # TODO: raise if key already exists
+                tools_provider_map[tool] = tool_provider
 
         # TODO: Tune system prompt
         # TODO: Handle context for each iteration
         # TODO: Handle tokens for tool response
         # TODO: Improvement for granite
         for i in range(MAX_ITERATIONS):
 
-            # Force llm to give final response when introspection is disabled
+            # Force llm to give final response when tools are not provided
             # or max iteration is reached
-            is_final_round = (not self._introspection_enabled) or (
-                i == MAX_ITERATIONS - 1
-            )
+            is_final_round = (not tools_map) or (i == MAX_ITERATIONS - 1)
             out, token_counter = self._invoke_llm(
                 messages, llm_input_values, tools_map, is_final_round
             )
@@ -228,8 +247,9 @@ def create_response(
             tool_calls.append(
                 [ToolCall.from_langchain_tool_call(t) for t in out.tool_calls]
             )
-            tool_calls_messages = execute_oc_tool_calls(
-                tools_map, out.tool_calls, user_token
+
+            tool_calls_messages = execute_tools(
+                out.tool_calls, tools_provider_map, tools_context
             )
             messages.extend(tool_calls_messages)