Introduction

The Atris MCP server provides extensive access to the Audius decentralized music ecosystem via structured protocol calls. This tool facilitates data analysis of music trends, user behavior, and content performance, mirroring the goal of data analysis to derive actionable information from complex datasets. It supports roughly 95% of the Audius Protocol API functionality using 105 distinct tools.

Note: Versions 2.0.0 and later exclusively utilize STDIO for all inter-process communication. The operating server adheres to Model Context Protocol specification version 2025-06-18. This value is exported as LATEST_PROTOCOL_VERSION within the src/config.ts file.

Core Capabilities Overview

This server exposes tools enabling comprehensive interaction with music data and platform functions. It covers track exploration, user relationship mapping, content uploading, and financial transaction insights.

Essential Features

Resource Access: Interface with track, user, playlist, and album data as standardized resources.
Media Operations: Permit downloading tracks and inspecting underlying technical attributes, including access to audio stems.
Discovery Engines: Access personalized suggestions, user consumption histories, and currently trending content categorized by genre.
Social Mapping: Identify users who have purchased content, created remixes, or follow related artists.
Streaming Facilitation: Offer direct track streaming to a client or provide links to open content within the native Audius Desktop application.
Creator Functions: Support the uploading of new material, playlist construction, and management of existing content.
Community Engagement: Allow for following users, marking tracks as favorites, and posting comments.
Monetization Pathways: Provide visibility into premium content access, track purchasing options, and direct artist tipping mechanisms.
Performance Metrics: Facilitate the tracking of play counts, trending status, and detailed listener insights.
Guided Prompts: Implement curated interactions for music discovery, content curation workflows, and detailed data analysis tasks.

Natural Language Interaction Examples

Utilizing the Atris MCP, LLMs can interpret user requests expressed in common language concerning Audius content. These examples illustrate the range of queries supported:

Music Discovery

"Identify electronic compositions possessing a high beats-per-minute rating."
"Which tracks are currently trending within the hip-hop category this week?"
"Suggest creators whose work closely resembles that of [artist name] here."
"Assist in finding emerging creators active in the jazz domain."
"Locate music suitable for meditation playlists exhibiting a relaxing auditory mood."

Artist Information

"Provide a comprehensive summary regarding the creator known as [name] now."
"Who constitutes the most engaged follower base for [artist]?"
"List the most recent musical pieces published by [artist] recently."
"Display the performance analytics associated with [artist]'s most successful tracks."
"Which musical figures exhibit creative overlap with [artist name]?"

Playlist Management

"Formulate a new playlist comprised exclusively of upbeat electronic selections."
"Integrate the leading trending hip-hop tracks into my existing workout compilation."
"Exclude the musical piece titled [title] from the collection named [name] now."
"Restructure my existing compilation to ensure superior auditory flow."
"Offer assistance in curating a suitable music compilation for an upcoming social gathering."

Track Analysis

"Examine the listener demographic data associated with [track] specifically."
"Who represents the most dedicated supporters of this particular [track]?"
"Contrast the current performance metrics of [track] against others in its assigned category."
"What has been the listening trend trajectory for [track] over the last thirty days?"
"Show the relevant engagement indicators recorded for [track] presently."

Content Monetization

"Configure the necessary NFT access controls for my newly uploaded track now."
"What recommended pricing structure should I assign to my premium offerings?"
"Review my record of tips sent and associated statistical reports."
"Analyze my derived revenue streams across the entire platform distribution."
"Clarify the available purchasing methods associated with [content] clearly."

"Identify platform users who consistently interact with my released music."
"Display the recent user commentary posted concerning my newest track publicly."
"Help me draft a professional outreach message to initiate collaboration with [artist]."
"Whom should I begin following to expand my professional presence within the [genre] community?"
"Assess my overall social interaction effectiveness and propose refinement strategies."
"Discover the most supportive fans who have provided financial tips to me."
"Review my historical notification log and assign priority levels to pending items."

Workflow Automation & Creative Assistance

"Develop a preliminary marketing schedule for my forthcoming track release event."
"Establish an automated system for weekly playlist updates based on personal consumption patterns."
"Schedule announcements for new content releases to maximize user engagement timings."
"Generate descriptive keyword tags appropriate for my recently produced ambient musical piece."
"Perform a comparative assessment of my genre tagging against stylistically similar creators."
"Suggest a dynamic pricing model derived from my existing catalog's performance history."
"Assist in formulating a compelling artist biography suitable for my profile section."

