Skip to main content
Glama
JLKmach

ServiceNow MCP Server

by JLKmach

move_catalog_items

Move ServiceNow catalog items to a different category by specifying item IDs and target category ID. Organize your service catalog by relocating items between categories.

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

  • The main handler function that implements the move_catalog_items tool logic. It updates the category field for each specified catalog item via ServiceNow REST API PATCH requests.
    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, including the handler function alias, schema, description, and serialization details.
    "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
    ),
Behavior2/5

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('move') but lacks critical details: whether this requires specific permissions, if the move is reversible, what happens to item relationships or metadata, or any rate limits. For a mutation tool with zero annotation coverage, this is a significant gap in transparency, leaving the agent unsure about side effects or constraints.

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 directly states the tool's function without any fluff or redundancy. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place, adhering perfectly to conciseness principles for tool descriptions.

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 complexity of a mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address behavioral aspects like permissions, reversibility, or error handling, nor does it explain return values or potential impacts. In a context with many sibling tools, the lack of usage guidelines further reduces completeness, leaving the agent under-informed for safe and effective invocation.

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'), so the schema does the heavy lifting. The description adds no additional semantic context beyond implying the parameters are used for moving items between categories, which is already evident from the schema. This meets the baseline for high schema coverage without enhancing parameter understanding.

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 verb ('move') and resource ('catalog items') with the destination ('to a different category'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from potential sibling tools like 'update_catalog_item' or 'create_catalog_category', which might also involve catalog item modifications, leaving room for ambiguity in a crowded toolset.

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. With many sibling tools like 'update_catalog_item' or 'create_catalog_category' that might overlap in catalog management, there's no indication of prerequisites, constraints, or specific scenarios where moving items is preferred over updating them directly. This omission could lead to incorrect tool selection in complex workflows.

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/JLKmach/servicenow-mcp'

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