IBM Core Content Services MCP Server

Instructions

Implementation Reference

• src/cs_mcp_server/tools/documents.py:502-574 (handler)

  The core handler function that executes the tool logic: updates a document's class using a GraphQL mutation to the updateDocument operation.

  async def update_document_class(
      identifier: str,
      class_identifier: str,
  ) -> Union[Document, ToolError]:
      """
      **PREREQUISITES IN ORDER**: To use this tool, you MUST call determine_class first
      to get the new class_identifier.
  
      Description:
      Changes a document's class in the content repository.
      WARNING: Changing a document's class can result in loss of properties if the new class
      does not have the same properties as the old class. Properties that don't exist in the
      new class will be removed from the document.
  
      This tool ONLY changes the document's class and does NOT update any properties.
      To update properties after changing the class, use the update_document_properties tool.
  
      :param identifier: The document id or path (required). This can be either the document's ID (GUID) or its path in the repository (e.g., "/Folder1/document.pdf").
      :param class_identifier: The new class identifier for the document (required).
  
      :returns: If successful, returns a Document object with the new class.
               If unsuccessful, returns a ToolError with details about the failure.
      """
      method_name = "update_document_class"
      try:
          # Prepare the mutation
          mutation = """
          mutation ($object_store_name: String!, $identifier: String!, $class_identifier: String!) {
            updateDocument(
              repositoryIdentifier: $object_store_name
              identifier: $identifier
              classIdentifier: $class_identifier
            ) {
              id
              className
              properties {
                id
                value
              }
            }
          }
          """
  
          # Prepare variables for the GraphQL query
          variables = {
              "object_store_name": graphql_client.object_store,
              "identifier": identifier,
              "class_identifier": class_identifier,
          }
  
          # Execute the GraphQL mutation
          logger.info("Executing document class update")
          response = await graphql_client.execute_async(
              query=mutation, variables=variables
          )
  
          # Handle errors
          if "errors" in response:
              logger.error("GraphQL error: %s", response["errors"])
              return ToolError(message=f"{method_name} failed: {response['errors']}")
  
          # Create and return a Document instance from the response
          return Document.create_an_instance(
              graphQL_changed_object_dict=response["data"]["updateDocument"],
              class_identifier=class_identifier,
          )
  
      except Exception as e:
          logger.error("%s failed: %s", method_name, str(e))
          logger.error(traceback.format_exc())
          return ToolError(
              message=f"{method_name} failed: {str(e)}. Trace available in server logs."
          )

• src/cs_mcp_server/tools/documents.py:499-501 (registration)

  The FastMCP decorator that registers the update_document_class tool with the given name.

  @mcp.tool(
      name="update_document_class",
  )

• src/cs_mcp_server/tools/documents.py:502-505 (schema)

  The function signature defines the input schema (identifier: str, class_identifier: str) and output type.

  async def update_document_class(
      identifier: str,
      class_identifier: str,
  ) -> Union[Document, ToolError]: