feat(ai): Add support for AI features

jira: GDAI-185
risk: low

Author: malmiron

gooddata-sdk/gooddata_sdk/compute/service.py

@@ -9,6 +9,8 @@
 from gooddata_api_client.model.chat_history_result import ChatHistoryResult
 from gooddata_api_client.model.chat_request import ChatRequest
 from gooddata_api_client.model.chat_result import ChatResult
+from gooddata_api_client.model.search_request import SearchRequest
+from gooddata_api_client.model.search_result import SearchResult
 
 from gooddata_sdk.client import GoodDataApiClient
 from gooddata_sdk.compute.model.execution import Execution, ExecutionDefinition, ResultCacheMetadata
@@ -91,17 +93,27 @@ def ai_chat(self, workspace_id: str, question: str) -> ChatResult:
         response = self._actions_api.ai_chat(workspace_id, chat_request, _check_return_type=False)
         return response
 
-    def ai_chat_history(self, workspace_id: str, chat_history_interaction_id: int = 0) -> ChatHistoryResult:
+    def ai_chat_history(
+        self, workspace_id: str, chat_history_interaction_id: str = None, thread_id_suffix: str = None
+    ) -> ChatHistoryResult:
         """
         Get chat history with AI in GoodData workspace.
 
         Args:
             workspace_id: workspace identifier
-            chat_history_interaction_id: collect history starting from this interaction id
+            chat_history_interaction_id: collect history starting from this interaction id. If None, complete chat history is returned.
+            thread_id_suffix: suffix to identify a specific chat thread. If provided, chat_history_interaction_id is ignored.
         Returns:
-            str: Chat history response
+            ChatHistoryResult: Chat history response containing interactions and other metadata
         """
-        chat_history_request = ChatHistoryRequest(chat_history_interaction_id=chat_history_interaction_id)
+
+        if chat_history_interaction_id is None:
+            chat_history_interaction_id = ""
+        if thread_id_suffix is None:
+            thread_id_suffix = ""
+        chat_history_request = ChatHistoryRequest(
+            chat_history_interaction_id=chat_history_interaction_id, reset=False, thread_id_suffix=thread_id_suffix
+        )
         response = self._actions_api.ai_chat_history(workspace_id, chat_history_request, _check_return_type=False)
         return response
 
@@ -115,6 +127,72 @@ def ai_chat_history_reset(self, workspace_id: str) -> None:
         chat_history_request = ChatHistoryRequest(reset=True)
         self._actions_api.ai_chat_history(workspace_id, chat_history_request, _check_return_type=False)
 