Prerequisites for Operation

Before implementation, ensure the following requirements are met by the operating environment:

Node.js environment must be version 16 or a newer iteration.
Possession of an active Audius API credential set is optional but highly advised for stable production operations.

Installation Procedures

NPM Installation (Recommended Approach)

Install the package directly from the public npm registry as follows:

npm install audius-mcp-atris

Alternatively, use the yarn package manager instead:

yarn add audius-mcp-atris

Manual Repository Installation

Obtain the source code repository via Git clone operation:

git clone https://github.com/glassBead/audius-mcp-atris.git
cd audius-mcp-atris

Install all necessary project dependencies:

npm install

Compile the underlying TypeScript source code into executable JavaScript:

npm run build

Configuration Settings

Establish a configuration file named .env within the primary directory, referencing the provided .env.example structure for guidance:

# Audius API Credentials
AUDIUS_API_KEY=your_api_key_here
AUDIUS_API_SECRET=your_api_secret_here
AUDIUS_ENVIRONMENT=production # Acceptable values include staging or development

# MCP Server Parameters
SERVER_NAME=audius-mcp
SERVER_VERSION=2.4.0
AUDIO_STREAMING=false

Execution Methods

Initiating the Server Process

Execute the primary startup command:

npm start

To launch the server with automatic code monitoring and rebuilding for development purposes:

npm run dev

Integration with Claude Interfaces

To integrate this server instance when utilizing Claude applications, follow these steps for connection:

Obtain and install Claude for Desktop or use the Claude CLI utility.

NPX Integration (Simplest Method)

Using npx offers the most straightforward method, permitting execution without a permanent global installation:

For Claude CLI Users:

Invoke the following command to register the toolchain:

claude mcp add audius npx audius-mcp-atris

For Claude Desktop Users:

Modify the configuration file specific to your operating system location. On macOS, this is typically ~/Library/Application Support/Claude/claude_mcp_config.json. On Windows, check %APPDATA%\Claude\claude_mcp_config.json. On Linux, use ~/.config/Claude/claude_mcp_config.json.

Insert the following structure into the mcpServers object within that file:

{
  "mcpServers": {
    "audius": {
      "command": "npx",
      "args": [
        "audius-mcp-atris"
      ],
      "env": {
        "AUDIUS_API_KEY": "your_api_key_here",
        "AUDIUS_API_SECRET": "your_api_secret_here"
      }
    }
  }
}

For Other LLM Environments Utilizing MCP:

If your LLM application supports the Model Context Protocol configuration format directly, utilize this structure within its associated configuration mechanism:

{
  "audius": {
    "command": "npx",
    "args": [
      "audius-mcp-atris"
    ],
    "env": {
      "AUDIUS_API_KEY": "your_api_key_here",
      "AUDIUS_API_SECRET": "your_api_secret_here"
    }
  }
}

Local Installation Connection Method

If you opt for a persistent, globally installed package:

# Install the package globally across the system
npm install -g audius-mcp-atris

# Register with Claude CLI using the global path
claude mcp add audius audius-mcp-atris

# Or for Claude Desktop configuration, utilize this structure instead:
{
  "mcpServers": {
    "audius": {
      "command": "audius-mcp-atris",
      "env": {
        "AUDIUS_API_KEY": "your_api_key_here",
        "AUDIUS_API_SECRET": "your_api_secret_here"
      }
    }
  }
}

Tool Catalog

This operational server exposes the following categories of functionality:

Discovery Toolset

Search: Perform general lookups for tracks, users, and playlists incorporating various filtering parameters.
Advanced Search: Execute searches enriched with specific genre, mood identifiers, BPM ranges, and other attributes.
Trending Discovery: Retrieve lists of currently popular or lesser-known tracks within the network.
Similar Artists: Identify creators whose musical output closely aligns with specified existing artists.

Track Utility Functions

Get Track Info: Retrieve detailed metadata for a specific track identified by its unique ID.
Search Tracks: Locate tracks effectively using layered filtering criteria.
Trending Tracks: Obtain the most actively played tracks on the platform at present.
Track Comments: View existing dialogue or append new comments associated with specific tracks.
Track Analytics: Access metrics including play volume, trending velocity, and audience insight reports.

