datarobot-genai 0.2.27__py3-none-any.whl → 0.2.28__py3-none-any.whl

datarobot_genai/drmcp/core/config.py

@@ -31,6 +31,124 @@ from .constants import DEFAULT_DATAROBOT_ENDPOINT
 from .constants import RUNTIME_PARAM_ENV_VAR_NAME_PREFIX
 
 
+class MCPToolConfig(BaseSettings):
+    """Tool configuration for MCP server."""
+
+    enable_predictive_tools: bool = Field(
+        default=True,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_PREDICTIVE_TOOLS",
+            "ENABLE_PREDICTIVE_TOOLS",
+        ),
+        description="Enable/disable predictive tools",
+    )
+
+    enable_jira_tools: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_JIRA_TOOLS",
+            "ENABLE_JIRA_TOOLS",
+        ),
+        description="Enable/disable Jira tools",
+    )
+
+    enable_confluence_tools: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_CONFLUENCE_TOOLS",
+            "ENABLE_CONFLUENCE_TOOLS",
+        ),
+        description="Enable/disable Confluence tools",
+    )
+
+    enable_gdrive_tools: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_GDRIVE_TOOLS",
+            "ENABLE_GDRIVE_TOOLS",
+        ),
+        description="Enable/disable GDrive tools",
+    )
+
+    enable_microsoft_graph_tools: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_MICROSOFT_GRAPH_TOOLS",
+            "ENABLE_MICROSOFT_GRAPH_TOOLS",
+        ),
+        description="Enable/disable Sharepoint tools",
+    )
+
+    is_atlassian_oauth_provider_configured: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_ATLASSIAN_OAUTH_PROVIDER_CONFIGURED",
+            "IS_ATLASSIAN_OAUTH_PROVIDER_CONFIGURED",
+        ),
+        description="Whether Atlassian OAuth provider is configured for Atlassian integration",
+    )
+
+    @property
+    def is_atlassian_oauth_configured(self) -> bool:
+        """Check if Atlassian OAuth is configured via provider flag or environment variables."""
+        return self.is_atlassian_oauth_provider_configured or bool(
+            os.getenv("ATLASSIAN_CLIENT_ID") and os.getenv("ATLASSIAN_CLIENT_SECRET")
+        )
+
+    is_google_oauth_provider_configured: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_GOOGLE_OAUTH_PROVIDER_CONFIGURED",
+            "IS_GOOGLE_OAUTH_PROVIDER_CONFIGURED",
+        ),
+        description="Whether Google OAuth provider is configured for Google integration",
+    )
+
+    @property
+    def is_google_oauth_configured(self) -> bool:
+        return self.is_google_oauth_provider_configured or bool(
+            os.getenv("GOOGLE_CLIENT_ID") and os.getenv("GOOGLE_CLIENT_SECRET")
+        )
+
+    is_microsoft_oauth_provider_configured: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_MICROSOFT_OAUTH_PROVIDER_CONFIGURED",
+            "IS_MICROSOFT_OAUTH_PROVIDER_CONFIGURED",
+        ),
+        description="Whether Microsoft OAuth provider is configured for Microsoft integration",
+    )
+
+    @property
+    def is_microsoft_oauth_configured(self) -> bool:
+        return self.is_microsoft_oauth_provider_configured or bool(
+            os.getenv("MICROSOFT_CLIENT_ID") and os.getenv("MICROSOFT_CLIENT_SECRET")
+        )
+
+    @field_validator(
+        "enable_predictive_tools",
+        "enable_jira_tools",
+        "enable_confluence_tools",
+        "enable_gdrive_tools",
+        "enable_microsoft_graph_tools",
+        "is_atlassian_oauth_provider_configured",
+        "is_google_oauth_provider_configured",
+        "is_microsoft_oauth_provider_configured",
+        mode="before",
+    )
+    @classmethod
+    def validate_runtime_params(cls, v: Any) -> Any:
+        """Validate runtime parameters."""
+        return extract_datarobot_runtime_param_payload(v)
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        case_sensitive=False,
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
 class MCPServerConfig(BaseSettings):
     """MCP Server configuration using pydantic settings."""
 
@@ -188,86 +306,11 @@ class MCPServerConfig(BaseSettings):
         ),
         description="Enable/disable memory management",
     )
-    enable_predictive_tools: bool = Field(
-        default=True,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_PREDICTIVE_TOOLS",
-            "ENABLE_PREDICTIVE_TOOLS",
-        ),
-        description="Enable/disable predictive tools",
-    )
 
-    # Jira tools
-    enable_jira_tools: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_JIRA_TOOLS",
-            "ENABLE_JIRA_TOOLS",
-        ),
-        description="Enable/disable Jira tools",
+    tool_config: MCPToolConfig = Field(
+        default_factory=MCPToolConfig,
+        description="Tool configuration",
     )
-    is_jira_oauth_provider_configured: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_JIRA_OAUTH_PROVIDER_CONFIGURED",
-            "IS_JIRA_OAUTH_PROVIDER_CONFIGURED",
-        ),
-        description="Whether Jira OAuth provider is configured for Jira integration",
-    )
-
-    @property
-    def is_jira_oauth_configured(self) -> bool:
-        return self.is_jira_oauth_provider_configured or bool(
-            os.getenv("JIRA_CLIENT_ID") and os.getenv("JIRA_CLIENT_SECRET")
-        )
-
-    # Confluence tools
-    enable_confluence_tools: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_CONFLUENCE_TOOLS",
-            "ENABLE_CONFLUENCE_TOOLS",
-        ),
-        description="Enable/disable Confluence tools",
-    )
-    is_confluence_oauth_provider_configured: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_CONFLUENCE_OAUTH_PROVIDER_CONFIGURED",
-            "IS_CONFLUENCE_OAUTH_PROVIDER_CONFIGURED",
-        ),
-        description="Whether Confluence OAuth provider is configured for Confluence integration",
-    )
-
-    @property
-    def is_confluence_oauth_configured(self) -> bool:
-        return self.is_confluence_oauth_provider_configured or bool(
-            os.getenv("CONFLUENCE_CLIENT_ID") and os.getenv("CONFLUENCE_CLIENT_SECRET")
-        )
-
-    # Gdrive tools
-    enable_gdrive_tools: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_GDRIVE_TOOLS",
-            "ENABLE_GDRIVE_TOOLS",
-        ),
-        description="Enable/disable GDrive tools",
-    )
-    is_gdrive_oauth_provider_configured: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_GDRIVE_OAUTH_PROVIDER_CONFIGURED",
-            "IS_GDRIVE_OAUTH_PROVIDER_CONFIGURED",
-        ),
-        description="Whether GDrive OAuth provider is configured for GDrive integration",
-    )
-
-    @property
-    def is_gdrive_oauth_configured(self) -> bool:
-        return self.is_gdrive_oauth_provider_configured or bool(
-            os.getenv("GDRIVE_CLIENT_ID") and os.getenv("GDRIVE_CLIENT_SECRET")
-        )
 
     @field_validator(
         "otel_attributes",
@@ -291,11 +334,6 @@ class MCPServerConfig(BaseSettings):
         "mcp_server_register_dynamic_tools_on_startup",
         "tool_registration_duplicate_behavior",
         "mcp_server_register_dynamic_prompts_on_startup",
-        "enable_predictive_tools",
-        "enable_jira_tools",
-        "is_jira_oauth_provider_configured",
-        "enable_confluence_tools",
-        "is_confluence_oauth_provider_configured",
         mode="before",
     )
     @classmethod

