datarobot-genai 0.2.23__py3-none-any.whl → 0.2.25__py3-none-any.whl

datarobot_genai/drmcp/core/dr_mcp_server.py

@@ -31,9 +31,6 @@ from .dynamic_prompts.register import register_prompts_from_datarobot_prompt_man
 from .dynamic_tools.deployment.register import register_tools_of_datarobot_deployments
 from .logging import MCPLogging
 from .mcp_instance import mcp
-from .mcp_server_tools import get_all_available_tags  # noqa # pylint: disable=unused-import
-from .mcp_server_tools import get_tool_info_by_name  # noqa # pylint: disable=unused-import
-from .mcp_server_tools import list_tools_by_tags  # noqa # pylint: disable=unused-import
 from .memory_management.manager import MemoryManager
 from .routes import register_routes
 from .routes_utils import prefix_mount_path

datarobot_genai/drmcp/core/mcp_instance.py

@@ -16,17 +16,13 @@ import logging
 from collections.abc import Callable
 from functools import wraps
 from typing import Any
-from typing import overload
 
 from fastmcp import Context
 from fastmcp import FastMCP
 from fastmcp.exceptions import NotFoundError
 from fastmcp.prompts.prompt import Prompt
 from fastmcp.server.dependencies import get_context
-from fastmcp.tools import FunctionTool
 from fastmcp.tools import Tool
-from fastmcp.utilities.types import NotSet
-from fastmcp.utilities.types import NotSetT
 from mcp.types import AnyFunction
 from mcp.types import Tool as MCPTool
 from mcp.types import ToolAnnotations
@@ -120,86 +116,6 @@ class TaggedFastMCP(FastMCP):
                 "In stateless mode, clients will see changes on next request."
             )
 
-    @overload
-    def tool(
-        self,
-        name_or_fn: AnyFunction,
-        *,
-        name: str | None = None,
-        title: str | None = None,
-        description: str | None = None,
-        tags: set[str] | None = None,
-        output_schema: dict[str, Any] | None | NotSetT = NotSet,
-        annotations: ToolAnnotations | dict[str, Any] | None = None,
-        exclude_args: list[str] | None = None,
-        meta: dict[str, Any] | None = None,
-        enabled: bool | None = None,
-    ) -> FunctionTool: ...
-
-    @overload
-    def tool(
-        self,
-        name_or_fn: str | None = None,
-        *,
-        name: str | None = None,
-        title: str | None = None,
-        description: str | None = None,
-        tags: set[str] | None = None,
-        output_schema: dict[str, Any] | None | NotSetT = NotSet,
-        annotations: ToolAnnotations | dict[str, Any] | None = None,
-        exclude_args: list[str] | None = None,
-        meta: dict[str, Any] | None = None,
-        enabled: bool | None = None,
-    ) -> Callable[[AnyFunction], FunctionTool]: ...
-
-    def tool(
-        self,
-        name_or_fn: str | Callable[..., Any] | None = None,
-        *,
-        name: str | None = None,
-        title: str | None = None,
-        description: str | None = None,
-        tags: set[str] | None = None,
-        output_schema: dict[str, Any] | None | NotSetT = NotSet,
-        annotations: ToolAnnotations | dict[str, Any] | None = None,
-        exclude_args: list[str] | None = None,
-        meta: dict[str, Any] | None = None,
-        enabled: bool | None = None,
-        **kwargs: Any,
-    ) -> Callable[[AnyFunction], FunctionTool] | FunctionTool:
-        """
-        Extend tool decorator that supports tags and other annotations, while remaining
-        signature-compatible with FastMCP.tool to avoid recursion issues with partials.
-        """
-        if isinstance(annotations, dict):
-            annotations = ToolAnnotations(**annotations)
-
-        # Ensure tags are available both via native fastmcp `tags` and inside annotations
-        if tags is not None:
-            tags_ = sorted(tags)
-            if annotations is None:
-                annotations = ToolAnnotations()  # type: ignore[call-arg]
-                annotations.tags = tags_  # type: ignore[attr-defined, union-attr]
-            else:
-                # At this point, annotations is ToolAnnotations (not dict)
-                assert isinstance(annotations, ToolAnnotations)
-                annotations.tags = tags_  # type: ignore[attr-defined]
-
-        return super().tool(
-            name_or_fn,
-            name=name,
-            title=title,
-            description=description,
-            tags=tags,
-            output_schema=output_schema
-            if output_schema is not None
-            else kwargs.get("output_schema"),
-            annotations=annotations,
-            exclude_args=exclude_args,
-            meta=meta,
-            enabled=enabled,
-        )
-
     async def list_tools(
         self, tags: list[str] | None = None, match_all: bool = False
     ) -> list[MCPTool]:
