Skip to main content
Glama

parse_task_list

Convert natural language task lists into structured todos with priority, timeframe, and energy levels for previewing before creation in Coach AI.

Instructions

Parse natural language task list into structured todos (does NOT create them).

Use this to preview what will be created before committing. Then use add_todo(todos_batch=...) to create them.

Or use brain_dump_tasks() for a one-step workflow.

Supports multiple formats:

  • Bullet points: "- Task 1"

  • Numbered lists: "1. Task 2"

  • Checkboxes: "[ ] Task 3"

  • Section headers: "Sprint work:\n- Task 4"

Smart extraction:

  • Priority: "#high", "URGENT:", "!!"

  • Timeframe: "this week", "(this month)", "someday"

  • Time: "(30min)", "~2h"

  • Energy: "[high energy]", "[low effort]"

  • Theme: "#sprint", "@admin"

Args: text: Natural language task list default_priority: Default priority for tasks default_timeframe: Default timeframe for tasks

Returns: JSON string of parsed todos

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
textYes
default_priorityNomedium
default_timeframeNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • The parse_task_list tool is implemented as an async function in server.py, decorated with @mcp.tool(). It uses the parse_natural_language_task_list helper function to parse the text.
    @mcp.tool()
    async def parse_task_list(
        text: str,
        default_priority: str = "medium",
        default_timeframe: Optional[str] = None,
    ) -> str:
        """Parse natural language task list into structured todos (does NOT create them).
    
        Use this to preview what will be created before committing.
        Then use add_todo(todos_batch=...) to create them.
    
        Or use brain_dump_tasks() for a one-step workflow.
    
        Supports multiple formats:
        - Bullet points: "- Task 1"
        - Numbered lists: "1. Task 2"
        - Checkboxes: "[ ] Task 3"
        - Section headers: "Sprint work:\\n- Task 4"
    
        Smart extraction:
        - Priority: "#high", "URGENT:", "!!"
        - Timeframe: "this week", "(this month)", "someday"
        - Time: "(30min)", "~2h"
        - Energy: "[high energy]", "[low effort]"
        - Theme: "#sprint", "@admin"
    
        Args:
            text: Natural language task list
            default_priority: Default priority for tasks
            default_timeframe: Default timeframe for tasks
    
        Returns:
            JSON string of parsed todos
        """
        result = parse_natural_language_task_list(text, default_priority, default_timeframe)
    
        response = f"{result['parse_summary']}\n\n"
    
        if result['parsed_todos']:
            response += "Parsed todos (ready for add_todo batch mode):\n"
            response += json.dumps(result['parsed_todos'], indent=2)
    
        if result['unparseable_lines']:
            response += "\n\nCould not parse:\n"
            for line in result['unparseable_lines']:
                response += f"  - {line}\n"
    
        response += f"\n\nTo create these todos, use: add_todo(todos_batch='{json.dumps(result['parsed_todos'])}')"
    
        return response
Behavior4/5

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

No annotations provided, so description carries full burden. Discloses critical safety trait 'does NOT create them,' explains extraction capabilities (priority, timeframe, energy patterns), and specifies return type 'JSON string of parsed todos.' Could mention error handling for malformed input.

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

Conciseness4/5

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

Well-structured with clear sections (purpose, usage, formats, extraction, Args, Returns). Examples of supported formats are valuable and necessary for a parser tool. Slightly verbose but every sentence earns its place by clarifying extraction patterns or workflow context.

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

Completeness4/5

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

Despite having output schema, description appropriately explains return values given no annotations. Covers parsing behavior, workflow integration with sibling tools, and parameter semantics comprehensively. Minor gap: doesn't mention error cases or size limits for the text parameter.

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?

Schema coverage is 0% (no descriptions in schema), but tool description compensates by documenting all 3 parameters: 'text: Natural language task list,' 'default_priority: Default priority,' 'default_timeframe: Default timeframe.' Also enriches 'text' parameter with extensive format examples (bullet points, checkboxes, etc.).

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

Purpose5/5

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

States specific action 'Parse natural language task list into structured todos' and explicitly distinguishes from siblings with '(does NOT create them)', immediately clarifying it differs from add_todo and brain_dump_tasks.

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

Usage Guidelines5/5

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

Provides explicit workflow guidance: 'Use this to preview what will be created before committing,' names specific next step 'use add_todo(todos_batch=...) to create them,' and offers alternative 'use brain_dump_tasks() for a one-step workflow.'

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/94aharris/coach-ai'

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