datarobot_genai/drmcp/core/tool_config.py

@@ -30,6 +30,7 @@ class ToolType(str, Enum):
     JIRA = "jira"
     CONFLUENCE = "confluence"
     GDRIVE = "gdrive"
+    MICROSOFT_GRAPH = "microsoft_graph"
 
 
 class ToolConfig(TypedDict):
@@ -39,7 +40,7 @@ class ToolConfig(TypedDict):
     oauth_check: Callable[["MCPServerConfig"], bool] | None
     directory: str
     package_prefix: str
-    config_field_name: str  # Name of the config field (e.g., "enable_predictive_tools")
+    config_field_name: str
 
 
 # Tool configuration registry
@@ -53,25 +54,32 @@ TOOL_CONFIGS: dict[ToolType, ToolConfig] = {
     ),
     ToolType.JIRA: ToolConfig(
         name="jira",
-        oauth_check=lambda config: config.is_jira_oauth_configured,
+        oauth_check=lambda config: config.tool_config.is_atlassian_oauth_configured,
         directory="jira",
         package_prefix="datarobot_genai.drmcp.tools.jira",
         config_field_name="enable_jira_tools",
     ),
     ToolType.CONFLUENCE: ToolConfig(
         name="confluence",
-        oauth_check=lambda config: config.is_confluence_oauth_configured,
+        oauth_check=lambda config: config.tool_config.is_atlassian_oauth_configured,
         directory="confluence",
         package_prefix="datarobot_genai.drmcp.tools.confluence",
         config_field_name="enable_confluence_tools",
     ),
     ToolType.GDRIVE: ToolConfig(
         name="gdrive",
-        oauth_check=lambda config: config.is_gdrive_oauth_configured,
+        oauth_check=lambda config: config.tool_config.is_google_oauth_configured,
         directory="gdrive",
         package_prefix="datarobot_genai.drmcp.tools.gdrive",
         config_field_name="enable_gdrive_tools",
     ),
+    ToolType.MICROSOFT_GRAPH: ToolConfig(
+        name="microsoft_graph",
+        oauth_check=lambda config: config.tool_config.is_microsoft_oauth_configured,
+        directory="microsoft_graph",
+        package_prefix="datarobot_genai.drmcp.tools.microsoft_graph",
+        config_field_name="enable_microsoft_graph_tools",
+    ),
 }
 
 