User Management Tools

User Profiles: Fetch comprehensive profile details belonging to any registered user.
User Tracks: List all musical pieces uploaded by a designated platform user.
Follow User: Initiate a follow relationship directed toward another user entity.
User Analytics: Monitor play statistics, identify major supporters, and review aggregated user data.

Content Creation Functions

Upload Track: Submit a new musical composition to the Audius network.
Update Track: Modify metadata associated with an already published track.
Create Playlist: Form a new curated collection of musical works.
Playlist Management: Add, remove, or dynamically alter the sequence of tracks within collections.

Follow Artists: Establish connections with preferred music creators.
Favorite Tracks: Mark desired musical pieces for quick future reference and appreciation.
Comments: Input textual feedback directly onto tracks.
Reposts: View which users have shared specific content within their network.
Messaging: Facilitate the sending and receiving of direct personal communications.

Monetization Capabilities

Premium Content: Check availability and initiate purchases for exclusive, gated material.
NFT-Gated Content: Verify access rights dependent upon verified Non-Fungible Token ownership.
Purchase Tracks: Execute transactions to acquire premium content using varied payment methods.
Send Tips: Transfer value directly to artists as financial appreciation.
Track Transactions: Review the history and statistical overview of all monetary transfers related to a track.

Blockchain & Wallet Operations

Wallet Management: Handle setup and maintenance for associated Ethereum and Solana wallets.
Token Balances: Query the current holdings of various cryptocurrencies.
Transactions: Inspect past activity and authorize new cryptocurrency transfers.
Rewards: Access information related to platform incentives and ongoing incentive programs.

Data Resource Locators

Platform data entities can be referenced using these standardized Uniform Resource Identifiers (URIs):

audius://track/{id}: Links to detailed track specifications identified by its unique sequence number.
audius://user/{id}: Directs to the specific user profile page corresponding to the identifier.
audius://playlist/{id}: Accesses the full details of a collection identified by its ID.
audius://album/{id}: Points toward the descriptive information associated with a specific album grouping.

Guided Prompt Sequences

This service offers structured interaction models for routine music-centric workflows:

Music Discovery: Receive tailored recommendations based on specified user preferences.
Track Analysis: Execute deep inspection of track attributes and derive contextual insights.
Artist Profiles: Generate comprehensive, structured summaries of creator activity.
Music Creation: Receive assistance during the process of track composition and subsequent publication.
Playlist Curation: Support creation workflows and strategies for promoting assembled collections.
Messaging: Provide guidance for executing effective user-to-user communications.
Analytics: Generate standardized reports summarizing content performance metrics.
Blockchain: Offer assistance navigating cryptocurrency interactions and token operations.
Monetization: Guide setup processes for premium offerings and transaction handling.
Notifications: Aid in organizing and prioritizing incoming system alerts.

Development Structure

Source Code Organization

The internal structure of the project is organized logically:

├── src/
│   ├── index.ts          # Primary execution entry point for the server
│   ├── server.ts         # Initialization and configuration logic for the MCP server
│   ├── config.ts         # Module handling environmental and runtime configuration variables
│   ├── sdk-client.ts     # Wrapper module interfacing with the core Audius SDK/API client
│   ├── tools/            # Directory housing all implemented MCP tool functions
│   │   ├── tracks.ts               # Tools focused on individual track operations and retrieval
│   │   ├── users.ts                # Tools dedicated to user entity interaction and querying
│   │   ├── playlists.ts            # Tools managing playlist access and structure definitions
│   │   ├── search.ts               # Tools responsible for broad and filtered searching operations
│   │   ├── social.ts               # Tools managing user connections and network interactions
│   │   ├── comments.ts             # Tools for reading and writing user comments
│   │   ├── track-management.ts     # Tools for content submission and metadata updates
│   │   ├── playlist-management.ts  # Tools for playlist creation and manipulation functions
│   │   ├── messaging.ts            # Tools enabling direct message exchange between users
│   │   ├── analytics.ts            # Tools for accessing and summarizing performance data
│   │   ├── blockchain.ts           # Tools interfacing with associated ledger activities
│   │   ├── monetization.ts         # Tools for handling premium sales and tipping mechanisms
│   │   └── notifications.ts        # Tools for managing user-facing alerts and messages
│   ├── resources/        # Definitions for structured MCP resource representations
│   │   ├── tracks.ts     # Resource schema for track data objects
│   │   ├── users.ts      # Resource schema for user profile data objects
│   │   └── playlists.ts  # Resource schema for playlist collection data objects
│   └── prompts/          # Implementations for guided conversational workflows
│       ├── music-search.ts      # Prompts focused on music finding scenarios
│       ├── track-info.ts        # Prompts designed for deep track characteristic analysis
│       ├── artist-profile.ts    # Prompts for generating holistic creator summaries
│       ├── music-creation.ts    # Prompts assisting with content production stages
│       ├── playlist-creation.ts # Prompts supporting the organization of track compilations
│       ├── messaging.ts         # Prompts guiding user communication tasks
│       ├── analytics.ts         # Prompts used to structure performance reporting requests
│       ├── blockchain.ts        # Prompts for cryptocurrency operations assistance
│       ├── monetization.ts      # Prompts focused on revenue generation guidance
│       └── notifications.ts     # Prompts for organizing system alerts and interactions

