Skip to main content
Glama
hyunjae-labs

xlwings Excel MCP Server

delete_sheet_columns

Remove specified columns from an Excel worksheet to clean data or adjust spreadsheet structure. Specify sheet name, starting column, and number of columns to delete.

Instructions

Delete one or more columns starting at the specified column.

Args:
    sheet_name: Name of worksheet
    start_col: Column number to start deleting from
    session_id: Session ID from open_workbook (preferred)
    filepath: Path to Excel file (legacy, deprecated)
    count: Number of columns to delete
    
Note: Use session_id for better performance. filepath parameter is deprecated.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
sheet_nameYes
start_colYes
session_idNo
filepathNo
countNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • Registration of the delete_sheet_columns tool via @mcp.tool() decorator. Defines input schema through parameters and docstring. Dispatches to appropriate implementation based on session_id (preferred) or legacy filepath.
    @mcp.tool()
    def delete_sheet_columns(
        sheet_name: str,
        start_col: int,
        session_id: Optional[str] = None,
        filepath: Optional[str] = None,
        count: int = 1
    ) -> str:
        """
        Delete one or more columns starting at the specified column.
        
        Args:
            sheet_name: Name of worksheet
            start_col: Column number to start deleting from
            session_id: Session ID from open_workbook (preferred)
            filepath: Path to Excel file (legacy, deprecated)
            count: Number of columns to delete
            
        Note: Use session_id for better performance. filepath parameter is deprecated.
        """
        try:
            # Support both new (session_id) and old (filepath) API
            if session_id:
                # New API: use session
                session = SESSION_MANAGER.get_session(session_id)
                if not session:
                    return ERROR_TEMPLATES['SESSION_NOT_FOUND'].format(
                        session_id=session_id, 
                        ttl=10  # Default TTL is 10 minutes (600 seconds)
                    )
                
                with session.lock:
                    from xlwings_mcp.xlwings_impl.rows_cols_xlw import delete_sheet_columns_xlw_with_wb
                    result = delete_sheet_columns_xlw_with_wb(session.workbook, sheet_name, start_col, count)
            elif filepath:
                # Legacy API: backwards compatibility
                logger.warning("Using deprecated filepath parameter. Please use session_id instead.")
                full_path = get_excel_path(filepath)
                from xlwings_mcp.xlwings_impl.rows_cols_xlw import delete_sheet_columns_xlw
                result = delete_sheet_columns_xlw(full_path, sheet_name, start_col, count)
            else:
                return ERROR_TEMPLATES['PARAMETER_MISSING'].format(
                    param1='session_id',
                    param2='filepath'
                )
            
            if "error" in result:
                return f"Error: {result['error']}"
            return result["message"]
            
        except (ValidationError, SheetError) as e:
            return f"Error: {str(e)}"
        except Exception as e:
            logger.error(f"Error deleting columns: {e}")
            raise
  • Core handler implementation for filepath-based deletion of sheet columns using xlwings COM API. Handles file opening, sheet access, column letter conversion, deletion loop, saving, and cleanup.
    def delete_sheet_columns_xlw(
        filepath: str,
        sheet_name: str,
        start_col: int,
        count: int = 1
    ) -> Dict[str, Any]:
        """
        Delete one or more columns in Excel using xlwings.
        
        Args:
            filepath: Path to Excel file
            sheet_name: Name of worksheet
            start_col: Column number to start deletion (1-based)
            count: Number of columns to delete
            
        Returns:
            Dict with success message or error
        """
        app = None
        wb = None
    
        # Initialize COM for thread safety (Windows)
        _com_initialize()
    
        try:
            logger.info(f"Deleting {count} columns starting from column {start_col} in {sheet_name}")
            
            # Check if file exists
            if not os.path.exists(filepath):
                return {"error": f"File not found: {filepath}"}
            
            # Open Excel app and workbook
            app = xw.App(visible=False, add_book=False)
            wb = app.books.open(filepath)
            
            # Check if sheet exists
            sheet_names = [s.name for s in wb.sheets]
            if sheet_name not in sheet_names:
                return {"error": f"Sheet '{sheet_name}' not found"}
            
            sheet = wb.sheets[sheet_name]
            
            # Convert column number to letter
            def col_num_to_letter(n):
                string = ""
                while n > 0:
                    n, remainder = divmod(n - 1, 26)
                    string = chr(65 + remainder) + string
                return string
            
            col_letter = col_num_to_letter(start_col)
            
            # Delete columns using xlwings
            # Delete multiple times since we delete one at a time
            for i in range(count):
                col_to_delete = sheet.range(f"{col_letter}:{col_letter}")
                col_to_delete.api.Delete()
            
            # Save the workbook
            wb.save()
            
            logger.info(f"✅ Successfully deleted {count} columns starting from column {col_letter}")
            return {
                "message": f"Successfully deleted {count} columns starting from column {col_letter}",
                "sheet": sheet_name,
                "start_col": start_col,
                "count": count
            }
            
        except Exception as e:
            logger.error(f"Error deleting columns: {e}")
            return {"error": str(e)}
            
        finally:
            if wb:
                wb.close()
            if app:
                app.quit()
  • Session-based core handler for deleting sheet columns using existing workbook object. Used by the main tool when session_id is provided. Includes column letter conversion and deletion via xlwings API.
    def delete_sheet_columns_xlw_with_wb(
        wb,
        sheet_name: str,
        start_col: int,
        count: int = 1
    ) -> Dict[str, Any]:
        """Session-based version using existing workbook object.
        
        Args:
            wb: Workbook object from session
            sheet_name: Name of worksheet
            start_col: Column number to start deletion (1-based)
            count: Number of columns to delete
            
        Returns:
            Dict with success message or error
        """
        try:
            logger.info(f"🗑️ Deleting {count} columns starting from column {start_col} in {sheet_name}")
            
            # Check if sheet exists
            sheet_names = [s.name for s in wb.sheets]
            if sheet_name not in sheet_names:
                return {"error": f"Sheet '{sheet_name}' not found"}
            
            sheet = wb.sheets[sheet_name]
            
            # Convert column number to letter
            def col_num_to_letter(n):
                string = ""
                while n > 0:
                    n, remainder = divmod(n - 1, 26)
                    string = chr(65 + remainder) + string
                return string
            
            col_letter = col_num_to_letter(start_col)
            
            # Delete columns using xlwings
            # Delete multiple times since we delete one at a time
            for i in range(count):
                col_to_delete = sheet.range(f"{col_letter}:{col_letter}")
                col_to_delete.api.Delete()
            
            # Save the workbook
            wb.save()
            
            logger.info(f"✅ Successfully deleted {count} columns starting from column {col_letter}")
            return {
                "message": f"Successfully deleted {count} columns starting from column {col_letter}",
                "sheet": sheet_name,
                "start_col": start_col,
                "count": count
            }
            
        except Exception as e:
            logger.error(f"Error deleting columns: {e}")
            return {"error": str(e)}
  • Helper function to convert column number (1-based) to Excel column letter (A, B, ..., Z, AA, etc.). Used in both handler implementations.
    def col_num_to_letter(n):
        string = ""
        while n > 0:
            n, remainder = divmod(n - 1, 26)
            string = chr(65 + remainder) + string
        return string
