AYX-MCP-Wrapper: Unofficial Alteryx Server Interface with MCP Multi

Ayx MCP Wrapper

AYX - MCP - Wrapper is an unofficial Alteryx server interface wrapper that provides comprehensive services based on the Model Context Protocol, supporting operations such as workflow management, collection management, user management, scheduled tasks, and credential management.

Developer tools Research and data #Workflow Management #User Management #Scheduled Tasks #Data Integration .Python

rating : 2.5 points

downloads : 2

update time : 2025-07-24

What is the Alteryx MCP Server?

The Alteryx MCP server is a Model Context Protocol (MCP) server that provides an interface for AI assistants and other MCP clients to interact with Alteryx Server. This server allows users to manage workflows, collections, users, schedules, and credentials, etc.

How to Use the Alteryx MCP Server?

By setting environment variables and running the MCP server, you can integrate it into tools such as Claude Desktop or Cursor IDE. You can also run the MCP server directly through the command line.

Application Scenarios

Suitable for application scenarios that require deep integration with Alteryx Server, such as automated workflow execution, data management, and user permission control, etc.

Main Features

Advanced SearchSupports searching for users, workflows, and assets by name, ID, or other attributes.

Workflow OperationsAllows executing, transferring, and managing workflows, providing comprehensive control over workflows.

Workflow AssetsSupports downloading workflow packages and extracting XML files for analysis.

Job MonitoringReal-time tracking and management of the status of workflow execution jobs.

Collection ManagementCreate, update, delete, and organize collections for easy resource management.

User ManagementManage users and their assets and permissions to ensure data security.

Schedule ManagementCreate and manage workflow schedules to achieve automated tasks.

Credential ManagementHandle server credentials and secure connections to ensure the security of data transmission.

Advantages and Limitations

Advantages

Provides seamless integration with Alteryx Server, simplifying data management and automated tasks.

Supports the integration of multiple client tools (such as Claude Desktop and Cursor).

Provides rich API functions to meet complex data processing requirements.

Easy to configure and deploy, suitable for enterprises of all sizes.

Limitations

Requires a certain technical background for configuration and maintenance.

Depends on the availability and stability of Alteryx Server.

Some functions may be complex for non-technical users.

Requires additional development work to fully utilize all its functions.

How to Use

Install the MCP Server

Install the MCP server using uv or pip.

Configure Environment Variables

Set environment variables such as the API address of the Alteryx server and OAuth2 credentials.

Run the MCP Server

Run the MCP server using uv and select an appropriate transport method (such as stdio, sse, or streamable-http).

Usage Examples

Automated Workflow ExecutionAutomatically execute workflows through the MCP server to improve data processing efficiency.

Manage User AssetsQuery and manage all user assets through the MCP server.

Monitor Job StatusMonitor the status of workflow execution jobs in real-time to detect problems in a timely manner.

Frequently Asked Questions

How to solve the authentication failure problem?

What should I do if the MCP server fails to start?

How to view the logs of the MCP server?

Which transport methods does the MCP server support?

Related Resources

Model Context Protocol (MCP)

Official documentation and specification of the MCP protocol.

Claude Desktop

The Claude Desktop application, which can be used to integrate the MCP server.

GitHub Project Repository

The GitHub source code repository for the Alteryx MCP server.

Alteryx Server Documentation

Official documentation for Alteryx Server to help you better understand its functions.

🚀 AYX-MCP-Wrapper

A Model Context Protocol (MCP) server that offers a comprehensive interface to Alteryx Servers, enabling AI assistants and other MCP clients to interact with Alteryx Server for managing workflows, collections, users, schedules, credentials, and more.

🚀 Quick Start

This AYX-MCP-Wrapper is a personal initiative that provides a Model Context Protocol (MCP) server for interacting with Alteryx Servers. Before using it, make sure you have met the prerequisites and completed the installation and configuration steps.

✨ Features

Advanced Search: Find users, workflows, and assets with flexible search options.
Workflow Operations: Execute, transfer, and manage workflows with full control.
Workflow Assets: Download workflow packages and extract XML for analysis.
Job Monitoring: Track and manage workflow execution jobs in real - time.
Collections Management: Create, update, delete, and organize collections.
User Management: Manage users, their assets, and permissions efficiently.
Schedule Management: Create and manage workflow schedules and automation.
Credential Management: Handle server credentials and secure connections.

📦 Installation

Quick Start with uv (Recommended)

# Install uv if you haven't already
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install the MCP server
uv pip install mcp-server-alteryx

