Skip to main content
Glama
vparlapalli490

ServiceNow MCP Server

move_catalog_items

Move ServiceNow catalog items to a different category by specifying item IDs and target category ID.

Instructions

Move catalog items to a different category.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
item_idsYesList of catalog item IDs to move
target_category_idYesTarget category ID to move items to

Implementation Reference

  • Main handler function that executes the tool logic: iterates over item_ids, patches each sc_cat_item to set the new category, handles errors and returns CatalogResponse.
    def move_catalog_items(
        config: ServerConfig,
        auth_manager: AuthManager,
        params: MoveCatalogItemsParams,
    ) -> CatalogResponse:
        """
        Move catalog items to a different category.
    
        Args:
            config: Server configuration
            auth_manager: Authentication manager
            params: Parameters for moving catalog items
    
        Returns:
            Response containing the result of the operation
        """
        logger.info(f"Moving {len(params.item_ids)} catalog items to category: {params.target_category_id}")
        
        # Build the API URL
        url = f"{config.instance_url}/api/now/table/sc_cat_item"
        
        # Make the API request for each item
        headers = auth_manager.get_headers()
        headers["Accept"] = "application/json"
        headers["Content-Type"] = "application/json"
        
        success_count = 0
        failed_items = []
        
        try:
            for item_id in params.item_ids:
                item_url = f"{url}/{item_id}"
                body = {
                    "category": params.target_category_id
                }
                
                try:
                    response = requests.patch(item_url, headers=headers, json=body)
                    response.raise_for_status()
                    success_count += 1
                except requests.exceptions.RequestException as e:
                    logger.error(f"Error moving catalog item {item_id}: {str(e)}")
                    failed_items.append({"item_id": item_id, "error": str(e)})
            
            # Prepare the response
            if success_count == len(params.item_ids):
                return CatalogResponse(
                    success=True,
                    message=f"Successfully moved {success_count} catalog items to category {params.target_category_id}",
                    data={"moved_items_count": success_count},
                )
            elif success_count > 0:
                return CatalogResponse(
                    success=True,
                    message=f"Partially moved catalog items. {success_count} succeeded, {len(failed_items)} failed.",
                    data={
                        "moved_items_count": success_count,
                        "failed_items": failed_items,
                    },
                )
            else:
                return CatalogResponse(
                    success=False,
                    message="Failed to move any catalog items",
                    data={"failed_items": failed_items},
                )
        
        except Exception as e:
            logger.error(f"Error moving catalog items: {str(e)}")
            return CatalogResponse(
                success=False,
                message=f"Error moving catalog items: {str(e)}",
                data=None,
            ) 
  • Pydantic model defining the input parameters for the move_catalog_items tool.
    class MoveCatalogItemsParams(BaseModel):
        """Parameters for moving catalog items between categories."""
        
        item_ids: List[str] = Field(..., description="List of catalog item IDs to move")
        target_category_id: str = Field(..., description="Target category ID to move items to")
  • Registration of the move_catalog_items tool in the central tool definitions dictionary used by the MCP server.
    "move_catalog_items": (
        move_catalog_items_tool,
        MoveCatalogItemsParams,
        str,  # Expects JSON string
        "Move catalog items to a different category.",
        "json_dict",  # Tool returns Pydantic model
    ),
  • Exported in __all__ for easy import of the tool function.
    "move_catalog_items",
  • Import alias used in tool registration.
        move_catalog_items as move_catalog_items_tool,
    )
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states the tool performs a 'move' operation, implying mutation, but doesn't disclose behavioral traits such as permissions required, whether the move is atomic or reversible, error handling for invalid IDs, or effects on related data (e.g., item references). For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core action ('Move catalog items') and destination ('to a different category'). There is no wasted verbiage or redundancy, making it easy to parse quickly. Every word earns its place by directly contributing to understanding the tool's function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity as a mutation operation with no annotations and no output schema, the description is incomplete. It lacks details on behavioral aspects (e.g., success/failure responses, side effects), usage context, and output expectations. For a tool that modifies data, this minimal description fails to provide adequate context for safe and effective use by an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with clear descriptions for both parameters ('item_ids' and 'target_category_id'). The description adds minimal value beyond the schema, as it only reiterates the general purpose without providing additional semantics like format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't detract either.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Move') and resource ('catalog items'), specifying the destination ('to a different category'). It distinguishes itself from sibling tools like 'list_catalog_items' or 'update_catalog_category' by focusing on relocation rather than listing or updating. However, it doesn't explicitly differentiate from potential similar tools like 'reorder_workflow_activities', which might involve moving items within a workflow context.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing existing items and categories), exclusions (e.g., cannot move items to non-existent categories), or comparisons to siblings like 'update_catalog_category' which might handle category changes differently. Usage is implied by the action but lacks explicit context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/vparlapalli490/MCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server