Skip to main content
Glama
robertZaufall

MindManager MCP Server

create_mindmap_from_mermaid_simple

Convert Mermaid mindmap text to a MindManager mindmap using simplified syntax. Deserializes Mermaid diagrams for visual mind mapping.

Instructions

Deserializes a Mermaid mindmap in simplified syntax and creates a MindManager mindmap from it.

Args:
    mermaid (str): Mermaid text describing the desired mindmap.
    turbo_mode (bool): Enable turbo mode (text-only operations). Defaults to True.

Returns:
    Dict[str, str]: Status dictionary indicating success or error details.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
mermaidYes
turbo_modeNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • The primary handler for the 'create_mindmap_from_mermaid_simple' tool. It validates input, calls the helper to deserialize and create the mindmap, handles errors, and returns status.
    @mcp.tool()
    async def create_mindmap_from_mermaid_simple(
        mermaid: str,
        turbo_mode: bool = True
    ) -> Dict[str, str]:
        """
        Deserializes a Mermaid mindmap in simplified syntax and creates a MindManager mindmap from it.
    
        Args:
            mermaid (str): Mermaid text describing the desired mindmap.
            turbo_mode (bool): Enable turbo mode (text-only operations). Defaults to True.
    
        Returns:
            Dict[str, str]: Status dictionary indicating success or error details.
        """
        if not mermaid or not mermaid.strip():
            return {"error": "Invalid Input", "message": "Mermaid content is required."}
    
        try:
            print("Creating mindmap from Mermaid diagram (simple).", file=sys.stderr)
            _deserialize_mermaid_simple(mermaid=mermaid, turbo_mode=turbo_mode)
            print("Mindmap created from Mermaid diagram (simple).", file=sys.stderr)
            return {"status": "success", "message": "Mindmap created from Mermaid diagram (simple)."}
        except Exception as e:
            return _handle_mindmanager_error("create_mindmap_from_mermaid_simple", e)
  • Key helper function that performs the deserialization of simple Mermaid input into a MindmapDocument and creates the mindmap in MindManager.
    def _deserialize_mermaid_simple(mermaid="", turbo_mode=True):
        deserialized = serialization.deserialize_mermaid_simple(mermaid)
        document = _get_document_instance(turbo_mode=turbo_mode)
        document.mindmap = deserialized
        document.create_mindmap()
        return None
  • Helper function used by the tool handler to format and return MindManager-related errors in a standardized MCP response format.
    def _handle_mindmanager_error(func_name: str, e: Exception) -> Dict[str, str]:
        """Formats MindManager errors for MCP response."""
        error_message = f"Error during MindManager operation '{func_name}': {e}"
        print(f"ERROR: {error_message}", file=sys.stderr)
        # Check for specific known errors from mindm.mindmanager if possible
        if "No document found" in str(e):
            return {"error": "MindManager Error", "message": "No document found or MindManager not running."}
        # Add more specific error checks here based on mindm library
        return {"error": "MindManager Error", "message": f"An error occurred: {e}"}
  • The @mcp.tool() decorator registers this function as an MCP tool with the name 'create_mindmap_from_mermaid_simple' in FastMCP.
    @mcp.tool()
Behavior2/5

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

With no annotations provided, the description carries full burden but offers limited behavioral insight. It mentions 'turbo mode (text-only operations)', which hints at performance or mode differences, but does not disclose critical traits like permissions needed, side effects (e.g., file creation), error handling, or rate limits. For a tool that likely creates resources, this is insufficient transparency.

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 front-loaded with the core purpose in the first sentence, followed by structured sections for Args and Returns. Each sentence earns its place by defining parameters and output without redundancy. It is appropriately sized and well-organized for quick comprehension.

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?

Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is reasonably complete. It covers the purpose, parameters, and return type. The output schema exists, so detailed return values aren't needed. However, it lacks context on behavioral aspects like error cases or integration with siblings, leaving minor gaps.

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 description coverage is 0%, so the description must compensate. It adds meaningful context for both parameters: 'mermaid' is explained as 'Mermaid text describing the desired mindmap', and 'turbo_mode' is clarified as 'Enable turbo mode (text-only operations)' with a default. This provides semantic understanding beyond the bare schema, though it could detail Mermaid syntax or turbo mode implications further.

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?

The description clearly states the specific action ('Deserializes... and creates') and resource ('Mermaid mindmap... MindManager mindmap'), distinguishing it from siblings like 'create_mindmap_from_mermaid' by specifying 'simplified syntax'. It provides a precise verb+resource combination that differentiates its scope.

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 lacks explicit guidance on when to use this tool versus alternatives. While it implies usage for Mermaid mindmaps in simplified syntax, it does not specify when to choose this over 'create_mindmap_from_mermaid' or other serialization tools, nor does it mention prerequisites or exclusions. No contextual usage advice is provided.

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/robertZaufall/mindm-mcp'

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