Skip to main content
Glama

update_document

Modify existing documents in Frappe by specifying the document type, name, and field values to update.

Instructions

    Update an existing document in Frappe.
    
    Args:
        doctype: DocType name
        name: Document name (case-sensitive)
        values: Field values to update
    

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
doctypeYes
nameYes
valuesYes

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • The handler function decorated with @mcp.tool() that implements the core logic for updating a Frappe document via REST API PUT request to /api/resource/{doctype}/{name}, handling success response and errors.
    @mcp.tool()
    async def update_document(
        doctype: str,
        name: str,
        values: Dict[str, Any]
    ) -> str:
        """
        Update an existing document in Frappe.
        
        Args:
            doctype: DocType name
            name: Document name (case-sensitive)
            values: Field values to update
        """
        try:
            client = get_client()
            
            # Make API request to update document
            response = await client.put(
                f"api/resource/{doctype}/{name}",
                json_data=values
            )
            
            if "data" in response:
                doc = response["data"]
                return f"Document updated successfully: {doctype} '{doc.get('name', name)}'"
            else:
                return json.dumps(response, indent=2)
                
        except Exception as error:
            return _format_error_response(error, "update_document")
  • src/server.py:40-40 (registration)
    Top-level registration call in the MCP server setup that invokes the register_tools function from the documents module, which defines and registers the update_document tool among others.
    documents.register_tools(mcp)
  • The @mcp.tool() decorator directly above the update_document function handler, which registers it as an MCP tool within the documents.register_tools(mcp) function.
    @mcp.tool()
  • Helper function used by update_document (and other tools) to format error responses with credential checks and diagnostic information.
    def _format_error_response(error: Exception, operation: str) -> str:
        """Format error response with detailed information."""
        credentials_check = validate_api_credentials()
        
        # Build diagnostic information
        diagnostics = [
            f"Error in {operation}",
            f"Error type: {type(error).__name__}",
            f"Is FrappeApiError: {isinstance(error, FrappeApiError)}",
            f"API Key available: {credentials_check['details']['api_key_available']}",
            f"API Secret available: {credentials_check['details']['api_secret_available']}"
        ]
        
        # Check for missing credentials first
        if not credentials_check["valid"]:
            error_msg = f"Authentication failed: {credentials_check['message']}. "
            error_msg += "API key/secret is the only supported authentication method."
            return error_msg
        
        # Handle FrappeApiError
        if isinstance(error, FrappeApiError):
            error_msg = f"Frappe API error: {error}"
            if error.status_code in (401, 403):
                error_msg += " Please check your API key and secret."
            return error_msg
        
        # Default error handling
        return f"Error in {operation}: {str(error)}"
Behavior2/5

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an update operation but doesn't mention permission requirements, whether it's idempotent, what happens on validation errors, or what the response contains. For a mutation tool with zero annotation coverage, this is insufficient.

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?

The description is appropriately concise with a clear purpose statement followed by parameter explanations. The Args section is well-structured but could be more front-loaded with critical usage information. No wasted sentences, though it could be more complete.

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 this is a mutation tool with no annotations, 3 parameters with 0% schema coverage, but with an output schema present, the description provides basic parameter semantics but lacks critical behavioral context. The output schema reduces the need to describe return values, but permission requirements, error handling, and sibling differentiation remain gaps.

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

Parameters3/5

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

Schema description coverage is 0%, so the schema provides no parameter documentation. The description adds basic semantic meaning for all three parameters (doctype, name, values), explaining what each represents. However, it doesn't provide format examples, constraints, or relationship details needed for effective use.

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 'an existing document in Frappe', making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'amend_document' or 'submit_document', which appear to be related document modification 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 like 'amend_document', 'submit_document', or 'create_document'. It doesn't mention prerequisites, constraints, or typical use cases, leaving the agent to guess based on tool names alone.

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/appliedrelevance/frappe-mcp-server'

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