Skip to main content
Glama
m0xai

Trello MCP Server with Python

by m0xai

update_checkitem

Modify checklist items in Trello by updating names, completion status, or positions to track task progress.

Instructions

Update a checkitem in a checklist.

Args:
    checklist_id (str): The ID of the checklist containing the item
    checkitem_id (str): The ID of the checkitem to update
    name (Optional[str]): New name for the checkitem
    checked (Optional[bool]): New checked state
    pos (Optional[str]): New position for the item

Returns:
    Dict: The updated checkitem data

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
checklist_idYes
checkitem_idYes
nameNo
checkedNo
posNo

Implementation Reference

  • The MCP tool handler function for 'update_checkitem'. It delegates to the ChecklistService.update_checkitem method.
    async def update_checkitem(
        checklist_id: str,
        checkitem_id: str,
        name: str | None = None,
        checked: bool | None = None,
        pos: str | None = None,
    ) -> Dict:
        """
        Update a checkitem in a checklist.
    
        Args:
            checklist_id (str): The ID of the checklist containing the item
            checkitem_id (str): The ID of the checkitem to update
            name (Optional[str]): New name for the checkitem
            checked (Optional[bool]): New checked state
            pos (Optional[str]): New position for the item
    
        Returns:
            Dict: The updated checkitem data
        """
        return await service.update_checkitem(
            checklist_id, checkitem_id, name, checked, pos
        )
  • Registration of the 'update_checkitem' tool with the MCP server.
    mcp.add_tool(checklist.update_checkitem)
  • Core helper method in ChecklistService that constructs the request data and calls the Trello API to update the checkitem.
    async def update_checkitem(
        self,
        checklist_id: str,
        checkitem_id: str,
        name: str | None = None,
        checked: bool | None = None,
        pos: str | None = None,
    ) -> Dict:
        """
        Update a checkitem in a checklist.
    
        Args:
            checklist_id (str): The ID of the checklist containing the item
            checkitem_id (str): The ID of the checkitem to update
            name (Optional[str]): New name for the checkitem
            checked (Optional[bool]): New checked state
            pos (Optional[str]): New position for the item
    
        Returns:
            Dict: The updated checkitem data
        """
        data = {}
        if name:
            data["name"] = name
        if checked is not None:
            data["checked"] = checked
        if pos:
            data["pos"] = pos
        return await self.client.PUT(
            f"/checklists/{checklist_id}/checkItems/{checkitem_id}", data=data
        )
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is an update operation, implying mutation, but doesn't cover critical aspects like required permissions, whether changes are reversible, error handling, or rate limits. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding the tool's behavior.

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 well-structured and appropriately sized. It starts with a clear purpose statement, followed by a bullet-point list of parameters with brief explanations, and ends with return information. Every sentence earns its place without redundancy or fluff.

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

Completeness3/5

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

Given the tool's complexity (mutation with 5 parameters), lack of annotations, and no output schema, the description is moderately complete. It covers parameters well but lacks behavioral context (e.g., permissions, side effects) and output details (only mentions 'Dict: The updated checkitem data' without structure). This is adequate but has clear gaps for safe and effective use.

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

Parameters4/5

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

The description adds substantial value beyond the input schema, which has 0% description coverage. It explains each parameter's purpose (e.g., 'New name for the checkitem', 'New checked state'), clarifying semantics that aren't evident from schema titles alone. However, it doesn't detail the 'pos' parameter's format (e.g., what values are valid for position), leaving a minor gap.

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 'update' and the resource 'checkitem in a checklist', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'update_card' or 'update_checklist', which would require more specific context about what distinguishes updating a checkitem from those other update operations.

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 checklist and checkitem IDs), exclusions, or comparisons to sibling tools like 'add_checkitem' or 'delete_checkitem', leaving the agent without context for tool selection.

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/m0xai/trello-mcp-server'

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