+    def ai_chat_history_feedback(
+        self, workspace_id: str, user_feedback: str, chat_history_interaction_id: str, thread_id_suffix: str = None
+    ) -> None:
+        """
+        Provide feedback for a specific chat history interaction.
+
+        Args:
+            workspace_id: workspace identifier
+            user_feedback: feedback to provide ("POSITIVE", "NEGATIVE" or "NONE")
+            chat_history_interaction_id: interaction id to provide feedback for
+            thread_id_suffix: suffix to identify a specific chat thread
+        """
+        if thread_id_suffix is None:
+            thread_id_suffix = ""
+        chat_history_request = ChatHistoryRequest(
+            user_feedback=user_feedback,
+            chat_history_interaction_id=chat_history_interaction_id,
+            thread_id_suffix=thread_id_suffix,
+            reset=False,
+        )
+        self._actions_api.ai_chat_history(workspace_id, chat_history_request, _check_return_type=False)
+
+    def ai_search(
+        self,
+        workspace_id: str,
+        question: str,
+        deep_search: bool = None,
+        limit: int = None,
+        object_types: list[str] = None,
+        relevant_score_threshold: float = None,
+        title_to_descriptor_ratio: float = None,
+    ) -> SearchResult:
+        """
+        Search for metadata objects using similarity search.
+
+        Args:
+            workspace_id: workspace identifier
+            question: keyword/sentence input for search
+            deep_search: turn on deep search - if true, content of complex objects will be searched as well
+            limit: maximum number of results to return
+            object_types: list of object types to search for. Enum items: "attribute", "metric", "fact",
+                "label", "date", "dataset", "visualization" and "dashboard"
+            relevant_score_threshold: minimum relevance score threshold for results
+            title_to_descriptor_ratio: ratio of title score to descriptor score
+
+        Returns:
+            SearchResult: Search results
+
+        Note:
+            Default values for optional parameters are documented in the AI Search endpoint of the GoodData API.
+        """
+        search_params = {}
+        if deep_search is not None:
+            search_params["deep_search"] = deep_search
+        if limit is not None:
+            search_params["limit"] = limit
+        if object_types is not None:
+            search_params["object_types"] = object_types
+        if relevant_score_threshold is not None:
+            search_params["relevant_score_threshold"] = relevant_score_threshold
+        if title_to_descriptor_ratio is not None:
+            search_params["title_to_descriptor_ratio"] = title_to_descriptor_ratio
+        search_request = SearchRequest(question=question, **search_params)
+        response = self._actions_api.ai_search(workspace_id, search_request, _check_return_type=False)
+        return response
+
     def cancel_executions(self, executions: dict[str, dict[str, str]]) -> None:
         """
         Try to cancel given executions using the cancel api endpoint.
@@ -132,3 +210,13 @@ def cancel_executions(self, executions: dict[str, dict[str, str]]) -> None:
                 )
         except ApiException as e:
             print("Exception when calling ActionsApi->cancel_executions: %s\n", e)
+
+    def metadata_sync(self, workspace_id: str, async_req: bool = False) -> None:
+        """
+        Sync metadata to other services.
+
+        Args:
+            workspace_id: workspace identifier
+            async_req: if True, the metadata sync will be performed asynchronously
+        """
+        self._actions_api.metadata_sync(workspace_id, async_req=async_req, _check_return_type=False)

gooddata-sdk/tests/compute/test_compute_service.py

@@ -0,0 +1,117 @@
+# (C) 2025 GoodData Corporation
+from unittest.mock import MagicMock
+
+from gooddata_api_client.model.chat_history_request import ChatHistoryRequest
+from gooddata_api_client.model.search_request import SearchRequest
+from gooddata_sdk.compute.service import ComputeService
+
+
+def test_ai_search_minimal_params():
+    api_client = MagicMock()
+    actions_api = MagicMock()
+    api_client.actions_api = actions_api
+    compute_service = ComputeService(api_client)
+
+    compute_service.ai_search("workspace1", "revenue")
+    actions_api.ai_search.assert_called_with("workspace1", SearchRequest(question="revenue"), _check_return_type=False)
+
+
+def test_ai_search_all_optional_params():
+    api_client = MagicMock()
+    actions_api = MagicMock()
+    api_client.actions_api = actions_api
+    compute_service = ComputeService(api_client)
+
+    compute_service.ai_search(
+        "workspace1",
+        "revenue",
+        deep_search=True,
+        limit=5,
+        object_types=["metric", "attribute"],
+        relevant_score_threshold=0.3,
+        title_to_descriptor_ratio=0.7,
+    )
+    actions_api.ai_search.assert_called_with(
+        "workspace1",
+        SearchRequest(
+            question="revenue",
+            deep_search=True,
+            limit=5,
+            object_types=["metric", "attribute"],
+            relevant_score_threshold=0.3,
+            title_to_descriptor_ratio=0.7,
+        ),
+        _check_return_type=False,
+    )
+
+
+def test_ai_chat_history_complete():
+    api_client = MagicMock()
+    actions_api = MagicMock()
+    api_client.actions_api = actions_api
+    compute_service = ComputeService(api_client)
+
+    compute_service.ai_chat_history("workspace1")
+    actions_api.ai_chat_history.assert_called_with(
+        "workspace1",
+        ChatHistoryRequest(chat_history_interaction_id="", reset=False, thread_id_suffix=""),
+        _check_return_type=False,
+    )
+
+
+def test_ai_chat_history_with_interaction_id():
+    api_client = MagicMock()
+    actions_api = MagicMock()
+    api_client.actions_api = actions_api
+    compute_service = ComputeService(api_client)
+
+    compute_service.ai_chat_history("workspace1", "interaction123", "thread123")
+    actions_api.ai_chat_history.assert_called_with(
+        "workspace1",
+        ChatHistoryRequest(chat_history_interaction_id="interaction123", reset=False, thread_id_suffix="thread123"),
+        _check_return_type=False,
+    )
+
+
+def test_ai_chat_history_reset():
+    api_client = MagicMock()
+    actions_api = MagicMock()
+    api_client.actions_api = actions_api
+    compute_service = ComputeService(api_client)
+
+    compute_service.ai_chat_history_reset("workspace1")
+    actions_api.ai_chat_history.assert_called_with(
+        "workspace1", ChatHistoryRequest(reset=True), _check_return_type=False
+    )
+
+
+def test_ai_chat_history_feedback():
+    api_client = MagicMock()
+    actions_api = MagicMock()
+    api_client.actions_api = actions_api
+    compute_service = ComputeService(api_client)
+
+    compute_service.ai_chat_history_feedback("workspace1", "POSITIVE", "interaction123", "thread123")
+    actions_api.ai_chat_history.assert_called_with(
+        "workspace1",
+        ChatHistoryRequest(
+            user_feedback="POSITIVE",
+            chat_history_interaction_id="interaction123",
+            thread_id_suffix="thread123",
+            reset=False,
+        ),
+        _check_return_type=False,
+    )
+
+
+def test_metadata_sync():
+    api_client = MagicMock()
+    actions_api = MagicMock()
+    api_client.actions_api = actions_api
+    compute_service = ComputeService(api_client)
+
+    compute_service.metadata_sync("workspace1")
+    actions_api.metadata_sync.assert_called_with("workspace1", async_req=False, _check_return_type=False)
+
+    compute_service.metadata_sync("workspace1", async_req=True)
+    actions_api.metadata_sync.assert_called_with("workspace1", async_req=True, _check_return_type=False)