Illustrative Workflow Commands

Music Discovery Examples

// Initiate a search targeting electronic music
search-tracks --query "electronic" --limit 5

// Retrieve the top ten most popular tracks within the specified genre
get-trending-tracks --genre "House" --limit 10

// Find musical creators whose styles resemble a reference user ID
similar-artists --userId "123456"

Content Creation Examples

// Submit a fresh musical composition to the network platform
upload-track --userId "123" --title "Summer Vibes" --genre "Electronic" --audioFileUrl "https://example.com/track.mp3"

// Generate a new grouping of tracks for sharing purposes
create-playlist --userId "123" --playlistName "Chillout Mix" --description "Perfect for relaxing"

// Incorporate several specific tracks into an existing collection
add-tracks-to-playlist --userId "123" --playlistId "456" --trackIds ["789", "101", "102"]

// Formally follow another registered user account
follow-user --userId "123" --followeeId "456"

// Designate a specific track as a personal favorite for later access
favorite-track --userId "123" --trackId "789"

// Post a public message or remark on a musical piece
add-track-comment --trackId "789" --userId "123" --comment "Great track!"

Monetization Examples

// Query the access restrictions applied to a specific track ID
track-access-gates --trackId "789"

// Review the listed purchase methods available for a piece of content
purchase-options --contentId "789" --contentType "track"

// Execute the purchase of a track using specified payment details
purchase-track --contentId "789" --walletAddress "0x123..." --purchaseOption "option1" --paymentToken "USDC" --amount "4.99" --signerPrivateKey "privateKey"

Validation and Testing

For development purposes involving local testing, the following steps are recommended:

Install the dedicated MCP Inspector tool globally via npm:

npm install -g @modelcontextprotocol/inspector

Execute the inspector tool, pointing it toward the compiled entry point of this server:

npx @modelcontextprotocol/inspector node ./build/index.js

This toolset relates to several key concepts in the data and decentralized web space:

Exploratory Data Analysis (EDA): Techniques for initial data inspection to find structure and anomalies.
Decentralized Autonomous Organizations (DAO): Structures underpinning platforms like Audius.
Data Mining: Using statistical models to discover hidden predictive knowledge from large datasets.
Business Intelligence (BI): Aggregated data analysis focusing on historical performance for organizational insight.
Text Analytics: Specialized statistical methods applied to unstructured textual data sources.

Extra Details

While marketing sections and general feature lists were condensed, the core functionality remains accessible via the detailed tool catalog above. For instance, the rich set of monetization tools directly supports the predictive analytics aspect of data analysis by tracking revenue streams—a crucial metric for creators seeking to make data-informed decisions about their artistic output.

Conclusion

This Atris server effectively structures access to complex music platform data, enabling analytical queries essential for effective music discovery and creator management. By translating complex API interactions into understandable protocol calls, it supports decision-making processes, much like the goal of data analysis is to transform raw information into actionable intelligence within the digital music domain.

License

This project is distributed under the terms of the MIT License.

Atris Protocol Interface for Decentralized Music Data

Author

glassBead-tc

Quick Info

Actions

Tags