Using pip

pip install mcp-server-alteryx

From Source

git clone https://github.com/jupiterbak/AYX-MCP-Wrapper.git
cd AYX-MCP-Wrapper
uv sync
uv run pip install -e .

⚠️ DISCLAIMER

This is NOT an official implementation.

This project is a personal initiative and is not affiliated with, endorsed by, or supported by any company. Even if the maintainer is an employee of a related company, this project is developed independently without any official backing or support.

📚 Documentation

Prerequisites

Python 3.10+: Modern Python with type hints support.
Alteryx Server: With API access enabled.
OAuth2 Credentials: Client ID and Secret for authentication.

Configuration

Environment Variables

Set up your Server credentials using environment variables:

# Required: Server API URL
export ALTERYX_API_HOST="https://your-server.com/webapi/"

# Required: OAuth2 Client Credentials
export ALTERYX_CLIENT_ID="your-client-id"
export ALTERYX_CLIENT_SECRET="your-client-secret"

# Optional: SSL Verification (default: true)
export ALTERYX_VERIFY_SSL="1"

# Optional: temporary folder
export ALTERYX_TEMP_DIRECTORY="your-temp-directory"

# Optional: Logging level
export LOG_LEVEL="INFO"

Configuration File

Alternatively, create a .env file in your project root:

ALTERYX_API_HOST=https://your-server.com/webapi/
ALTERYX_CLIENT_ID=your-client-id
ALTERYX_CLIENT_SECRET=your-client-secret
ALTERYX_VERIFY_SSL=1
ALTERYX_TEMP_DIRECTORY=your-temp-directory
LOG_LEVEL=INFO

Usage

Claude Desktop Integration

To use this MCP server with Claude Desktop, add the following configuration to your Claude Desktop settings:

{
  "mcpServers": {
    "alteryx": {
      "command": "uvx",
      "args": ["mcp-server-alteryx", "--transport", "stdio"],
      "env": {
        "ALTERYX_API_HOST": "https://your-server.com/webapi/",
        "ALTERYX_CLIENT_ID": "your-client-id",
        "ALTERYX_CLIENT_SECRET": "your-client-secret",
        "ALTERYX_VERIFY_SSL": "1",
        "ALTERYX_TEMP_DIRECTORY": "your-temp-directory"
      }
    }
  }
}

However, we recommend to use it in combination with the "Sequential Thinking" tool:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sequential-thinking"
      ]
    },
    "alteryx": {
      "command": "uvx",
      "args": ["mcp-server-alteryx", "--transport", "stdio"],
      "env": {
        "ALTERYX_API_HOST": "http://localhost/webapi/",
        "ALTERYX_CLIENT_ID": "your-client-id",
        "ALTERYX_CLIENT_SECRET": "your-client-secret",
        "ALTERYX_VERIFY_SSL": "1",
        "ALTERYX_TEMP_DIRECTORY": "your-temp-directory"
      }
    }
  }
}

Configuration Options:

command: The uvx executable to use.
args: Command line arguments for the MCP server.
env: Environment variables for Server authentication.

Transport Options:

stdio: Standard input/output (recommended for Claude Desktop).
sse: Server - Sent Events.
streamable-http: HTTP streaming.

Cursor Integration

For Cursor IDE integration, add to your Cursor settings:

{
  "mcpServers": {
    "alteryx": {
      "command": "uvx",
      "args": ["mcp-server-alteryx", "--transport", "stdio"],
      "env": {
        "ALTERYX_API_HOST": "https://your-alteryx-server.com/webapi/",
        "ALTERYX_CLIENT_ID": "your-client-id",
        "ALTERYX_CLIENT_SECRET": "your-client-secret",
        "ALTERYX_TEMP_DIRECTORY": "your-temp-directory"
      }
    }
  }
}

Command Line Interface

The MCP server can be run with different transport options:

# Using stdio transport (default)
uvx run src.main --transport stdio

# Using Server-Sent Events (SSE)
uvx run src.main --transport sse

# Using HTTP streaming
uvx run src.main --transport streamable-http

# Set log level
uvx run src.main --log-level DEBUG

# Run with custom configuration
uvx run src.main --transport stdio --log-level INFO

Available Tools

The MCP server provides comprehensive tools organized by functionality:

Collections Management

