Strudel MCP Server

Instructions

Implementation Reference

• src/server/EnhancedMCPServerFixed.ts:276-280 (registration)

  Tool registration definition for 'analyze_rhythm' in the getTools() array.

  {
    name: 'analyze_rhythm',
    description: 'Rhythm analysis',
    inputSchema: { type: 'object', properties: {} }
  },

• src/server/EnhancedMCPServerFixed.ts:963-972 (handler)

  MCP tool handler in executeTool switch statement (currently stubbed, calls analyzeAudio but returns placeholder).

  case 'analyze_rhythm':
    if (!this.isInitialized) {
      return 'Browser not initialized. Run init first.';
    }
    const analysis = await this.controller.analyzeAudio();
    return {
      isPlaying: analysis.features?.isPlaying,
      tempo: 'Analysis pending implementation',
      pattern: 'Rhythm pattern analysis'
    };

• src/AudioAnalyzer.ts:609-712 (handler)

  Core rhythm analysis implementation in AudioAnalyzer class, performing onset detection, complexity analysis, syncopation detection, etc.

  async analyzeRhythm(page: Page): Promise<RhythmAnalysis> {
    // Get analyzer object from browser
    const analyzer = await page.evaluate(() => {
      return (window as any).strudelAudioAnalyzer;
    });
  
    if (!analyzer || !analyzer.isConnected) {
      return {
        pattern: 'X...',
        complexity: 0,
        density: 0,
        syncopation: 0,
        onsets: [],
        isRegular: true
      };
    }
  
    let onsets: number[];
  
    // Check if this is a mock with pre-calculated onset times (for testing)
    if (typeof analyzer.analyze === 'function') {
      const analysis = analyzer.analyze();
      if (analysis?.features?.onsets) {
        onsets = analysis.features.onsets;
      } else if (analysis?.features?.onsetTimes) {
        onsets = analysis.features.onsetTimes;
      } else {
        // No mock data, use real-time detection
        const fftData = new Uint8Array(analyzer.dataArray);
        const flux = this.calculateSpectralFlux(fftData);
  
        if (flux > this.ONSET_THRESHOLD) {
          this._onsetHistory.push(Date.now());
          if (this._onsetHistory.length > this.MAX_HISTORY_LENGTH) {
            this._onsetHistory.shift();
          }
        }
  
        onsets = [...this._onsetHistory];
      }
    } else {
      // No analyze function, use real-time detection
      const fftData = new Uint8Array(analyzer.dataArray);
      const flux = this.calculateSpectralFlux(fftData);
  
      if (flux > this.ONSET_THRESHOLD) {
        this._onsetHistory.push(Date.now());
        if (this._onsetHistory.length > this.MAX_HISTORY_LENGTH) {
          this._onsetHistory.shift();
        }
      }
  
      onsets = [...this._onsetHistory];
    }
  
    // Need at least 2 onsets for rhythm analysis
    if (onsets.length < 2) {
      return {
        pattern: 'X...',
        complexity: 0,
        density: 0,
        syncopation: 0,
        onsets: [],
        isRegular: true
      };
    }
  
    // Calculate intervals
    const intervals = this.calculateIntervals(onsets);
  
    // Calculate density (events per second)
    const duration = (onsets[onsets.length - 1] - onsets[0]) / 1000;
    const density = duration > 0 ? (onsets.length - 1) / duration : 0;
  
    // Calculate complexity from interval variance
    const meanInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
    const variance = this.calculateVariance(intervals, meanInterval);
    const coefficientOfVariation = Math.sqrt(variance) / meanInterval;
  
    // Analyze subdivisions
    const subdivisionScore = this.analyzeSubdivisions(intervals);
  
    // Combine variance and subdivision complexity with higher sensitivity
    const varianceComponent = Math.min(1, coefficientOfVariation * 5);
    const complexity = Math.min(1, varianceComponent * 0.8 + subdivisionScore * 0.2);
  
    // Calculate syncopation (off-beat events)
    const syncopation = this.detectSyncopation(onsets, meanInterval);
  
    // Determine regularity
    const isRegular = coefficientOfVariation < 0.2;
  
    // Generate pattern string
    const pattern = this.generatePatternString(onsets, meanInterval);
  
    return {
      pattern,
      complexity,
      density,
      syncopation,
      onsets,
      isRegular
    };
  }

• src/types/AudioAnalysis.ts:18-25 (schema)

  TypeScript interface defining the RhythmAnalysis return type (schema).

  export interface RhythmAnalysis {
    pattern: string;
    complexity: number; // 0-1 scale
    density: number; // events per second
    syncopation: number; // 0-1 scale
    onsets: number[];
    isRegular: boolean;
  }

• src/AudioAnalyzer.ts:717-734 (helper)

  Helper function for subdivision complexity calculation used in analyzeRhythm.

  private analyzeSubdivisions(intervals: number[]): number {
    if (intervals.length === 0) return 0;
  
    const meanInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
  
    // Count how many different subdivision levels are present
    const subdivisions = new Set<number>();
  
    for (const interval of intervals) {
      const ratio = interval / meanInterval;
      // Quantize to common subdivisions (1, 0.5, 0.25, 0.75, 0.33, etc.)
      const quantized = Math.round(ratio * 8) / 8; // Higher resolution
      subdivisions.add(quantized);
    }
  
    // More subdivision levels = more complex (more aggressive scaling)
    return Math.min(1, subdivisions.size / 4);
  }