@@ -488,11 +404,10 @@ async def register_tools(
     # Apply dr_mcp_extras to the memory-aware function
     wrapped_fn = dr_mcp_extras()(memory_aware_fn)
 
-    # Create annotations with tags, deployment_id if provided
-    annotations = ToolAnnotations()  # type: ignore[call-arg]
-    if tags is not None:
-        annotations.tags = tags  # type: ignore[attr-defined]
+    # Create annotations only when additional metadata is required
+    annotations: ToolAnnotations | None = None  # type: ignore[assignment]
     if deployment_id is not None:
+        annotations = ToolAnnotations()  # type: ignore[call-arg]
         annotations.deployment_id = deployment_id  # type: ignore[attr-defined]
 
     tool = Tool.from_function(

datarobot_genai/drmcp/core/tool_filter.py

@@ -41,7 +41,7 @@ def filter_tools_by_tags(
     filtered_tools = []
 
     for tool in tools:
-        tool_tags = getattr(tool.annotations, "tags", []) if tool.annotations else []
+        tool_tags = get_tool_tags(tool)
 
         if not tool_tags:
             continue
@@ -68,9 +68,18 @@ def get_tool_tags(tool: Tool | MCPTool) -> list[str]:
     -------
         List of tags for the tool
     """
+    # Primary: native FastMCP meta location
+    if hasattr(tool, "meta") and getattr(tool, "meta"):
+        fastmcp_meta = tool.meta.get("_fastmcp", {})
+        meta_tags = fastmcp_meta.get("tags", [])
+        if isinstance(meta_tags, list):
+            return meta_tags
+
+    # Fallback: annotations.tags (for compatibility during transition)
     if tool.annotations and hasattr(tool.annotations, "tags"):
         tags = getattr(tool.annotations, "tags", [])
         return tags if isinstance(tags, list) else []
+
     return []
 
 

datarobot_genai/drmcp/tools/predictive/project.py

@@ -14,6 +14,10 @@
 
 import json
 import logging
+from typing import Annotated
+
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
 
 from datarobot_genai.drmcp.core.clients import get_sdk_client
 from datarobot_genai.drmcp.core.mcp_instance import dr_mcp_tool
@@ -21,35 +25,39 @@ from datarobot_genai.drmcp.core.mcp_instance import dr_mcp_tool
 logger = logging.getLogger(__name__)
 
 
-@dr_mcp_tool(tags={"project", "management", "list"})
-async def list_projects() -> str:
-    """
-    List all DataRobot projects for the authenticated user.
-
-    Returns
-    -------
-        A string summary of the user's DataRobot projects.
-    """
+@dr_mcp_tool(tags={"predictive", "project", "read", "management", "list"})
+async def list_projects() -> ToolResult:
+    """List all DataRobot projects for the authenticated user."""
     client = get_sdk_client()
     projects = client.Project.list()
-    if not projects:
-        return "No projects found."
-    return "\n".join(f"{p.id}: {p.project_name}" for p in projects)
+    projects = {p.id: p.project_name for p in projects}
 
+    return ToolResult(
+        content=(
+            json.dumps(projects, indent=2)
+            if projects
+            else json.dumps({"message": "No projects found."}, indent=2)
+        ),
+        structured_content=projects,
+    )
 
-@dr_mcp_tool(tags={"project", "data", "info"})
-async def get_project_dataset_by_name(project_id: str, dataset_name: str) -> str:
-    """
-    Get a dataset ID by name for a given project.
 
-    Args:
-        project_id: The ID of the DataRobot project.
-        dataset_name: The name of the dataset to find (e.g., 'training', 'holdout').
+@dr_mcp_tool(tags={"predictive", "project", "read", "data", "info"})
+async def get_project_dataset_by_name(
+    *,
+    project_id: Annotated[str, "The ID of the DataRobot project."] | None = None,
+    dataset_name: Annotated[str, "The name of the dataset to find (e.g., 'training', 'holdout')."]
+    | None = None,
+) -> ToolError | ToolResult:
+    """Get a dataset ID by name for a given project.
 
-    Returns
-    -------
-        The dataset ID and the dataset type (source or prediction) as a string, or an error message.
+    The dataset ID and the dataset type (source or prediction) as a string, or an error message.
     """
+    if not project_id:
+        return ToolError("Project ID is required.")
+    if not dataset_name:
+        return ToolError("Dataset name is required.")
+
     client = get_sdk_client()
     project = client.Project.get(project_id)
     all_datasets = []
@@ -61,12 +69,22 @@ async def get_project_dataset_by_name(project_id: str, dataset_name: str) -> str
         all_datasets.extend([{"type": "prediction", "dataset": ds} for ds in prediction_datasets])
     for ds in all_datasets:
         if dataset_name.lower() in ds["dataset"].name.lower():
-            return json.dumps(
-                {
+            return ToolResult(
+                content=(
+                    json.dumps(
+                        {
+                            "dataset_id": ds["dataset"].id,
+                            "dataset_type": ds["type"],
+                        },
+                        indent=2,
+                    )
+                ),
+                structured_content={
                     "dataset_id": ds["dataset"].id,
                     "dataset_type": ds["type"],
-                    "ui_panel": ["dataset"],
                 },
-                indent=2,
             )
-    return f"Dataset with name containing '{dataset_name}' not found in project {project_id}."
+    return ToolResult(
+        content=f"Dataset with name containing '{dataset_name}' not found in project {project_id}.",
+        structured_content={},
+    )

datarobot_genai/drmcp/tools/predictive/training.py

@@ -18,8 +18,11 @@ import json
 import logging
 from dataclasses import asdict
 from dataclasses import dataclass
+from typing import Annotated
 
 import pandas as pd
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
 
 from datarobot_genai.drmcp.core.clients import get_sdk_client
 from datarobot_genai.drmcp.core.mcp_instance import dr_mcp_tool
@@ -53,22 +56,15 @@ class DatasetInsight:
     missing_data_summary: dict[str, float]
 
 
-@dr_mcp_tool(tags={"training", "analysis", "dataset"})
-async def analyze_dataset(dataset_id: str) -> str:
-    """
-    Analyze a dataset to understand its structure and potential use cases.
+@dr_mcp_tool(tags={"predictive", "training", "read", "analysis", "dataset"})
+async def analyze_dataset(
+    *,
+    dataset_id: Annotated[str, "The ID of the DataRobot dataset to analyze"] | None = None,
+) -> ToolError | ToolResult:
+    """Analyze a dataset to understand its structure and potential use cases."""
+    if not dataset_id:
+        return ToolError("Dataset ID must be provided")
 
-    Args:
-        dataset_id: The ID of the DataRobot dataset to analyze
-
-    Returns
-    -------
-        JSON string containing dataset insights including:
-        - Basic statistics (rows, columns)
-        - Column types (numerical, categorical, datetime, text)
-        - Potential target columns
-        - Missing data summary
-    """
     client = get_sdk_client()
     dataset = client.Dataset.get(dataset_id)
     df = dataset.get_as_dataframe()
@@ -105,27 +101,23 @@ async def analyze_dataset(dataset_id: str) -> str:
         potential_targets=potential_targets,
         missing_data_summary=missing_data,
     )
+    insights_dict = asdict(insights)
 
-    return json.dumps(asdict(insights), indent=2)
-
+    return ToolResult(
+        content=json.dumps(insights_dict, indent=2),
+        structured_content=insights_dict,
+    )
 
-@dr_mcp_tool(tags={"training", "analysis", "usecase"})
-async def suggest_use_cases(dataset_id: str) -> str:
-    """
-    Analyze a dataset and suggest potential machine learning use cases.
 
-    Args:
-        dataset_id: The ID of the DataRobot dataset to analyze
+@dr_mcp_tool(tags={"predictive", "training", "read", "analysis", "usecase"})
+async def suggest_use_cases(
+    *,
+    dataset_id: Annotated[str, "The ID of the DataRobot dataset to analyze"] | None = None,
+) -> ToolError | ToolResult:
+    """Analyze a dataset and suggest potential machine learning use cases."""
+    if not dataset_id:
+        return ToolError("Dataset ID must be provided")
 
-    Returns
-    -------
-        JSON string containing suggested use cases with:
-        - Use case name and description
-        - Suggested target column
-        - Problem type
-        - Confidence score
-        - Reasoning for the suggestion
-    """
     client = get_sdk_client()
     dataset = client.Dataset.get(dataset_id)
     df = dataset.get_as_dataframe()
@@ -141,27 +133,23 @@ async def suggest_use_cases(dataset_id: str) -> str:
 
     # Sort by confidence score
     suggestions.sort(key=lambda x: x["confidence"], reverse=True)
-    return json.dumps(suggestions, indent=2)
-
-
-@dr_mcp_tool(tags={"training", "analysis", "eda"})
-async def get_exploratory_insights(dataset_id: str, target_col: str | None = None) -> str:
-    """
-    Generate exploratory data insights for a dataset.
-
-    Args:
-        dataset_id: The ID of the DataRobot dataset to analyze
-        target_col: Optional target column to focus EDA insights on
-
-    Returns
-    -------
-        JSON string containing EDA insights including:
-        - Dataset summary statistics
-        - Target variable analysis (if specified)
-        - Feature correlations with target
-        - Missing data analysis
-        - Data type distribution
-    """
+
+    return ToolResult(
+        content=json.dumps(suggestions, indent=2),
+        structured_content={"use_case_suggestions": suggestions},
+    )
+
+
+@dr_mcp_tool(tags={"predictive", "training", "read", "analysis", "eda"})
+async def get_exploratory_insights(
+    *,
+    dataset_id: Annotated[str, "The ID of the DataRobot dataset to analyze"] | None = None,
+    target_col: Annotated[str, "Optional target column to focus EDA insights on"] | None = None,
+) -> ToolError | ToolResult:
+    """Generate exploratory data insights for a dataset."""
+    if not dataset_id:
+        return ToolError("Dataset ID must be provided")
+
     client = get_sdk_client()
     dataset = client.Dataset.get(dataset_id)
     df = dataset.get_as_dataframe()
@@ -238,8 +226,10 @@ async def get_exploratory_insights(dataset_id: str, target_col: str | None = Non
                     sorted(correlations.items(), key=lambda x: abs(x[1]), reverse=True)
                 )
 
-    eda_insights["ui_panel"] = ["eda"]
-    return json.dumps(eda_insights, indent=2)
+    return ToolResult(
+        content=json.dumps(eda_insights, indent=2),
+        structured_content=eda_insights,
+    )
 
 
 def _identify_potential_targets(
@@ -450,47 +440,50 @@ def _analyze_target_for_use_cases(df: pd.DataFrame, target_col: str) -> list[Use
     return suggestions
 
 
-@dr_mcp_tool(tags={"training", "autopilot", "model"})
+@dr_mcp_tool(tags={"predictive", "training", "write", "autopilot", "model"})
 async def start_autopilot(
-    target: str,
-    project_id: str | None = None,
-    mode: str | None = "quick",
-    dataset_url: str | None = None,
-    dataset_id: str | None = None,
-    project_name: str | None = "MCP Project",
-    use_case_id: str | None = None,
-) -> str:
-    """
-    Start automated model training (Autopilot) for a project.
-
-    Args:
-        target: Name of the target column for modeling.
-        project_id: Optional, the ID of the DataRobot project or a new project if no id is provided.
-        mode: Optional, Autopilot mode ('quick', 'comprehensive', or 'manual')
-        dataset_url: Optional, The URL to the dataset to upload (optional if dataset_id is provided)
-            for a new project.
-        dataset_id: Optional, The ID of an existing dataset in AI Catalog (optional if dataset_url
-            is provided) for a new project.
-        project_name: Optional, name for the project if no id is provided, creates a new project.
-        use_case_id: Optional, ID of the use case to associate this project with (required for
-            next-gen platform).
-
-    Returns
-    -------
-        JSON string containing:
-        - project_id: Project ID
-        - target: Target column name
-        - mode: Selected Autopilot mode
-        - status: Current project status
-        - ui_panel: List of recommended UI panels for visualization
-    """
+    *,
+    target: Annotated[str, "Name of the target column for modeling"] | None = None,
+    project_id: Annotated[
+        str, "Optional, the ID of the DataRobot project or a new project if no id is provided"
+    ]
+    | None = None,
+    mode: Annotated[str, "Optional, Autopilot mode ('quick', 'comprehensive', or 'manual')"]
+    | None = "quick",
+    dataset_url: Annotated[
+        str,
+        """
+        Optional, The URL to the dataset to upload
+        (optional if dataset_id is provided) for a new project.
+        """,
+    ]
+    | None = None,
+    dataset_id: Annotated[
+        str,
+        """
+        Optional, The ID of an existing dataset in AI Catalog
+        (optional if dataset_url is provided) for a new project.
+        """,
+    ]
+    | None = None,
+    project_name: Annotated[
+        str, "Optional, name for the project if no id is provided, creates a new project"
+    ]
+    | None = "MCP Project",
+    use_case_id: Annotated[
+        str,
+        "Optional, ID of the use case to associate this project (required for next-gen platform)",
+    ]
+    | None = None,
+) -> ToolError | ToolResult:
+    """Start automated model training (Autopilot) for a project."""
     client = get_sdk_client()
 
     if not project_id:
         if not dataset_url and not dataset_id:
-            return "Error: Either dataset_url or dataset_id must be provided"
+            return ToolError("Either dataset_url or dataset_id must be provided")
         if dataset_url and dataset_id:
-            return "Error: Please provide either dataset_url or dataset_id, not both"
+            return ToolError("Please provide either dataset_url or dataset_id, not both")
 
         if dataset_url:
             dataset = client.Dataset.create_from_url(dataset_url)
@@ -504,7 +497,7 @@ async def start_autopilot(
         project = client.Project.get(project_id)
 
     if not target:
-        return "Error: Target variable must be specified"
+        return ToolError("Target variable must be specified")
 
     try:
         # Start modeling
@@ -515,40 +508,48 @@ async def start_autopilot(
             "target": target,
             "mode": mode,
             "status": project.get_status(),
-            "ui_panel": ["eda", "model-training", "leaderboard"],
             "use_case_id": project.use_case_id,
         }
 
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        return json.dumps(
-            {
-                "error": f"Failed to start Autopilot: {str(e)}",
-                "project_id": project.id,
-                "target": target,
-                "mode": mode,
-            },
-            indent=2,
+        return ToolResult(
+            content=json.dumps(result, indent=2),
+            structured_content=result,
         )
 
+    except Exception as e:
+        return ToolError(
+            content=json.dumps(
+                {
+                    "error": f"Failed to start Autopilot: {str(e)}",
+                    "project_id": project.id if project else None,
+                    "target": target,
+                    "mode": mode,
+                },
+                indent=2,
+            )
+        )
 
-@dr_mcp_tool(tags={"training", "model", "evaluation"})
-async def get_model_roc_curve(project_id: str, model_id: str, source: str = "validation") -> str:
-    """
-    Get detailed ROC curve for a specific model.
 
-    Args:
-        project_id: The ID of the DataRobot project
-        model_id: The ID of the model to analyze
-        source: The source of the data to use for the ROC curve ('validation' or 'holdout' or
-            'crossValidation')
+@dr_mcp_tool(tags={"prediction", "training", "read", "model", "evaluation"})
+async def get_model_roc_curve(
+    *,
+    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[
+        str,
+        """
+        The source of the data to use for the ROC curve
+        ('validation' or 'holdout' or 'crossValidation')
+        """,
+    ]
+    | str = "validation",
+) -> ToolError | ToolResult:
+    """Get detailed ROC curve for a specific model."""
+    if not project_id:
+        return ToolError("Project ID must be provided")
+    if not model_id:
+        return ToolError("Model ID must be provided")
 
-    Returns
-    -------
-        JSON string containing:
-        - roc_curve: ROC curve data
-        - ui_panel: List of recommended UI panels for visualization
-    """
     client = get_sdk_client()
     project = client.Project.get(project_id)
     model = client.Model.get(project=project, model_id=model_id)
@@ -581,26 +582,26 @@ async def get_model_roc_curve(project_id: str, model_id: str, source: str = "val
             "source": source,
         }
 
-        return json.dumps({"data": roc_data, "ui_panel": ["roc-curve"]}, indent=2)
+        return ToolResult(
+            content=json.dumps({"data": roc_data}, indent=2),
+            structured_content={"data": roc_data},
+        )
     except Exception as e:
-        return json.dumps({"error": f"Failed to get ROC curve: {str(e)}"}, indent=2)
+        return ToolError(f"Failed to get ROC curve: {str(e)}")
 
 
-@dr_mcp_tool(tags={"training", "model", "evaluation"})
-async def get_model_feature_impact(project_id: str, model_id: str) -> str:
-    """
-    Get detailed feature impact for a specific model.
-
-    Args:
-        project_id: The ID of the DataRobot project
-        model_id: The ID of the model to analyze
+@dr_mcp_tool(tags={"predictive", "training", "read", "model", "evaluation"})
+async def get_model_feature_impact(
+    *,
+    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,
+) -> ToolError | ToolResult:
+    """Get detailed feature impact for a specific model."""
+    if not project_id:
+        return ToolError("Project ID must be provided")
+    if not model_id:
+        return ToolError("Model ID must be provided")
 
-    Returns
-    -------
-        JSON string containing:
-        - feature_impact: Feature importance scores
-        - ui_panel: List of recommended UI panels for visualization
-    """
     client = get_sdk_client()
     project = client.Project.get(project_id)
     model = client.Model.get(project=project, model_id=model_id)
@@ -608,26 +609,31 @@ async def get_model_feature_impact(project_id: str, model_id: str) -> str:
     model.request_feature_impact()
     feature_impact = model.get_or_request_feature_impact()
 
-    return json.dumps({"data": feature_impact, "ui_panel": ["feature-impact"]}, indent=2)
-
+    return ToolResult(
+        content=json.dumps({"data": feature_impact}, indent=2),
+        structured_content={"data": feature_impact},
+    )
 
-@dr_mcp_tool(tags={"training", "model", "evaluation"})
-async def get_model_lift_chart(project_id: str, model_id: str, source: str = "validation") -> str:
-    """
-    Get detailed lift chart for a specific model.
 
-    Args:
-        project_id: The ID of the DataRobot project
-        model_id: The ID of the model to analyze
-        source: The source of the data to use for the lift chart ('validation' or 'holdout' or
-            'crossValidation')
+@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[
+        str,
+        """
+        The source of the data to use for the lift chart
+        ('validation' or 'holdout' or 'crossValidation')
+        """,
+    ]
+    | str = "validation",
+) -> ToolError | ToolResult:
+    """Get detailed lift chart for a specific model."""
+    if not project_id:
+        return ToolError("Project ID must be provided")
+    if not model_id:
+        return ToolError("Model ID must be provided")
 
-    Returns
-    -------
-        JSON string containing:
-        - lift_chart: Lift chart data
-        - ui_panel: List of recommended UI panels for visualization
-    """
     client = get_sdk_client()
     project = client.Project.get(project_id)
     model = client.Model.get(project=project, model_id=model_id)
@@ -648,4 +654,7 @@ async def get_model_lift_chart(project_id: str, model_id: str, source: str = "va
         "target_class": lift_chart.target_class,
     }
 
-    return json.dumps({"data": lift_chart_data, "ui_panel": ["lift-chart"]}, indent=2)
+    return ToolResult(
+        content=json.dumps({"data": lift_chart_data}, indent=2),
+        structured_content={"data": lift_chart_data},
+    )

{datarobot_genai-0.2.23.dist-info → datarobot_genai-0.2.25.dist-info}/METADATA

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

{datarobot_genai-0.2.23.dist-info → datarobot_genai-0.2.25.dist-info}/RECORD

@@ -31,18 +31,17 @@ datarobot_genai/drmcp/core/config.py,sha256=69QDsVVSvjzv1uIHOjtQGzdg7_Ic4sA3vLA6
 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
-datarobot_genai/drmcp/core/dr_mcp_server.py,sha256=yKaIe7Qq23Zgny7Q1dc48iEcpfM8z2Ne6iouGYL58AE,14392
+datarobot_genai/drmcp/core/dr_mcp_server.py,sha256=czcjbwhZAeW9EtG_Bys0GARPOuQulstkiU7FG48Q9bg,14118
 datarobot_genai/drmcp/core/dr_mcp_server_logo.py,sha256=hib-nfR1SNTW6CnpFsFCkL9H_OMwa4YYyinV7VNOuLk,4708
 datarobot_genai/drmcp/core/exceptions.py,sha256=eqsGI-lxybgvWL5w4BFhbm3XzH1eU5tetwjnhJxelpc,905
 datarobot_genai/drmcp/core/logging.py,sha256=Y_hig4eBWiXGaVV7B_3wBcaYVRNH4ydptbEQhrP9-mY,3414
-datarobot_genai/drmcp/core/mcp_instance.py,sha256=hArS-BIdsIdRyRA21a4_ILgqqzmuRxZts-Ewgtf1H60,20917
-datarobot_genai/drmcp/core/mcp_server_tools.py,sha256=odNZKozfx0VV38SLZHw9lY0C0JM_JnRI06W3BBXnyE4,4278
+datarobot_genai/drmcp/core/mcp_instance.py,sha256=cbhy9vSw7LMZWPAYkpCyT0V55wfxyRLkzOlgwKh1T2o,17794
 datarobot_genai/drmcp/core/routes.py,sha256=dqE2M0UzAyyN9vQjlyTjYW4rpju3LT039po5weuO__I,17936
 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_filter.py,sha256=tLOcG50QBvS48cOVHM6OqoODYiiS6KeM_F-2diaHkW0,2858
+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
 datarobot_genai/drmcp/core/dynamic_prompts/controllers.py,sha256=AGJlKqgHRO0Kd7Gl-Ulw9KYBgzjTTFXWBvOUF-SuKUI,5454
@@ -95,8 +94,8 @@ datarobot_genai/drmcp/tools/predictive/deployment_info.py,sha256=BGEF_dmbxOBJR0n
 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=KaMDAvJY4s12j_4ybA7-KcCS1yMOj-KPIKNBgCSE2iM,2536
-datarobot_genai/drmcp/tools/predictive/training.py,sha256=kxeDVLqUh9ajDk8wK7CZRRydDK8UNuTVZCB3huUihF8,23660
+datarobot_genai/drmcp/tools/predictive/project.py,sha256=xC52UdYvuFeNZC7Y5MfXcvzTL70WwAacQXESr6rqN6s,3255
+datarobot_genai/drmcp/tools/predictive/training.py,sha256=S9V7AlO6mAgIAJNww0g5agFOw4YqRiCsIGaRDJcOe4A,23991
 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
@@ -111,9 +110,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.23.dist-info/METADATA,sha256=5BfpvvJLwdoecSF1_TQsKLrgdzjfc2_vY9gvACOqGFo,6301
-datarobot_genai-0.2.23.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-datarobot_genai-0.2.23.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
-datarobot_genai-0.2.23.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
-datarobot_genai-0.2.23.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
-datarobot_genai-0.2.23.dist-info/RECORD,,
+datarobot_genai-0.2.25.dist-info/METADATA,sha256=C2_0ev_hz7YV8hiWuMVjoS5O9fz62WZ_oN3DuYDj6rA,6301
+datarobot_genai-0.2.25.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+datarobot_genai-0.2.25.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
+datarobot_genai-0.2.25.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
+datarobot_genai-0.2.25.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
+datarobot_genai-0.2.25.dist-info/RECORD,,

datarobot_genai/drmcp/core/mcp_server_tools.py

@@ -1,129 +0,0 @@
-# Copyright 2025 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.
-
-import logging
-
-from .mcp_instance import dr_core_mcp_tool
-from .mcp_instance import mcp
-
-logger = logging.getLogger(__name__)
-
-
-@dr_core_mcp_tool(tags={"mcp_server_tools", "metadata"})
-async def get_all_available_tags() -> str:
-    """
-    List all unique tags from all registered tools.
-
-    Returns
-    -------
-        A string containing all available tags, one per line.
-    """
-    tags = await mcp.get_all_tags()
-    if not tags:
-        return "No tags found in any tools."
-
-    return "\n".join(sorted(tags))
-
-
-@dr_core_mcp_tool(tags={"mcp_server_tools", "metadata", "discovery"})
-async def list_tools_by_tags(tags: list[str] | None = None, match_all: bool = False) -> str:
-    """
-    List tools filtered by tags.
-
-    Args:
-        tags: Optional list of tags to filter by. If None, returns all tools.
-        match_all: If True, tool must have all specified tags (AND logic).
-                  If False, tool must have at least one tag (OR logic).
-                  Only used when tags is provided.
-
-    Returns
-    -------
-        A formatted string listing tools that match the tag criteria.
-    """
-    tools = await mcp.list_tools(tags=tags, match_all=match_all)
-
-    if not tools:
-        if tags:
-            logic = "all" if match_all else "any"
-            return f"No tools found with {logic} of the tags: {', '.join(tags)}"
-        else:
-            return "No tools found."
-
-    result = []
-    if tags:
-        logic = "all" if match_all else "any"
-        result.append(f"Tools with {logic} of the tags: {', '.join(tags)}")
-    else:
-        result.append("All available tools:")
-
-    result.append("")
-
-    for i, tool in enumerate(tools, 1):
-        tool_tags = []
-        if tool.annotations and hasattr(tool.annotations, "extra") and tool.annotations.extra:
-            tool_tags = tool.annotations.extra.get("tags", [])
-
-        result.append(f"{i}. {tool.name}")
-        result.append(f"   Description: {tool.description}")
-        if tool_tags:
-            result.append(f"   Tags: {', '.join(tool_tags)}")
-        result.append("")
-
-    return "\n".join(result)
-
-
-@dr_core_mcp_tool(tags={"mcp_server_tools", "metadata", "discovery"})
-async def get_tool_info_by_name(tool_name: str) -> str:
-    """
-    Get detailed information about a specific tool by name.
-
-    Args:
-        tool_name: The name of the tool to get information about.
-
-    Returns
-    -------
-        A formatted string with detailed information about the tool.
-    """
-    all_tools = await mcp.list_tools()
-
-    for tool in all_tools:
-        if tool.name == tool_name:
-            result = [f"Tool: {tool.name}"]
-            result.append(f"Description: {tool.description}")
-
-            # Get tags
-            tool_tags = []
-            if tool.annotations and hasattr(tool.annotations, "extra") and tool.annotations.extra:
-                tool_tags = tool.annotations.extra.get("tags", [])
-
-            if tool_tags:
-                result.append(f"Tags: {', '.join(tool_tags)}")
-            else:
-                result.append("Tags: None")
-
-            # Get input schema info
-            if (
-                tool.inputSchema
-                and hasattr(tool.inputSchema, "properties")
-                and tool.inputSchema.properties
-            ):
-                result.append("Parameters:")
-                for param_name, param_info in tool.inputSchema.properties.items():
-                    param_type = param_info.get("type", "unknown")
-                    param_desc = param_info.get("description", "No description")
-                    result.append(f"  - {param_name} ({param_type}): {param_desc}")
-
-            return "\n".join(result)
-
-    return f"Tool '{tool_name}' not found."