Function	Description	Parameters
`get_all_collections()`	Retrieve all accessible collections	None
`get_collection_by_id(collection_id)`	Get specific collection details	`collection_id: str`
`create_collection(name)`	Create a new collection	`name: str`
`update_collection_name_or_owner(collection_id, name, owner_id)`	Update collection properties	`collection_id: str, name: str, owner_id: str`
`add_workflow_to_collection(collection_id, workflow_id)`	Add workflow to collection	`collection_id: str, workflow_id: str`
`remove_workflow_from_collection(collection_id, workflow_id)`	Remove workflow from collection	`collection_id: str, workflow_id: str`
`add_schedule_to_collection(collection_id, schedule_id)`	Add schedule to collection	`collection_id: str, schedule_id: str`
`remove_schedule_from_collection(collection_id, schedule_id)`	Remove schedule from collection	`collection_id: str, schedule_id: str`
`delete_collection(collection_id)`	Delete a collection	`collection_id: str`

Workflow Operations

Function	Description	Parameters
`get_all_workflows()`	Retrieve all accessible workflows	None
`get_workflow_by_id(workflow_id)`	Get specific workflow details	`workflow_id: str`
`update_workflow_name_or_comment(workflow_id, name, comment)`	Update workflow properties	`workflow_id: str, name: str, comment: str`
`transfer_workflow(workflow_id, new_owner_id)`	Transfer workflow ownership	`workflow_id: str, new_owner_id: str`
`get_workflow_jobs(workflow_id)`	Get jobs for a workflow	`workflow_id: str`
`start_workflow_execution(workflow_id, input_data)`	Start workflow execution and return job ID	`workflow_id: str, input_data: List[InputData]`
`execute_workflow_with_monitoring(workflow_id, input_data)`	Execute workflow and monitor completion	`workflow_id: str, input_data: List[InputData]`
`download_workflow_package_file(workflow_id, output_directory)`	Download workflow package	`workflow_id: str, output_directory: str`
`get_workflow_xml(workflow_id)`	Extract workflow XML	`workflow_id: str`

User Management

Function	Description	Parameters
`get_all_users()`	Retrieve all accessible users	None
`get_user_by_id(user_id)`	Get specific user details	`user_id: str`
`get_user_by_email(email)`	Find user by email	`email: str`
`get_user_by_name(name)`	Find user by name	`name: str`
`get_user_by_first_name(first_name)`	Find user by first name	`first_name: str`
`get_all_user_assets(user_id)`	Get all assets owned by user	`user_id: str`
`get_user_assets_by_type(user_id, asset_type)`	Get specific asset types	`user_id: str, asset_type: str`
`update_user_details(user_id, first_name, last_name, email)`	Update user information	`user_id: str, first_name: str, last_name: str, email: str`
`transfer_all_assets(user_id, new_owner_id, transfer_workflows, transfer_schedules, transfer_collections)`	Transfer user assets	`user_id: str, new_owner_id: str, transfer_workflows: bool, transfer_schedules: bool, transfer_collections: bool`
`deactivate_user(user_id)`	Deactivate a user	`user_id: str`
`reset_user_password(user_id)`	Reset user password	`user_id: str`

Schedule Management

Function	Description	Parameters
`get_all_schedules()`	Retrieve all accessible schedules	None
`get_schedule_by_id(schedule_id)`	Get specific schedule details	`schedule_id: str`
`deactivate_schedule(schedule_id)`	Deactivate a schedule	`schedule_id: str`
`activate_schedule(schedule_id)`	Activate a schedule	`schedule_id: str`
`update_schedule_name_or_comment(schedule_id, name, comment)`	Update schedule properties	`schedule_id: str, name: str, comment: str`
`change_schedule_owner(schedule_id, new_owner_id)`	Change schedule ownership	`schedule_id: str, new_owner_id: str`

Job Monitoring

Function	Description	Parameters
`get_all_job_messages(job_id)`	Get messages for a specific job	`job_id: str`
`get_job_by_id(job_id)`	Get job details	`job_id: str`
`get_job_output_data(job_id)`	Get output data files from completed job	`job_id: str`

Credentials & Connections

Function	Description	Parameters
`get_all_credentials()`	Retrieve all accessible credentials	None
`get_credential_by_id(credential_id)`	Get specific credential details	`credential_id: str`
`lookup_connection(connection_id)`	Lookup DCM connection	`connection_id: str`
`get_connection_by_id(connection_id)`	Get connection details	`connection_id: str`

Development

Setup Development Environment

# Clone the repository
git clone https://github.com/jupiterbak/AYX-MCP-Wrapper.git
cd AYX-MCP-Wrapper

# Install dependencies
uv sync

# Install in development mode
uv run pip install -e .