@@ -92,12 +100,12 @@ def is_tool_enabled(tool_type: ToolType, config: "MCPServerConfig") -> bool:
     -------
         True if the tool is enabled, False otherwise
     """
-    tool_config = TOOL_CONFIGS[tool_type]
-    enable_config_name = tool_config["config_field_name"]
-    is_enabled = getattr(config, enable_config_name)
+    tool_config_registry = TOOL_CONFIGS[tool_type]
+    enable_config_name = tool_config_registry["config_field_name"]
+    is_enabled = getattr(config.tool_config, enable_config_name)
 
     # If tool is enabled, check OAuth requirements if needed
-    if is_enabled and tool_config["oauth_check"] is not None:
-        return tool_config["oauth_check"](config)
+    if is_enabled and tool_config_registry["oauth_check"] is not None:
+        return tool_config_registry["oauth_check"](config)
 
     return is_enabled

datarobot_genai/drmcp/test_utils/tool_base_ete.py

@@ -39,6 +39,54 @@ class ETETestExpectations(BaseModel):
 SHOULD_NOT_BE_EMPTY = "SHOULD_NOT_BE_EMPTY"
 
 
+def _extract_structured_content(tool_result: str) -> Any:
+    r"""
+    Extract and parse structured content from tool result string.
+
+    Tool results are formatted as:
+    "Content: {content}\nStructured content: {structured_content}"
+
+    Structured content can be:
+    1. A JSON object with a "result" key: {"result": "..."} or {"result": "{...}"}
+    2. A direct JSON object: {"key": "value", ...}
+    3. Empty or missing
+
+    Args:
+        tool_result: The tool result string
+
+    Returns
+    -------
+        Parsed structured content, or None if not available
+    """
+    # Early returns for invalid inputs
+    if not tool_result or "Structured content: " not in tool_result:
+        return None
+
+    structured_part = tool_result.split("Structured content: ", 1)[1].strip()
+    # Parse JSON, return None on failure or empty structured_part
+    if not structured_part:
+        return None
+    try:
+        structured_data = json.loads(structured_part)
+    except json.JSONDecodeError:
+        return None
+
+    # If structured data has a "result" key, extract and parse that
+    if isinstance(structured_data, dict) and "result" in structured_data:
+        result_value = structured_data["result"]
+        # If result is a JSON string (starts with { or [), try to parse it
+        if isinstance(result_value, str) and result_value.strip().startswith(("{", "[")):
+            try:
+                parsed_result = json.loads(result_value)
+            except json.JSONDecodeError:
+                parsed_result = result_value  # Return string as-is if parsing fails
+            return parsed_result
+        return result_value  # Return result value directly
+
+    # If it's a direct JSON object (not wrapped in {"result": ...}), return it as-is
+    return structured_data
+
+
 def _check_dict_has_keys(
     expected: dict[str, Any],
     actual: dict[str, Any] | list[dict[str, Any]],
@@ -130,7 +178,26 @@ class ToolBaseE2E:
                             f"result, but got: {response.tool_results[i]}"
                         )
                     else:
-                        actual_result = json.loads(response.tool_results[i])
+                        actual_result = _extract_structured_content(response.tool_results[i])
+                        if actual_result is None:
+                            # Fallback: try to parse the entire tool result as JSON
+                            try:
+                                actual_result = json.loads(response.tool_results[i])
+                            except json.JSONDecodeError:
+                                # If that fails, try to extract content part
+                                if "Content: " in response.tool_results[i]:
+                                    content_part = response.tool_results[i].split("Content: ", 1)[1]
+                                    if "\nStructured content: " in content_part:
+                                        content_part = content_part.split(
+                                            "\nStructured content: ", 1
+                                        )[0]
+                                    try:
+                                        actual_result = json.loads(content_part.strip())
+                                    except json.JSONDecodeError:
+                                        raise AssertionError(
+                                            f"Could not parse tool result for "
+                                            f"{tool_call.tool_name}: {response.tool_results[i]}"
+                                        )
                         assert _check_dict_has_keys(expected_result, actual_result), (
                             f"Should have called {tool_call.tool_name} tool with the correct "
                             f"result structure, but got: {response.tool_results[i]}"

datarobot_genai/drmcp/tools/clients/microsoft_graph.py

@@ -0,0 +1,479 @@
+# Copyright 2026 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Microsoft Graph API Client for searching SharePoint and OneDrive content."""
+
+import logging
+from typing import Any
+
+import httpx
+from datarobot.auth.datarobot.exceptions import OAuthServiceClientErr
+from fastmcp.exceptions import ToolError
+from pydantic import BaseModel
+from pydantic import Field
+
+from datarobot_genai.drmcp.core.auth import get_access_token
+
+logger = logging.getLogger(__name__)
+
+GRAPH_API_BASE = "https://graph.microsoft.com/v1.0"
+MAX_SEARCH_RESULTS = 250
+
+
+async def get_microsoft_graph_access_token() -> str | ToolError:
+    """
+    Get Microsoft Graph OAuth access token with error handling.
+
+    Returns
+    -------
+        Access token string on success, ToolError on failure
+
+    Example:
+        ```python
+        token = await get_microsoft_graph_access_token()
+        if isinstance(token, ToolError):
+            # Handle error
+            return token
+        # Use token
+        ```
+    """
+    try:
+        access_token = await get_access_token("microsoft")
+        if not access_token:
+            logger.warning("Empty access token received")
+            return ToolError("Received empty access token. Please complete the OAuth flow.")
+        return access_token
+    except OAuthServiceClientErr as e:
+        logger.error(f"OAuth client error: {e}", exc_info=True)
+        return ToolError(
+            "Could not obtain access token for Microsoft. Make sure the OAuth "
+            "permission was granted for the application to act on your behalf."
+        )
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"Unexpected error obtaining access token: {error_msg}", exc_info=True)
+        return ToolError("An unexpected error occurred while obtaining access token for Microsoft.")
+
+
+class MicrosoftGraphError(Exception):
+    """Exception for Microsoft Graph API errors."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class MicrosoftGraphItem(BaseModel):
+    """Represents an item (file or folder) from Microsoft Graph (SharePoint/OneDrive)."""
+
+    id: str
+    name: str
+    web_url: str | None = Field(None, alias="webUrl")
+    size: int | None = None
+    created_datetime: str | None = Field(None, alias="createdDateTime")
+    last_modified_datetime: str | None = Field(None, alias="lastModifiedDateTime")
+    is_folder: bool = False
+    mime_type: str | None = Field(None, alias="mimeType")
+    drive_id: str | None = Field(None, alias="driveId")
+    parent_folder_id: str | None = Field(None, alias="parentFolderId")
+
+    model_config = {"populate_by_name": True}
+
+    @classmethod
+    def from_api_response(cls, data: dict[str, Any]) -> "MicrosoftGraphItem":
+        """Create a MicrosoftGraphItem from Microsoft Graph API response data."""
+        parent_ref = data.get("parentReference", {})
+        return cls(
+            id=data.get("id", ""),
+            name=data.get("name", "Unknown"),
+            web_url=data.get("webUrl"),
+            size=data.get("size"),
+            created_datetime=data.get("createdDateTime"),
+            last_modified_datetime=data.get("lastModifiedDateTime"),
+            is_folder="folder" in data,
+            mime_type=data.get("file", {}).get("mimeType") if "file" in data else None,
+            drive_id=parent_ref.get("driveId"),
+            parent_folder_id=parent_ref.get("id"),
+        )
+
+
+class MicrosoftGraphClient:
+    """Client for interacting with Microsoft Graph API to search SharePoint and OneDrive content."""
+
+    def __init__(self, access_token: str, site_url: str | None = None):
+        """
+        Initialize Microsoft Graph client with access token.
+
+        Args:
+            access_token: OAuth access token for Microsoft Graph API
+            site_url: Optional SharePoint site URL (e.g., https://tenant.sharepoint.com/sites/sitename)
+                     If not provided, searches across all accessible sites and OneDrive
+        """
+        self.access_token = access_token
+        self.site_url = site_url
+        self._client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {access_token}",
+                "Content-Type": "application/json",
+            },
+            timeout=30.0,
+        )
+        self._site_id: str | None = None
+
+    async def _get_site_id(self) -> str:
+        """Get the SharePoint site ID from the site URL or return root site ID."""
+        if self._site_id:
+            return self._site_id
+
+        # If no site_url provided, use root site
+        if not self.site_url:
+            # Get root site ID
+            graph_url = f"{GRAPH_API_BASE}/sites/root"
+            try:
+                response = await self._client.get(graph_url)
+                response.raise_for_status()
+                data = response.json()
+                self._site_id = data.get("id", "")
+                return self._site_id
+            except httpx.HTTPStatusError as e:
+                raise self._handle_http_error(e, "Failed to get root site ID") from e
+
+        # Extract site path from URL
+        # Format: https://{tenant}.sharepoint.com/sites/{site-name}
+        # or: https://{tenant}.sharepoint.com/sites/{site-name}/...
+        url_parts = self.site_url.replace("https://", "").split("/")
+        if len(url_parts) < 3:
+            raise MicrosoftGraphError(f"Invalid SharePoint site URL: {self.site_url}")
+
+        hostname = url_parts[0]  # tenant.sharepoint.com
+        site_path = "/".join(url_parts[1:])  # sites/site-name/...
+
+        # Use Microsoft Graph API to get site ID
+        graph_url = f"{GRAPH_API_BASE}/sites/{hostname}:/{site_path}"
+        try:
+            response = await self._client.get(graph_url)
+            response.raise_for_status()
+            data = response.json()
+            self._site_id = data.get("id", "")
+            return self._site_id
+        except httpx.HTTPStatusError as e:
+            raise self._handle_http_error(
+                e, f"Failed to get site ID from URL: {self.site_url}"
+            ) from e
+
+    def _handle_http_error(
+        self, error: httpx.HTTPStatusError, base_message: str
+    ) -> MicrosoftGraphError:
+        """Handle HTTP errors and return appropriate MicrosoftGraphError with user-friendly messages."""  # noqa: E501
+        error_msg = base_message
+
+        if error.response.status_code == 403:
+            error_msg += (
+                ": Insufficient permissions. Requires Sites.Read.All or Sites.Search.All "
+                "permission."
+            )
+        elif error.response.status_code == 400:
+            try:
+                error_data = error.response.json()
+                api_message = error_data.get("error", {}).get("message", "Invalid request")
+                error_msg += f": {api_message}"
+            except Exception:
+                error_msg += ": Invalid request parameters."
+        else:
+            error_msg += f": HTTP {error.response.status_code}"
+
+        return MicrosoftGraphError(error_msg)
+
+    async def search_content(
+        self,
+        search_query: str,
+        site_id: str | None = None,
+        from_offset: int = 0,
+        size: int = 250,
+        entity_types: list[str] | None = None,
+        filters: list[str] | None = None,
+        include_hidden_content: bool = False,
+        region: str | None = None,
+    ) -> list[MicrosoftGraphItem]:
+        """
+        Search for content using Microsoft Graph API search.
+
+        This tool utilizes Microsoft Graph's search engine to locate items across
+        SharePoint sites, OneDrive, and other Microsoft 365 services. When a site
+        is specified, it searches within that site. Otherwise, it searches across
+        all accessible SharePoint sites and OneDrive.
+
+        Args:
+            search_query: The search string to find files, folders, or list items
+            site_id: Optional site ID to scope the search. If not provided and site_url
+                    is set, will use that site. If neither is provided, searches across
+                    all accessible sites.
+            from_offset: The zero-based index of the first result to return (default: 0).
+                        Use this for pagination - increment by the size value to get the next page.
+            size: Maximum number of results to return in this request (default: 250, max: 250).
+                  The LLM should control pagination by making multiple calls with different
+                  'from' values (e.g., from=0 size=250, then from=250 size=250, etc.).
+            entity_types: Optional list of entity types to search. Valid values:
+                         "driveItem", "listItem", "site", "list", "drive".
+                         Default: ["driveItem", "listItem"]
+            filters: Optional list of filter expressions (KQL syntax) to refine search results
+            include_hidden_content: Whether to include hidden content in search results.
+                                  Only works with delegated permissions, not application
+                                  permissions.
+            region: Optional region code for application permissions (e.g., "NAM", "EUR", "APC")
+
+        Returns
+        -------
+            List of MicrosoftGraphItem objects matching the search query
+
+        Raises
+        ------
+            MicrosoftGraphError: If the search fails
+            httpx.HTTPStatusError: If the API request fails
+        """
+        if not search_query:
+            raise MicrosoftGraphError("Search query cannot be empty")
+
+        # Validate and limit size parameter
+        size = min(max(1, size), MAX_SEARCH_RESULTS)  # Between 1 and 250
+        from_offset = max(0, from_offset)  # Must be non-negative
+
+        # Determine which site to search
+        # If site_id is provided, use it directly; otherwise resolve from site_url if set
+        if site_id:
+            target_site_id = site_id
+        elif self.site_url:
+            target_site_id = await self._get_site_id()
+        else:
+            target_site_id = None
+
+        # Use unified Microsoft Search API for both site-specific and organization-wide search
+        # Reference: https://learn.microsoft.com/en-us/graph/api/search-query
+        graph_url = f"{GRAPH_API_BASE}/search/query"
+
+        # Default entity types: driveItem and listItem
+        if entity_types is None:
+            entity_types = ["driveItem", "listItem"]
+
+        # Validate entity types
+        valid_entity_types = ["driveItem", "listItem", "site", "list", "drive"]
+        entity_types = [et for et in entity_types if et in valid_entity_types]
+        if not entity_types:
+            entity_types = ["driveItem", "listItem"]  # Fallback to default
+
+        # Build search request payload
+        # Reference: https://learn.microsoft.com/en-us/graph/search-concept-files
+        query_parts = []
+
+        # If searching within a specific site, add scoping using KQL syntax first
+        if target_site_id:
+            # Get site details to construct proper scoping query
+            try:
+                site_info_url = f"{GRAPH_API_BASE}/sites/{target_site_id}"
+                site_response = await self._client.get(site_info_url)
+                site_response.raise_for_status()
+                site_data = site_response.json()
+                site_web_url = site_data.get("webUrl", "")
+
+                # Use KQL to scope search to the specific site
+                # Format: path:"{site-url}"
+                if site_web_url:
+                    query_parts.append(f'path:"{site_web_url}"')
+            except httpx.HTTPStatusError as e:
+                raise self._handle_http_error(e, "Failed to get site details for scoping") from e
+            except Exception as e:
+                logger.warning(
+                    f"Could not get site details for scoping, using un-scoped search: {e}"
+                )
+                # Fall back to un-scoped search if site details can't be retrieved
+
+        # Add the main search query
+        query_parts.append(search_query)
+
+        # Add filters if provided (using AND operator for proper KQL syntax)
+        if filters:
+            # Join filters with AND operator for proper KQL syntax
+            filter_string = " AND ".join(filters)
+            query_parts.append(filter_string)
+
+        # Combine all query parts with spaces
+        query_string = " ".join(query_parts)
+
+        # Build request payload with from and size parameters
+        request_payload = {
+            "entityTypes": entity_types,
+            "query": {
+                "queryString": query_string,
+            },
+            "from": from_offset,
+            "size": size,
+        }
+
+        # Add includeHiddenContent (only works with delegated permissions)
+        if include_hidden_content:
+            request_payload["includeHiddenContent"] = True
+
+        # Add region for application permissions
+        if region:
+            request_payload["region"] = region
+
+        payload = {"requests": [request_payload]}
+
+        try:
+            response = await self._client.post(graph_url, json=payload)
+            response.raise_for_status()
+            data = response.json()
+        except httpx.HTTPStatusError as e:
+            raise self._handle_http_error(e, "Failed to search SharePoint content") from e
+
+        # Parse the Microsoft Search API response format
+        # Reference: https://learn.microsoft.com/en-us/graph/search-concept-files
+        results = []
+        for request_result in data.get("value", []):
+            hits_containers = request_result.get("hitsContainers", [])
+            for container in hits_containers:
+                hits = container.get("hits", [])
+                for hit in hits:
+                    resource = hit.get("resource", {})
+                    if not resource:
+                        continue
+
+                    odata_type = resource.get("@odata.type", "")
+                    transformed_resource = self._transform_search_resource(resource, odata_type)
+                    # transformed_resource always returns a dict, so we can process it directly
+                    results.append(MicrosoftGraphItem.from_api_response(transformed_resource))
+
+        return results
+
+    def _transform_search_resource(
+        self, resource: dict[str, Any], odata_type: str
+    ) -> dict[str, Any]:
+        """Transform a search API resource to MicrosoftGraphItem-compatible format."""
+        # Preserve original values from resource if they exist, otherwise use defaults
+        # This ensures we don't lose data that might be present in the original response
+        base_resource = {
+            "id": resource.get("id", ""),
+            "webUrl": resource.get("webUrl"),
+            "createdDateTime": resource.get("createdDateTime"),
+            "lastModifiedDateTime": resource.get("lastModifiedDateTime"),
+            "size": resource.get("size"),
+            "folder": resource.get("folder", {}),
+            "file": resource.get("file", {}),
+        }
+
+        parent_ref = resource.get("parentReference", {})
+
+        if odata_type == "#microsoft.graph.listItem":
+            fields = resource.get("fields", {})
+            base_resource.update(
+                {
+                    "name": fields.get("Title") or resource.get("name", "Unknown"),
+                    "parentReference": {
+                        "driveId": parent_ref.get("driveId"),
+                        "id": parent_ref.get("id"),
+                    },
+                }
+            )
+        elif odata_type == "#microsoft.graph.site":
+            base_resource.update(
+                {
+                    "name": resource.get("displayName") or resource.get("name", "Unknown"),
+                    "parentReference": {},
+                }
+            )
+        elif odata_type == "#microsoft.graph.list":
+            base_resource.update(
+                {
+                    "name": resource.get("displayName") or resource.get("name", "Unknown"),
+                    "parentReference": {
+                        "siteId": parent_ref.get("siteId"),
+                    },
+                }
+            )
+        elif odata_type == "#microsoft.graph.drive":
+            base_resource.update(
+                {
+                    "name": resource.get("name", "Unknown"),
+                    "parentReference": {
+                        "siteId": parent_ref.get("siteId"),
+                    },
+                }
+            )
+        else:
+            # Standard driveItem - use resource as-is
+            return resource
+
+        return base_resource
+
+    async def __aenter__(self) -> "MicrosoftGraphClient":
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any
+    ) -> None:
+        """Async context manager exit."""
+        await self._client.aclose()
+
+
+def validate_site_url(site_url: str) -> str | None:
+    """Validate SharePoint site URL and return user-friendly error message if invalid.
+
+    Args:
+        site_url: The SharePoint site URL to validate
+
+    Returns
+    -------
+        None if valid, or a user-friendly error message if invalid
+    """
+    if not site_url:
+        return (
+            "SharePoint site URL is required. "
+            "Please provide a valid SharePoint site URL (e.g., https://yourtenant.sharepoint.com/sites/yoursite)."
+        )
+
+    site_url = site_url.strip()
+
+    if not site_url.startswith("https://"):
+        return (
+            f"Invalid SharePoint site URL: '{site_url}'. "
+            "The URL must start with 'https://'. "
+            "Example: https://yourtenant.sharepoint.com/sites/yoursite"
+        )
+
+    if "sharepoint.com" not in site_url.lower():
+        return (
+            f"Invalid SharePoint site URL: '{site_url}'. "
+            "The URL must be a SharePoint site URL containing 'sharepoint.com'. "
+            "Example: https://yourtenant.sharepoint.com/sites/yoursite"
+        )
+
+    # Check basic URL structure
+    url_parts = site_url.replace("https://", "").split("/")
+    if len(url_parts) < 1 or not url_parts[0]:
+        return (
+            f"Invalid SharePoint site URL format: '{site_url}'. "
+            "The URL must include a domain name. "
+            "Example: https://yourtenant.sharepoint.com/sites/yoursite"
+        )
+
+    # Check if it looks like a valid SharePoint site URL
+    domain = url_parts[0]
+    if not domain.endswith("sharepoint.com"):
+        return (
+            f"Invalid SharePoint site URL: '{site_url}'. "
+            "The domain must end with 'sharepoint.com'. "
+            "Example: https://yourtenant.sharepoint.com/sites/yoursite"
+        )
+
+    return None

datarobot_genai/drmcp/tools/microsoft_graph/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2026 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

datarobot_genai/drmcp/tools/microsoft_graph/tools.py

@@ -0,0 +1,198 @@
+# Copyright 2026 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Microsoft Graph MCP tools for searching SharePoint and OneDrive content."""
+
+import logging
+from typing import Annotated
+
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
+
+from datarobot_genai.drmcp.core.mcp_instance import dr_mcp_tool
+from datarobot_genai.drmcp.tools.clients.microsoft_graph import MicrosoftGraphClient
+from datarobot_genai.drmcp.tools.clients.microsoft_graph import MicrosoftGraphError
+from datarobot_genai.drmcp.tools.clients.microsoft_graph import get_microsoft_graph_access_token
+from datarobot_genai.drmcp.tools.clients.microsoft_graph import validate_site_url
+
+logger = logging.getLogger(__name__)
+
+
+@dr_mcp_tool(
+    tags={
+        "microsoft",
+        "graph api",
+        "sharepoint",
+        "drive",
+        "list",
+        "search",
+        "files",
+        "find",
+        "contents",
+    }
+)
+async def microsoft_graph_search_content(
+    *,
+    search_query: Annotated[str, "The search string to find files, folders, or list items."],
+    site_url: Annotated[
+        str | None,
+        "Optional SharePoint site URL to scope the search "
+        "(e.g., https://tenant.sharepoint.com/sites/sitename). "
+        "If not provided, searches across all accessible sites.",
+    ] = None,
+    site_id: Annotated[
+        str | None,
+        "Optional ID of the site to scope the search. If provided, takes precedence over site_url.",
+    ] = None,
+    from_offset: Annotated[
+        int,
+        "The zero-based index of the first result to return. Use this for pagination. "
+        "Default: 0 (start from the beginning). To get the next page, increment by the size "
+        "value (e.g., first page: from=0 size=250, second page: from=250 size=250, "
+        "third page: from=500 size=250).",
+    ] = 0,
+    size: Annotated[
+        int,
+        "Maximum number of results to return in this request. Default is 250, max is 250. "
+        "The LLM should control pagination by making multiple calls with different 'from' values.",
+    ] = 250,
+    entity_types: Annotated[
+        list[str] | None,
+        "Optional list of entity types to search. Valid values: 'driveItem', 'listItem', "
+        "'site', 'list', 'drive'. Default: ['driveItem', 'listItem']. "
+        "Multiple types can be specified.",
+    ] = None,
+    filters: Annotated[
+        list[str] | None,
+        "Optional list of KQL filter expressions to refine search results "
+        "(e.g., ['fileType:docx', 'size>1000']).",
+    ] = None,
+    include_hidden_content: Annotated[
+        bool,
+        "Whether to include hidden content in search results. Only works with delegated "
+        "permissions, not application permissions. Default: False.",
+    ] = False,
+    region: Annotated[
+        str | None,
+        "Optional region code for application permissions (e.g., 'NAM', 'EUR', 'APC'). "
+        "Required when using application permissions to search SharePoint content in "
+        "specific regions.",
+    ] = None,
+) -> ToolResult | ToolError:
+    """
+    Search for SharePoint and OneDrive content using Microsoft Graph Search API.
+
+    Search Scope:
+    - When site_url or site_id is provided: searches within the specified SharePoint site
+    - When neither is provided: searches across all accessible SharePoint sites and OneDrive
+
+    Supported Entity Types:
+    - driveItem: Files and folders in document libraries and OneDrive
+    - listItem: Items in SharePoint lists
+    - site: SharePoint sites
+    - list: SharePoint lists
+    - drive: Document libraries/drives
+
+    Filtering:
+    - Filters use KQL (Keyword Query Language) syntax
+    - Multiple filters are combined with AND operators
+    - Examples: ['fileType:docx', 'size>1000', 'lastModifiedTime>2024-01-01']
+    - Filters are applied in addition to the search query
+
+    Pagination:
+    - Controlled via from_offset (zero-based index) and size parameters
+    - Maximum size per request: 250 results
+    - To paginate: increment from_offset by size value for each subsequent page
+    - Example pagination sequence:
+      * Page 1: from_offset=0, size=250 (returns results 0-249)
+      * Page 2: from_offset=250, size=250 (returns results 250-499)
+      * Page 3: from_offset=500, size=250 (returns results 500-749)
+
+    API Reference:
+    - Endpoint: POST /search/query
+    - Documentation: https://learn.microsoft.com/en-us/graph/api/search-query
+    - Search concepts: https://learn.microsoft.com/en-us/graph/search-concept-files
+
+    Permissions:
+    - Requires Sites.Read.All or Sites.Search.All permission
+    - include_hidden_content only works with delegated permissions
+    - region parameter is required for application permissions in multi-region environments
+    """
+    if not search_query:
+        raise ToolError("Argument validation error: 'search_query' cannot be empty.")
+
+    # Validate site_url if provided
+    if site_url:
+        validation_error = validate_site_url(site_url)
+        if validation_error:
+            raise ToolError(validation_error)
+
+    access_token = await get_microsoft_graph_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with MicrosoftGraphClient(access_token=access_token, site_url=site_url) as client:
+            items = await client.search_content(
+                search_query=search_query,
+                site_id=site_id,
+                from_offset=from_offset,
+                size=size,
+                entity_types=entity_types,
+                filters=filters,
+                include_hidden_content=include_hidden_content,
+                region=region,
+            )
+    except MicrosoftGraphError as e:
+        logger.error(f"Microsoft Graph error searching content: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error searching Microsoft Graph content: {e}", exc_info=True)
+        raise ToolError(
+            f"An unexpected error occurred while searching Microsoft Graph content: {str(e)}"
+        )
+
+    results = []
+    for item in items:
+        result_dict = {
+            "id": item.id,  # Unique ID of the file, folder, or list item
+            "name": item.name,
+            "webUrl": item.web_url,
+            "size": item.size,
+            "createdDateTime": item.created_datetime,
+            "lastModifiedDateTime": item.last_modified_datetime,
+            "isFolder": item.is_folder,
+            "mimeType": item.mime_type,
+            # Document library/drive ID (driveId in Microsoft Graph API)
+            "documentLibraryId": item.drive_id,
+            "parentFolderId": item.parent_folder_id,  # Parent folder ID
+        }
+        results.append(result_dict)
+
+    n = len(results)
+    return ToolResult(
+        content=(
+            f"Successfully searched Microsoft Graph and retrieved {n} result(s) for "
+            f"'{search_query}' (from={from_offset}, size={size})."
+        ),
+        structured_content={
+            "query": search_query,
+            "siteUrl": site_url,
+            "siteId": site_id,
+            "from": from_offset,
+            "size": size,
+            "results": results,
+            "count": n,
+        },
+    )

datarobot_genai/drmcp/tools/predictive/data.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import logging
 import os
 from typing import Annotated
@@ -28,6 +29,7 @@ logger = logging.getLogger(__name__)
 
 @dr_mcp_tool(tags={"predictive", "data", "write", "upload", "catalog"})
 async def upload_dataset_to_ai_catalog(
+    *,
     file_path: Annotated[str, "The path to the dataset file to upload."] | None = None,
     file_url: Annotated[str, "The URL to the dataset file to upload."] | None = None,
 ) -> ToolError | ToolResult:
@@ -80,11 +82,17 @@ async def list_ai_catalog_items() -> ToolResult:
             structured_content={"datasets": []},
         )
 