Behavior3/5

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

With no annotations provided, the description carries full burden. It clearly indicates this is a destructive operation ('Delete'), mentions performance considerations, and notes deprecation, but doesn't disclose error conditions, permissions needed, or what happens to adjacent columns after deletion.

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 well-structured with a clear purpose statement followed by parameter explanations and usage notes. Every sentence adds value, though the parameter explanations could be slightly more concise.

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?

For a destructive operation with 5 parameters and no annotations, the description provides good coverage of purpose, parameters, and basic usage guidance. The existence of an output schema reduces the need to describe return values, but more behavioral context about the deletion's effects would be helpful.

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

Parameters5/5

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

With 0% schema description coverage, the description fully compensates by explaining all 5 parameters in detail: sheet_name identifies the worksheet, start_col specifies where to begin deletion, session_id/filepath provide workbook access methods with performance/deprecation notes, and count determines how many columns to delete.

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 ('Delete one or more columns starting at the specified column'), identifies the resource (columns in a worksheet), and distinguishes from sibling tools like delete_sheet_rows and delete_range by specifying column deletion rather than row or range deletion.

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

Usage Guidelines4/5

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

The description provides explicit guidance on parameter usage (session_id preferred over deprecated filepath) and implies context through sibling tools like open_workbook, but doesn't specify when to use this tool versus alternatives like delete_range or delete_worksheet.

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/hyunjae-labs/xlwings-mcp-server'

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