Skip to main content
Glama
DiversioTeam

ClickUp MCP Server

by DiversioTeam

create_task

Add new tasks to ClickUp lists with titles, descriptions, assignees, priorities, due dates, and time estimates for organized project management.

Instructions

Create a new task in a specific list

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
titleYesTask title
descriptionNoTask description
list_nameNoName of the list to create task in
list_idNoID of the list (alternative to list_name)
assigneesNoUser IDs to assign
priorityNoPriority (1=urgent, 2=high, 3=normal, 4=low)
due_dateNoDue date (ISO 8601 format)
time_estimateNoTime estimate (e.g., '2h 30m')

Implementation Reference

  • Primary implementation of the 'create_task' tool handler. Resolves list by name if needed, builds CreateTaskRequest from parameters, calls client.create_task API wrapper, and returns formatted task information.
    async def create_task(
        self,
        title: str,
        description: Optional[str] = None,
        list_name: Optional[str] = None,
        list_id: Optional[str] = None,
        assignees: Optional[List[int]] = None,
        priority: Optional[int] = None,
        due_date: Optional[str] = None,
        time_estimate: Optional[str] = None,
        **kwargs: Any,
    ) -> Dict[str, Any]:
        """Create a new task."""
        # Find list ID if name provided
        if not list_id and not list_name:
            raise ValueError("Either list_id or list_name must be provided")
    
        if not list_id:
            lst = await self.client.find_list_by_name(list_name)
            if not lst:
                return {"error": f"List '{list_name}' not found"}
            list_id = lst.id
    
        # Build task request
        task_request = CreateTaskRequest(name=title)
    
        if description:
            task_request.description = description
        if assignees:
            task_request.assignees = assignees
        if priority:
            task_request.priority = priority
        if due_date:
            # Parse ISO date to unix timestamp
            dt = datetime.fromisoformat(due_date.replace("Z", "+00:00"))
            task_request.due_date = int(dt.timestamp() * 1000)
            task_request.due_date_time = True
        if time_estimate:
            task_request.time_estimate = parse_duration(time_estimate)
    
        # Create task
        task = await self.client.create_task(list_id, task_request)
    
        result = {
            "id": task.id,
            "name": task.name,
            "status": task.status.status,
            "url": format_task_url(task.id),
            "list": task.list.get("name", "Unknown"),
            "created": True,
        }
    
        if task.custom_id:
            result["custom_id"] = task.custom_id
    
        return result
  • Input schema definition for the 'create_task' tool, defining parameters like title (required), description, list_name or list_id, assignees, priority, due_date, and time_estimate.
    Tool(
        name="create_task",
        description="Create a new task in a specific list",
        inputSchema={
            "type": "object",
            "properties": {
                "title": {"type": "string", "description": "Task title"},
                "description": {"type": "string", "description": "Task description"},
                "list_name": {
                    "type": "string",
                    "description": "Name of the list to create task in",
                },
                "list_id": {
                    "type": "string",
                    "description": "ID of the list (alternative to list_name)",
                },
                "assignees": {
                    "type": "array",
                    "items": {"type": "integer"},
                    "description": "User IDs to assign",
                },
                "priority": {
                    "type": "integer",
                    "description": "Priority (1=urgent, 2=high, 3=normal, 4=low)",
                },
                "due_date": {"type": "string", "description": "Due date (ISO 8601 format)"},
                "time_estimate": {
                    "type": "string",
                    "description": "Time estimate (e.g., '2h 30m')",
                },
            },
            "required": ["title"],
        },
  • Registration of the 'create_task' handler method in the ClickUpTools class's internal tools dictionary, mapping the tool name to the handler function.
    self._tools: Dict[str, Callable] = {
        "create_task": self.create_task,
        "get_task": self.get_task,
        "update_task": self.update_task,
        "delete_task": self.delete_task,
        "list_tasks": self.list_tasks,
        "search_tasks": self.search_tasks,
        "get_subtasks": self.get_subtasks,
        "get_task_comments": self.get_task_comments,
        "create_task_comment": self.create_task_comment,
        "get_task_status": self.get_task_status,
        "update_task_status": self.update_task_status,
        "get_assignees": self.get_assignees,
        "assign_task": self.assign_task,
        "list_spaces": self.list_spaces,
        "list_folders": self.list_folders,
        "list_lists": self.list_lists,
        "find_list_by_name": self.find_list_by_name,
        # Bulk operations
        "bulk_update_tasks": self.bulk_update_tasks,
        "bulk_move_tasks": self.bulk_move_tasks,
        # Time tracking
        "get_time_tracked": self.get_time_tracked,
        "log_time": self.log_time,
        # Templates
        "create_task_from_template": self.create_task_from_template,
        "create_task_chain": self.create_task_chain,
        # Analytics
        "get_team_workload": self.get_team_workload,
        "get_task_analytics": self.get_task_analytics,
        # User management
        "list_users": self.list_users,
        "get_current_user": self.get_current_user,
        "find_user_by_name": self.find_user_by_name,
    }
  • Low-level ClickUpClient method that performs the actual HTTP POST request to the ClickUp API to create a task, using the CreateTaskRequest model.
    async def create_task(
        self,
        list_id: str,
        task: CreateTaskRequest,
    ) -> Task:
        """Create a new task."""
        data = await self._request(
            "POST",
            f"/list/{list_id}/task",
            json=task.model_dump(exclude_none=True),
        )
        return Task(**data)
  • Pydantic model defining the structure for task creation data, used by the client to serialize parameters for the ClickUp API.
    class CreateTaskRequest(BaseModel):
        """Request model for creating a task."""
    
        name: str
        description: Optional[str] = None
        assignees: Optional[ListType[int]] = None
        tags: Optional[ListType[str]] = None
        status: Optional[str] = None
        priority: Optional[int] = None
        due_date: Optional[int] = None  # Unix timestamp in milliseconds
        due_date_time: Optional[bool] = False
        time_estimate: Optional[int] = None  # Time in milliseconds
        start_date: Optional[int] = None  # Unix timestamp in milliseconds
        start_date_time: Optional[bool] = False
        notify_all: Optional[bool] = True
        parent: Optional[str] = None
        links_to: Optional[str] = None
        custom_fields: Optional[ListType[Dict[str, Any]]] = None

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/DiversioTeam/clickup-mcp'

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