Xano Backend Configuration Protocol (BCP) Handler

This implementation establishes a Model Context Protocol (MCP) endpoint specifically designed to interface with Xano's underlying metadata API. It enables intelligent agents (such as Claude or assistants within Cursor) to perform sophisticated structural and documentation operations on a connected Xano workspace.

Core Capabilities

• Data Structure Control: Full CRUD operations on database tables.
• Schema Engineering: Granular control over column definitions, types, and relational structures within tables.
• Workspace Administration: A holistic toolkit for managing the database topology.
• Specification Export: Ability to pull API endpoint definitions into standard JSON (full fidelity) or token-optimized Markdown representations.

Feedback and feature requests for this initial release are highly encouraged.

Prerequisites for Deployment

• A functioning Node.js runtime (version 16 or newer).
• A compatible package manager (npm, yarn, etc.).
• Valid authentication credentials for the target Xano account.
• An MCP-enabled client application (e.g., Cursor, Claude Desktop).

Setup Procedure

1. Repository Acquisition: bash git clone https://github.com/lowcodelocky2/xano-mcp.git cd xano-mcp

2. Dependency Installation: bash npm install

3. Credential Configuration: Modify index.ts to set the required environment variables:

   • XANO_API_KEY: Authentication token.
   • XANO_WORKSPACE: The workspace identifier.
   • XANO_API_BASE: The base URL for the metadata API endpoint (e.g., https://your-instance.xano.io/api:meta).

4. Compilation: bash npm run build

Client Integration Guides

For Claude Desktop Users

Refer to the official MCP quickstart: https://modelcontextprotocol.io/quickstart/user

Configure your client settings with the following structure, adjusting the path:

{ "mcpServers": { "xano-admin": { "command": "node", "args": [ "/absolute/path/to/xano-mcp/index.js" ] } } }

Crucial Note: This server is functional only within the native desktop client, not the web interface (https://claude.ai/download).

For Cursor Users

1. Launch Cursor.
2. Select the option to 'Add MCP Server'.
3. Configure as follows:
   • Name: A descriptive alias (e.g., xano-backend-manager).
   • Type: command.
   • Command: node /absolute/path/to/xano-mcp/build/index.js

Use the pwd command in your terminal to easily ascertain the required absolute path.

Xano MCP Toolset Reference

This integration provides a comprehensive set of tools for managing your Xano workspace through the Model Context Protocol (MCP). Here's what you can do:

Database Structure Management

Table Operations

• Retrieve a manifest of all existing workspace tables.
• Inspect the granular structure (schema) of any table.
• Provision new tables complete with specified initial column definitions.
• Orchestrate the permanent removal of tables.
• Execute fine-grained schema modifications (column addition, removal, renaming).

Schema Refinement

• Introduce new attributes (columns), supporting diverse data types.
• Deprecate existing attributes.
• Apply attribute renaming operations.
• Facilitate wholesale replacement of a table's complete definition.
• Support for advanced structures and inter-table linkages.

API Endpoint Governance

API Group Control

• Instantiate new API grouping containers.
• List existing API groups.
• Navigate and query the endpoints contained within groups.
• Toggle Swagger/OpenAPI documentation generation status.
• Manage group metadata (e.g., descriptive tags, branch context).

Endpoint Configuration

• Register new individual API definitions within groups.
• Define supported HTTP verbs (GET, POST, PUT, DELETE, PATCH, HEAD).
• Configure endpoint-level descriptive documentation.
• Set associated metadata, such as tags and descriptive text.

Specification Generation

• Compile API Group specifications into markdown (for brevity) or JSON (for full detail).
• Examine generated Swagger documentation output.
• Access deep-dive structural information.

This toolset enables complete management of your Xano workspace, allowing you to build and maintain your backend infrastructure programmatically through the MCP interface.

Restoring the Table Deletion Functionality

To reactivate the delete-table capability within this codebase, execute the following targeted edits:

1. Navigate to the primary source file: src/index.ts.
2. Locate the section demarcated for the delete tool, which currently resembles: typescript // Delete Table Tool /* server.tool(

and concludes near: typescript ); */

1. To activate the tool, you must neutralize the block comment markers:

   • Erase the opening /* immediately following the "Delete Table Tool" heading.
   • Erase the closing */ preceding the "Edit Table Schema Tool" section.

   This simple textual modification enables the latent tool definition. A rebuild is mandatory afterward.

Post-Modification Code Example

typescript // Delete Table Tool server.tool( "delete-table", "Delete a table from the Xano workspace", { table_id: z.string().describe("ID of the table to delete") }, async ({ table_id }) => { // ... implementation logic resides here } );

Finalization Steps

1. Commit the file save.
2. Recompile the project: npm run build.
3. Refresh or restart your MCP client (Claude / Cursor).
4. The permanent table removal operation will now be accessible.

Critical Caution

Utilizing the delete-table function results in irreversible loss of workspace data. Ensure all critical information is backed up before invoking this powerful command.

Background Context: XMLHttpRequest

XMLHttpRequest (XHR) defines a JavaScript object API facilitating the transmission of HTTP requests from a web browser to a remote server. Its methods permit web-based applications to initiate server communications asynchronously, even after the initial page load, and receive subsequent data. XHR is the fundamental technology underpinning Asynchronous JavaScript and XML (Ajax). Before Ajax, interactivity was primarily managed via traditional hyperlink navigation or form submissions, actions that typically necessitated a full page reload.

== Genesis == The conceptual basis for XHR originated in 2000, conceived by Microsoft Outlook's development team. This concept was first actualized within Internet Explorer 5 (1999). However, the initial implementation did not use the standardized XMLHttpRequest name; instead, it relied on COM object instantiation via ActiveXObject("Msxml2.XMLHTTP") or ActiveXObject("Microsoft.XMLHTTP"). By the release of Internet Explorer 7 (2006), all contemporary browsers had adopted the unified XMLHttpRequest identifier. This identifier has since become the universal standard across major browser engines, including Mozilla's Gecko (2002), Safari 1.2 (2004), and Opera 8.0 (2005).

=== Standardization Trajectory === The World Wide Web Consortium (W3C) published its first formal Working Draft specification for the XMLHttpRequest object on April 5, 2006. A Level 2 specification followed on February 25, 2008, introducing features like progress monitoring, support for cross-site requests, and binary stream handling. By the close of 2011, the enhancements of Level 2 were integrated back into the primary specification. In late 2012, development responsibility transferred to the WHATWG, which now maintains the living document using Web IDL definitions.

== Operational Workflow == Sending a request using XMLHttpRequest generally involves a defined sequence of programming steps:

1. Instantiate the core XHR object via its constructor.
2. Invoke the open() method to define the request modality (e.g., GET/POST), specify the target Uniform Resource Identifier (URI), and set the operational mode (synchronous or asynchronous).
3. For asynchronous operations, register an event listener to handle subsequent state changes.
4. Commence the transmission by executing the send() method.
5. Monitor state transitions within the registered event handler. Upon successful server response, the data is typically available in the responseText property. Completion is signaled when the state transitions to 4 (the "done" state).

Beyond these fundamentals, XHR offers extensive control over transmission parameters. Custom headers can be injected to guide server behavior. Data can be uploaded synchronously with the send() call. Responses can be automatically parsed from raw text into structured JavaScript objects (like JSON), or streamed incrementally instead of waiting for full reception. Furthermore, requests can be terminated prematurely or assigned timeout constraints.

== Inter-Domain Communication ==

Early in the World Wide Web's evolution, security models recognized the inherent risks associated with unconstrained communication betwee