+    datasets_dict = {ds.id: ds.name for ds in datasets}
+    datasets_count = len(datasets)
+
     return ToolResult(
-        content=f"Found {len(datasets)} AI Catalog items.",
+        content=(
+            f"Found {datasets_count} AI Catalog items, here are the details:\n"
+            f"{json.dumps(datasets_dict, indent=2)}"
+        ),
         structured_content={
-            "datasets": [{"id": ds.id, "name": ds.name} for ds in datasets],
-            "count": len(datasets),
+            "datasets": datasets_dict,
+            "count": datasets_count,
         },
     )
 

datarobot_genai/drmcp/tools/predictive/training.py

@@ -617,6 +617,7 @@ async def get_model_feature_impact(
 
 @dr_mcp_tool(tags={"predictive", "training", "read", "model", "evaluation"})
 async def get_model_lift_chart(
+    *,
     project_id: Annotated[str, "The ID of the DataRobot project"] | None = None,
     model_id: Annotated[str, "The ID of the model to analyze"] | None = None,
     source: Annotated[

{datarobot_genai-0.2.27.dist-info → datarobot_genai-0.2.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datarobot-genai
-Version: 0.2.27
+Version: 0.2.28
 Summary: Generic helpers for GenAI
 Project-URL: Homepage, https://github.com/datarobot-oss/datarobot-genai
 Author: DataRobot, Inc.

{datarobot_genai-0.2.27.dist-info → datarobot_genai-0.2.28.dist-info}/RECORD

@@ -27,7 +27,7 @@ datarobot_genai/drmcp/server.py,sha256=KE4kjS5f9bfdYftG14HBHrfvxDfCD4pwCXePfvl1O
 datarobot_genai/drmcp/core/__init__.py,sha256=y4yapzp3KnFMzSR6HlNDS4uSuyNT7I1iPBvaCLsS0sU,577
 datarobot_genai/drmcp/core/auth.py,sha256=E-5wrGbBFEBlD5377g6Exddrc7HsazamwX8tWr2RLXY,5815
 datarobot_genai/drmcp/core/clients.py,sha256=y-yG8617LbmiZ_L7FWfMrk4WjIekyr76u_Q80aLqGpI,5524
-datarobot_genai/drmcp/core/config.py,sha256=69QDsVVSvjzv1uIHOjtQGzdg7_Ic4sA3vLA6ZbZJ1Ok,12674
+datarobot_genai/drmcp/core/config.py,sha256=SWLhVKoqI4vmA-04TFKpKm1_G2yEMEN1e_8cv8d_XRM,13774
 datarobot_genai/drmcp/core/config_utils.py,sha256=U-aieWw7MyP03cGDFIp97JH99ZUfr3vD9uuTzBzxn7w,6428
 datarobot_genai/drmcp/core/constants.py,sha256=lUwoW_PTrbaBGqRJifKqCn3EoFacoEgdO-CpoFVrUoU,739
 datarobot_genai/drmcp/core/credentials.py,sha256=PYEUDNMVw1BoMzZKLkPVTypNkVevEPtmk3scKnE-zYg,6706
@@ -40,7 +40,7 @@ datarobot_genai/drmcp/core/routes.py,sha256=dqE2M0UzAyyN9vQjlyTjYW4rpju3LT039po5
 datarobot_genai/drmcp/core/routes_utils.py,sha256=vSseXWlplMSnRgoJgtP_rHxWSAVYcx_tpTv4lyTpQoc,944
 datarobot_genai/drmcp/core/server_life_cycle.py,sha256=WKGJWGxalvqxupzJ2y67Kklc_9PgpZT0uyjlv_sr5wc,3419
 datarobot_genai/drmcp/core/telemetry.py,sha256=NEkSTC1w6uQgtukLHI-sWvR4EMgInysgATcvfQ5CplM,15378
-datarobot_genai/drmcp/core/tool_config.py,sha256=5JCWO70ZH-K-34yS7vYJG2nl4i9UO_q_W9NCoWSXXno,3271
+datarobot_genai/drmcp/core/tool_config.py,sha256=izUdM6dN3GRBzSBs-OagggM2dX5PGBnDbVv4N5bfWFI,3668
 datarobot_genai/drmcp/core/tool_filter.py,sha256=yKQlEtzyIeXGxZJkHbK36QI19vmgQkvqmfx5cTo2pp4,3156
 datarobot_genai/drmcp/core/utils.py,sha256=EvfpqKZ3tECMoxpIQ_tA_3rOgy6KJEYKC0lWZo_Daag,4517
 datarobot_genai/drmcp/core/dynamic_prompts/__init__.py,sha256=y4yapzp3KnFMzSR6HlNDS4uSuyNT7I1iPBvaCLsS0sU,577
@@ -72,7 +72,7 @@ datarobot_genai/drmcp/test_utils/mcp_utils_ete.py,sha256=46rH0fYYmUj7ygf968iRbdS
 datarobot_genai/drmcp/test_utils/mcp_utils_integration.py,sha256=sHA_BWtpgIAFp9IXiNkUeBartBMjLAauqkV9bYtCr-g,3874
 datarobot_genai/drmcp/test_utils/openai_llm_mcp_client.py,sha256=YgyqHK09MB-PBaqT34heqvmvYYFtLpzzSJt7xuTJmDg,11224
 datarobot_genai/drmcp/test_utils/test_interactive.py,sha256=guXvR8q2H6VUdmvIjEJcElQJCC6lQ-oTrzbD2EkHeCs,8025
-datarobot_genai/drmcp/test_utils/tool_base_ete.py,sha256=wmI-xcL0rSr56-ZoGNB8np0CZHAU583o8-Kw7fRwtMw,6232
+datarobot_genai/drmcp/test_utils/tool_base_ete.py,sha256=3yMfOsz3LdHYywuE5BhdJDpTUowx37HsFSsMdBTxA80,9337
 datarobot_genai/drmcp/test_utils/utils.py,sha256=esGKFv8aO31-Qg3owayeWp32BYe1CdYOEutjjdbweCw,3048
 datarobot_genai/drmcp/tools/__init__.py,sha256=0kq9vMkF7EBsS6lkEdiLibmUrghTQqosHbZ5k-V9a5g,578
 datarobot_genai/drmcp/tools/clients/__init__.py,sha256=0kq9vMkF7EBsS6lkEdiLibmUrghTQqosHbZ5k-V9a5g,578
@@ -80,6 +80,7 @@ datarobot_genai/drmcp/tools/clients/atlassian.py,sha256=__M_uz7FrcbKCYRzeMn24DCE
 datarobot_genai/drmcp/tools/clients/confluence.py,sha256=h_G0By_kDnJeWDT_d-IREsaZ5-0xB5GoLXOqblYP5MA,20706
 datarobot_genai/drmcp/tools/clients/gdrive.py,sha256=8GztWTdpJ7Ir3NIvIoOHPzDscoR1Ui7Ct2IiKmuUzIc,26012
 datarobot_genai/drmcp/tools/clients/jira.py,sha256=Rm91JAyrNIqxu66-9rU1YqoRXVnWbEy-Ahvy6f6HlVg,9823
+datarobot_genai/drmcp/tools/clients/microsoft_graph.py,sha256=PASGThDPE8zkBZqach8lurJL1y47DWUPLwvf9N6uLGM,19234
 datarobot_genai/drmcp/tools/clients/s3.py,sha256=GmwzvurFdNfvxOooA8g5S4osRysHYU0S9ypg_177Glg,953
 datarobot_genai/drmcp/tools/confluence/__init__.py,sha256=0kq9vMkF7EBsS6lkEdiLibmUrghTQqosHbZ5k-V9a5g,578
 datarobot_genai/drmcp/tools/confluence/tools.py,sha256=_-ws65WLK8KZP_mKkf4yJ7ZunR8qdyoiMwHQX47MSMw,12362
@@ -87,15 +88,17 @@ datarobot_genai/drmcp/tools/gdrive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQe
 datarobot_genai/drmcp/tools/gdrive/tools.py,sha256=G8LlnGEINZqV83Q-b3ZliWkDjouhbozDam3w6GfA7s0,10711
 datarobot_genai/drmcp/tools/jira/__init__.py,sha256=0kq9vMkF7EBsS6lkEdiLibmUrghTQqosHbZ5k-V9a5g,578
 datarobot_genai/drmcp/tools/jira/tools.py,sha256=dfkqTU2HH-7n44hX80ODFacKq0p0LOchFcZtIIKFNMM,9687
+datarobot_genai/drmcp/tools/microsoft_graph/__init__.py,sha256=CuOaMt1AJo7cHx_GuhO3s_aqxZas_wlDsoBorBsvbeU,577
+datarobot_genai/drmcp/tools/microsoft_graph/tools.py,sha256=zJ-UA1TMhPOYcExvgWv0YBjDsSIDPA-U1SEbBrVfAc8,7744
 datarobot_genai/drmcp/tools/predictive/__init__.py,sha256=WuOHlNNEpEmcF7gVnhckruJRKU2qtmJLE3E7zoCGLDo,1030
-datarobot_genai/drmcp/tools/predictive/data.py,sha256=mt3PvIel4IUAZo0HLIs6QsTtRkuzX1qg-5PHI3IJ7E8,4455
+datarobot_genai/drmcp/tools/predictive/data.py,sha256=sSFAmO6x0DSuolw8urhMaOj5PwfUH29oc2mEOZI3YU4,4631
 datarobot_genai/drmcp/tools/predictive/deployment.py,sha256=lm02Ayuo11L1hP41fgi3QpR1Eyty-Wc16rM0c8SgliM,3277
 datarobot_genai/drmcp/tools/predictive/deployment_info.py,sha256=BGEF_dmbxOBJR0n1Tt9TO2-iNTQSBTr-oQUyaxLZ0ZI,15297
 datarobot_genai/drmcp/tools/predictive/model.py,sha256=Yih5-KedJ-1yupPLXCJsCXOdyWWi9pRvgapXDlgXWJA,4891
 datarobot_genai/drmcp/tools/predictive/predict.py,sha256=Qoob2_t2crfWtyPzkXMRz2ITZumnczU6Dq4C7q9RBMI,9370
 datarobot_genai/drmcp/tools/predictive/predict_realtime.py,sha256=urq6rPyZFsAP-bPyclSNzrkvb6FTamdlFau8q0IWWJ0,13472
 datarobot_genai/drmcp/tools/predictive/project.py,sha256=xC52UdYvuFeNZC7Y5MfXcvzTL70WwAacQXESr6rqN6s,3255
-datarobot_genai/drmcp/tools/predictive/training.py,sha256=S9V7AlO6mAgIAJNww0g5agFOw4YqRiCsIGaRDJcOe4A,23991
+datarobot_genai/drmcp/tools/predictive/training.py,sha256=LzMxbBT8wxKYDrRlVElfmTUrzpmGvwrR-mTGf6YUnIA,23998
 datarobot_genai/langgraph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datarobot_genai/langgraph/agent.py,sha256=DRnywmS9KDywyChtuIZZwNKbJs8BpC259EG_kxYbiQ8,15828
 datarobot_genai/langgraph/mcp.py,sha256=iA2_j46mZAaNaL7ntXT-LW6C-NMJkzr3VfKDDfe7mh8,2851
@@ -110,9 +113,9 @@ datarobot_genai/nat/datarobot_llm_clients.py,sha256=Yu208Ed_p_4P3HdpuM7fYnKcXtim
 datarobot_genai/nat/datarobot_llm_providers.py,sha256=aDoQcTeGI-odqydPXEX9OGGNFbzAtpqzTvHHEkmJuEQ,4963
 datarobot_genai/nat/datarobot_mcp_client.py,sha256=35FzilxNp4VqwBYI0NsOc91-xZm1C-AzWqrOdDy962A,9612
 datarobot_genai/nat/helpers.py,sha256=Q7E3ADZdtFfS8E6OQPyw2wgA6laQ58N3bhLj5CBWwJs,3265
-datarobot_genai-0.2.27.dist-info/METADATA,sha256=XfhoUrhYzD4u2Glt9HIR0AUEzlj170ct0ZkcSujc_W4,6301
-datarobot_genai-0.2.27.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-datarobot_genai-0.2.27.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
-datarobot_genai-0.2.27.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
-datarobot_genai-0.2.27.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
-datarobot_genai-0.2.27.dist-info/RECORD,,
+datarobot_genai-0.2.28.dist-info/METADATA,sha256=4BXiWsOeKBshX05-9fayxuNDKjA6ova0H2CbrQILvCQ,6301
+datarobot_genai-0.2.28.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+datarobot_genai-0.2.28.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
+datarobot_genai-0.2.28.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
+datarobot_genai-0.2.28.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
+datarobot_genai-0.2.28.dist-info/RECORD,,