@ray0404/zig-audio-mcp 0.1.0

package/src/index.ts

@@ -0,0 +1,1281 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+
+// Library information database
+const ZIG_AUDIO_LIBRARIES = {
+  zang: {
+    name: "zang",
+    description: "Audio synthesis library with generators, effects, and filters. Low-level, no dynamic allocations.",
+    repo: "https://github.com/dbandstra/zang",
+    license: "MIT",
+    features: ["oscillators", "envelopes", "filters", "effects", "no-allocations"],
+    categories: ["synthesis", "effects", "filters"],
+    installation: "git clone https://github.com/dbandstra/zang.git && cd zang && zig build",
+    version: "0.12+ compatible",
+    examples: ["SineOsc", "Envelope", "Filter", "Sampler"],
+    api_docs: "https://github.com/dbandstra/zang#features",
+    use_cases: ["Game audio", "Real-time synthesis", "Embedded audio"]
+  },
+  zaudio: {
+    name: "zaudio",
+    description: "Zig wrapper for miniaudio. Supports playback, recording, and node graph audio processing.",
+    repo: "https://github.com/MasterQ32/zaudio",
+    license: "MIT",
+    features: ["playback", "recording", "node-graph", "streaming"],
+    categories: ["playback", "recording", "wrapper"],
+    installation: "Add to build.zig.zon: .url = \"git+https://github.com/MasterQ32/zaudio#master\"",
+    version: "Zig 0.11+",
+    examples: ["Device playback", "Recording", "Node graphs"],
+    api_docs: "https://github.com/MasterQ32/zaudio",
+    use_cases: ["Desktop audio apps", "Cross-platform playback", "Audio processing pipelines"]
+  },
+  bonk: {
+    name: "bonk",
+    description: "DSP objects including filters and delay lines. MPL-2.0 licensed.",
+    repo: "https://github.com/chr15m/bonk",
+    license: "MPL-2.0",
+    features: ["filters", "delay-lines", "waveshapers"],
+    categories: ["dsp", "effects"],
+    installation: "Add to build.zig.zon: .url = \"git+https://github.com/chr15m/bonk#master\"",
+    version: "Zig 0.10+",
+    examples: ["IIR filters", "Delay effects", "Waveshaping"],
+    api_docs: "https://github.com/chr15m/bonk",
+    use_cases: ["Audio effects processing", "Real-time DSP", "Creative coding"]
+  },
+  pcm: {
+    name: "pcm",
+    description: "PCM audio file handling for WAV and AIFF formats.",
+    repo: "https://github.com/Hejsil/pcm",
+    license: "MIT",
+    features: ["wav", "aiff", "io", "encoding"],
+    categories: ["file-io", "encoding"],
+    installation: "Add to build.zig.zon: .url = \"git+https://github.com/Hejsil/pcm#master\"",
+    version: "Zig 0.9+",
+    examples: ["WAV reading/writing", "AIFF support", "Sample format conversion"],
+    api_docs: "https://github.com/Hejsil/pcm",
+    use_cases: ["Audio file processing", "Sample libraries", "Format conversion"]
+  },
+  "zig-liquid-dsp": {
+    name: "zig-liquid-dsp",
+    description: "DSP library for software-defined radio. Complex signal processing.",
+    repo: "https://github.com/ggerard/zig-liquid-dsp",
+    license: "MIT",
+    features: ["filters", "modulation", "fourier", "sdr"],
+    categories: ["sdr", "dsp"],
+    installation: "Add to build.zig.zon: .url = \"git+https://github.com/ggerard/zig-liquid-dsp#master\"",
+    version: "Zig 0.11+",
+    examples: ["FIR/IIR filters", "Modulation schemes", "FFT processing"],
+    api_docs: "https://github.com/ggerard/zig-liquid-dsp",
+    use_cases: ["SDR applications", "Signal analysis", "Communications"]
+  },
+  dalek: {
+    name: "dalek",
+    description: "Experimental data-oriented audio engine.",
+    repo: "https://github.com/chr15m/dalek",
+    license: "MIT",
+    features: ["data-oriented", "performance", "audio-engine"],
+    categories: ["engine", "experimental"],
+    installation: "Add to build.zig.zon: .url = \"git+https://github.com/chr15m/dalek#master\"",
+    version: "Zig 0.10+",
+    examples: ["Entity-component audio", "High-performance mixing", "Modular processing"],
+    api_docs: "https://github.com/chr15m/dalek",
+    use_cases: ["Game engines", "High-performance audio", "Large-scale audio processing"]
+  }
+};
+
+// Filter information for DSP explanations
+const DSP_FILTERS = {
+  lowpass: {
+    name: "Low Pass Filter",
+    description: "Allows frequencies below the cutoff to pass through, attenuating higher frequencies.",
+    formula: "y[n] = a0 * x[n] + a1 * x[n-1] + a2 * x[n-2] - b1 * y[n-1] - b2 * y[n-2]",
+    useCases: ["sub-bass smoothing", "removing high-frequency noise", "warmth/room modeling"],
+    zigLibraries: ["zang", "bonk", "zig-liquid-dsp"]
+  },
+  highpass: {
+    name: "High Pass Filter",
+    description: "Allows frequencies above the cutoff to pass through, attenuating lower frequencies.",
+    formula: "y[n] = a0 * x[n] + a1 * x[n-1] + a2 * x[n-2] - b1 * y[n-1] - b2 * y[n-2]",
+    useCases: ["DC offset removal", "rumble removal", "clarifying midrange"],
+    zigLibraries: ["zang", "bonk", "zig-liquid-dsp"]
+  },
+  bandpass: {
+    name: "Band Pass Filter",
+    description: "Allows frequencies within a specific band to pass through.",
+    formula: "y[n] = a0 * x[n] + a1 * x[n-1] + a2 * x[n-2] - b1 * y[n-1] - b2 * y[n-2]",
+    useCases: ["isolating instrument frequencies", "telephone effect", " formant simulation"],
+    zigLibraries: ["zang", "bonk", "zig-liquid-dsp"]
+  },
+  notch: {
+    name: "Notch Filter",
+    description: "Attenuates a specific frequency band while allowing others to pass.",
+    formula: "y[n] = a0 * x[n] + a1 * x[n-1] + a2 * x[n-2] - b1 * y[n-1] - b2 * y[n-2]",
+    useCases: ["hum removal", "feedback suppression", "EQ notching"],
+    zigLibraries: ["bonk", "zig-liquid-dsp"]
+  },
+  "biquad": {
+    name: "Biquad Filter",
+    description: "Second-order IIR filter using two poles and two zeros. Generic form for many filter types.",
+    formula: "y[n] = (b0*x[n] + b1*x[n-1] + b2*x[n-2] - a1*y[n-1] - a2*y[n-2]) / a0",
+    useCases: ["parametric EQ", "crossover filters", "tone control"],
+    zigLibraries: ["zang", "bonk"]
+  },
+  "one-pole": {
+    name: "One-Pole Filter",
+    description: "Simple first-order filter with single pole. Good for smoothing and DC removal.",
+    formula: "y[n] = alpha * x[n] + (1 - alpha) * y[n-1]",
+    useCases: ["smoothing", "DC removal", "simple envelopes"],
+    zigLibraries: ["zang"]
+  }
+};
+
+// Tool input validation schemas
+const ListLibrariesInput = z.object({
+  category: z.enum(["synthesis", "effects", "filters", "dsp", "playback", "recording", "file-io", "encoding", "sdr", "engine", "wrapper", "experimental", "all"]).optional(),
+  feature: z.string().optional()
+});
+
+const GetLibraryInfoInput = z.object({
+  library: z.enum(["zang", "zaudio", "bonk", "pcm", "zig-liquid-dsp", "dalek"])
+});
+
+const ExplainFilterInput = z.object({
+  filter_type: z.enum(["lowpass", "highpass", "bandpass", "notch", "biquad", "one-pole"])
+});
+
+const GenerateCodeInput = z.object({
+  task: z.enum(["oscillator", "envelope", "filter", "delay", "mixer", "player", "recorder", "file-write", "file-read"]),
+  parameters: z.record(z.union([z.string(), z.number(), z.boolean()])).optional()
+});
+
+const ListResourcesInput = z.object({
+  resource_type: z.enum(["tutorial", "reference", "example", "article"]).optional()
+});
+
+const RecommendLibraryInput = z.object({
+  use_case: z.string().describe("Describe what you want to build (e.g., 'synthesizer', 'audio player', 'DSP effects')"),
+  requirements: z.array(z.string()).optional().describe("Specific requirements like 'low latency', 'no allocations', 'cross-platform'")
+});
+
+const DesignFilterInput = z.object({
+  filter_type: z.enum(["lowpass", "highpass", "bandpass", "notch", "biquad"]),
+  parameters: z.object({
+    sample_rate: z.number().min(1).max(192000),
+    cutoff: z.number().optional().describe("Cutoff frequency in Hz"),
+    q: z.number().optional().describe("Quality factor (resonance)"),
+    gain: z.number().optional().describe("Gain in dB for peaking/shelving filters")
+  })
+});
+
+const VerifyCodeInput = z.object({
+  code: z.string().describe("Zig code to verify for basic syntax and imports"),
+  libraries: z.array(z.string()).optional().describe("Expected libraries that should be imported")
+});
+
+const ProjectTemplateInput = z.object({
+  project_type: z.enum(["synthesizer", "audio-player", "dsp-processor", "file-processor", "game-audio"]),
+  features: z.array(z.string()).optional().describe("Additional features to include")
+});
+
+// Tool handlers
+async function handleListLibraries(args: unknown) {
+  const input = ListLibrariesInput.parse(args);
+  
+  let libraries = Object.values(ZIG_AUDIO_LIBRARIES);
+  
+  if (input.category && input.category !== "all") {
+    libraries = libraries.filter(lib => lib.categories.includes(input.category!));
+  }
+  
+  if (input.feature) {
+    libraries = libraries.filter(lib => 
+      lib.features.some(f => f.toLowerCase().includes(input.feature!.toLowerCase()))
+    );
+  }
+
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(libraries, null, 2)
+    }]
+  };
+}
+
+async function handleVerifyCode(args: unknown) {
+  const input = VerifyCodeInput.parse(args);
+
+  const issues: string[] = [];
+  const suggestions: string[] = [];
+
+  // Check for missing std import
+  if (input.code.includes("std.math") && !input.code.includes('const std = @import("std");')) {
+    issues.push("Missing std import but using std.math");
+    suggestions.push('Add: const std = @import("std");');
+  }
+
+  // Check for common library imports
+  const libraryChecks = [
+    { lib: "zang", pattern: /zang\./, import: 'const zang = @import("zang");' },
+    { lib: "zaudio", pattern: /zaudio\./, import: 'const zaudio = @import("zaudio");' },
+    { lib: "bonk", pattern: /bonk\./, import: 'const bonk = @import("bonk");' },
+    { lib: "pcm", pattern: /pcm\./, import: 'const pcm = @import("pcm");' }
+  ];
+
+  for (const check of libraryChecks) {
+    if (input.code.match(check.pattern) && !input.code.includes(check.import)) {
+      issues.push(`Using ${check.lib} but missing import`);
+      suggestions.push(`Add: ${check.import}`);
+    }
+  }
+
+  // Check for basic syntax issues
+  if (input.code.includes("main()") && !input.code.includes("pub fn main")) {
+    issues.push("main function should be declared as 'pub fn main'");
+  }
+
+  // Check for common mistakes
+  if (input.code.includes("try ") && !input.code.includes("!void")) {
+    suggestions.push("Consider using error return types (!void) for functions with try");
+  }
+
+  const verificationResult = {
+    code_length: input.code.length,
+    issues: issues.length > 0 ? issues : ["No obvious issues detected"],
+    suggestions: suggestions.length > 0 ? suggestions : ["Code looks good"],
+    libraries_found: libraryChecks.filter(check => input.code.includes(check.lib)).map(check => check.lib)
+  };
+
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(verificationResult, null, 2)
+    }]
+  };
+}
+
+async function handleProjectTemplate(args: unknown) {
+  const input = ProjectTemplateInput.parse(args);
+
+  const templates = {
+    synthesizer: {
+      build_zig: `const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe = b.addExecutable(.{
+        .name = "synth",
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Add zang dependency
+    const zang = b.dependency("zang", .{});
+    exe.root_module.addImport("zang", zang.module("zang"));
+
+    b.installArtifact(exe);
+}`,
+      main_zig: `const std = @import("std");
+const zang = @import("zang");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Initialize synthesizer components
+    var sine_osc = zang.SineOsc.init(.{
+        .sample_rate = 44100,
+        .frequency = 440.0,
+    });
+
+    var envelope = zang.Envelope.init(.{
+        .attack = 0.1,
+        .decay = 0.2,
+        .sustain = 0.7,
+        .release = 0.3,
+        .sample_rate = 44100,
+    });
+
+    // Audio processing loop would go here
+    std.debug.print("Synthesizer initialized\\n", .{});
+}`,
+      build_zig_zon: `.{ .name = "synth", .version = "0.1.0", .dependencies = .{
+.zang = .{
+    .url = "https://github.com/dbandstra/zang/archive/master.tar.gz",
+    .hash = "1220...", // Get actual hash from zig fetch
+},
+} }`
+    },
+    "audio-player": {
+      build_zig: `const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe = b.addExecutable(.{
+        .name = "player",
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Add zaudio dependency
+    const zaudio = b.dependency("zaudio", .{});
+    exe.root_module.addImport("zaudio", zaudio.module("zaudio"));
+
+    b.installArtifact(exe);
+}`,
+      main_zig: `const std = @import("std");
+const zaudio = @import("zaudio");
+
+pub fn main() !void {
+    // Initialize audio device
+    var device = try zaudio.Device.init(.{
+        .direction = .playback,
+        .sample_rate = 44100,
+        .channels = 2,
+        .format = .f32,
+    });
+    defer device.deinit();
+
+    // Start playback
+    try device.start();
+
+    std.debug.print("Audio player initialized\\n", .{});
+}`,
+      build_zig_zon: `.{ .name = "player", .version = "0.1.0", .dependencies = .{
+.zaudio = .{
+    .url = "https://github.com/MasterQ32/zaudio/archive/master.tar.gz",
+    .hash = "1220...", // Get actual hash
+},
+} }`
+    }
+  };
+
+  const template = (templates as any)[input.project_type] || templates.synthesizer;
+
+  const result = {
+    project_type: input.project_type,
+    files: {
+      "build.zig": template.build_zig,
+      "src/main.zig": template.main_zig,
+      "build.zig.zon": template.build_zig_zon
+    },
+    setup_instructions: [
+      "mkdir project-name && cd project-name",
+      "Copy the files above to their respective locations",
+      "Run 'zig build' to compile",
+      "Run 'zig build run' to execute"
+    ]
+  };
+
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(result, null, 2)
+    }]
+  };
+}
+
+async function handleGetLibraryInfo(args: unknown) {
+  const input = GetLibraryInfoInput.parse(args);
+  const lib = ZIG_AUDIO_LIBRARIES[input.library];
+
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(lib, null, 2)
+    }]
+  };
+}
+
+async function handleExplainFilter(args: unknown) {
+  const input = ExplainFilterInput.parse(args);
+  const filter = DSP_FILTERS[input.filter_type];
+  
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(filter, null, 2)
+    }]
+  };
+}
+
+async function handleGenerateCode(args: unknown) {
+  const input = GenerateCodeInput.parse(args);
+  
+  const codeTemplates: Record<string, string> = {
+    oscillator: `// Zig oscillator using zang
+const std = @import("std");
+const zang = @import("zang");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Initialize zang modules
+    var modules = zang.modules;
+    var sine_osc = zang.SineOsc.init(.{
+        .sample_rate = 44100,
+        .frequency = 440.0,
+    });
+
+    // Create audio buffer
+    var buffer: [1024]f32 = undefined;
+
+    // Paint audio into buffer
+    sine_osc.paint(buffer[0..]);
+
+    std.debug.print("Generated {} samples of sine wave\\n", .{buffer.len});
+}`,
+    envelope: `// ADSR envelope using zang
+const std = @import("std");
+const zang = @import("zang");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Initialize zang envelope
+    var envelope = zang.Envelope.init(.{
+        .attack = 0.1,
+        .decay = 0.2,
+        .sustain = 0.7,
+        .release = 0.3,
+        .sample_rate = 44100,
+    });
+
+    // Create audio buffer
+    var buffer: [1024]f32 = undefined;
+
+    // Trigger note on
+    envelope.setGate(true);
+
+    // Paint envelope into buffer
+    envelope.paint(buffer[0..]);
+
+    // After some time, trigger note off
+    envelope.setGate(false);
+
+    std.debug.print("Generated ADSR envelope with {} samples\\n", .{buffer.len});
+}`,
+    filter: `// Low-pass filter using zang
+const std = @import("std");
+const zang = @import("zang");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Initialize zang low-pass filter
+    var filter = zang.Filter.init(.{
+        .type = .lowpass,
+        .cutoff = 1000.0,
+        .resonance = 0.7,
+        .sample_rate = 44100,
+    });
+
+    // Create input and output buffers
+    var input: [1024]f32 = undefined;
+    var output: [1024]f32 = undefined;
+
+    // Fill input with noise or signal
+    for (&input, 0..) |*sample, i| {
+        sample.* = std.rand.float(f32) * 2.0 - 1.0; // White noise
+    }
+
+    // Process through filter
+    filter.process(input[0..], output[0..]);
+
+    std.debug.print("Applied low-pass filter to {} samples\\n", .{input.len});
+}`,
+    delay: `// Delay effect using bonk
+const std = @import("std");
+const bonk = @import("bonk");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Initialize bonk delay
+    var delay = bonk.Delay.init(.{
+        .delay_time = 0.3, // 300ms delay
+        .feedback = 0.5,
+        .mix = 0.3,
+        .sample_rate = 44100,
+    });
+
+    // Create input and output buffers
+    var input: [1024]f32 = undefined;
+    var output: [1024]f32 = undefined;
+
+    // Fill input with some signal
+    for (&input, 0..) |*sample, i| {
+        sample.* = std.math.sin(@as(f32, @floatFromInt(i)) * 0.01); // Simple tone
+    }
+
+    // Process through delay
+    delay.process(input[0..], output[0..]);
+
+    std.debug.print("Applied delay effect to {} samples\\n", .{input.len});
+}`,
+    mixer: `// Simple audio mixer
+pub fn Mixer(comptime T: type, num_channels: usize) type {
+    return struct {
+        gains: [num_channels]f32 = .{0} ** num_channels,
+        
+        pub fn setGain(self: *@This(), channel: usize, gain: f32) void {
+            if (channel < num_channels) {
+                self.gains[channel] = gain;
+            }
+        }
+        
+        pub fn mix(self: *@This(), inputs: [num_channels]f32) f32 {
+            var result: f32 = 0;
+            for (inputs, self.gains) |input, gain| {
+                result += input * gain;
+            }
+            return result;
+        }
+    };
+}`,
+    player: `// Audio playback using zaudio
+const std = @import("std");
+const zaudio = @import("zaudio");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Initialize zaudio device
+    var device = try zaudio.Device.init(.{
+        .direction = .playback,
+        .sample_rate = 44100,
+        .channels = 2,
+        .format = .f32,
+    });
+    defer device.deinit();
+
+    // Start playback
+    try device.start();
+
+    // Create audio buffer with a sine wave
+    var buffer: [4410]f32 = undefined; // 0.1 seconds at 44100 Hz
+    for (&buffer, 0..) |*sample, i| {
+        const t = @as(f32, @floatFromInt(i)) / 44100.0;
+        sample.* = std.math.sin(t * 440.0 * 2.0 * std.math.pi) * 0.3;
+    }
+
+    // Play the buffer
+    try device.writeInterleaved(buffer[0..]);
+
+    // Wait a bit
+    std.time.sleep(100 * std.time.ns_per_ms);
+
+    std.debug.print("Played sine wave for 0.1 seconds\\n", .{});
+}`,
+    recorder: `// Audio recording using zaudio
+const std = @import("std");
+const zaudio = @import("zaudio");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Initialize zaudio device for recording
+    var device = try zaudio.Device.init(.{
+        .direction = .capture,
+        .sample_rate = 44100,
+        .channels = 1,
+        .format = .f32,
+    });
+    defer device.deinit();
+
+    // Start recording
+    try device.start();
+
+    // Record for 1 second
+    var buffer: [44100]f32 = undefined;
+    const frames_read = try device.readInterleaved(buffer[0..]);
+
+    std.debug.print("Recorded {} samples from microphone\\n", .{frames_read});
+}`,
+    "file-write": `// Write WAV file using pcm
+const std = @import("std");
+const pcm = @import("pcm");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Create some sample audio data
+    var samples = try allocator.alloc(f32, 44100); // 1 second at 44100 Hz
+    defer allocator.free(samples);
+
+    // Fill with a sine wave
+    for (samples, 0..) |*sample, i| {
+        const t = @as(f32, @floatFromInt(i)) / 44100.0;
+        sample.* = std.math.sin(t * 440.0 * 2.0 * std.math.pi) * 0.5;
+    }
+
+    // Write to WAV file
+    var wav_writer = try pcm.WavWriter.init(.{
+        .filename = "output.wav",
+        .channels = .mono,
+        .sample_rate = 44100,
+        .format = .f32,
+    });
+    defer wav_writer.deinit();
+
+    try wav_writer.write(samples);
+
+    std.debug.print("Wrote {} samples to output.wav\\n", .{samples.len});
+}`,
+    "file-read": `// Read WAV file using pcm
+const std = @import("std");
+const pcm = @import("pcm");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Read WAV file
+    var wav_reader = try pcm.WavReader.init("input.wav", allocator);
+    defer wav_reader.deinit();
+
+    std.debug.print("WAV file: {} Hz, {} channels, {} frames\\n",
+        .{wav_reader.sampleRate(), wav_reader.channels(), wav_reader.frameCount()});
+
+    // Read all samples
+    var samples = try wav_reader.readSamples(allocator);
+    defer allocator.free(samples);
+
+    std.debug.print("Read {} samples from input.wav\\n", .{samples.len});
+}`
+  };
+  
+  return {
+    content: [{
+      type: "text",
+      text: codeTemplates[input.task] || "Template not available"
+    }]
+  };
+}
+
+async function handleListResources(args: unknown) {
+  const input = ListResourcesInput.parse(args);
+  
+  const resources = [
+    {
+      type: "tutorial",
+      title: "Zig Audio Ecosystem Overview",
+      url: "https://github.com/topics/zig-audio",
+      description: "Overview of audio libraries in Zig ecosystem"
+    },
+    {
+      type: "tutorial",
+      title: "Getting Started with Zang",
+      url: "https://github.com/dbandstra/zang",
+      description: "Complete guide to zang synthesis library with examples"
+    },
+    {
+      type: "tutorial",
+      title: "Audio Programming in Zig",
+      url: "https://ziglang.org/learn/samples/#audio",
+      description: "Official Zig language audio programming samples"
+    },
+    {
+      type: "example",
+      title: "Zang Examples Repository",
+      url: "https://github.com/dbandstra/zang/tree/master/examples",
+      description: "Complete examples for oscillators, effects, and synthesis"
+    },
+    {
+      type: "example",
+      title: "Zaudio Usage Examples",
+      url: "https://github.com/MasterQ32/zaudio/tree/master/examples",
+      description: "Cross-platform audio I/O examples with miniaudio"
+    },
+    {
+      type: "reference",
+      title: "Zaudio API Documentation",
+      url: "https://github.com/MasterQ32/zaudio",
+      description: "Complete API reference for miniaudio wrapper"
+    },
+    {
+      type: "reference",
+      title: "Digital Signal Processing Fundamentals",
+      url: "https://www.dspguide.com/",
+      description: "Comprehensive DSP theory and algorithms reference"
+    },
+    {
+      type: "reference",
+      title: "PCM File Format Specification",
+      url: "https://www.mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html",
+      description: "WAV file format technical specification"
+    },
+    {
+      type: "article",
+      title: "Building Real-time Audio Apps in Zig",
+      url: "https://christine.website/blog/zig-dsp-01-2024",
+      description: "In-depth tutorial on DSP effects and real-time processing"
+    },
+    {
+      type: "article",
+      title: "Zig Audio Libraries Comparison",
+      url: "https://zig.news/spectral/zig-audio-libraries-comparison-2024",
+      description: "Performance and feature comparison of Zig audio libraries"
+    },
+    {
+      type: "article",
+      title: "Low-Latency Audio Programming",
+      url: "https://www.rossbencina.com/code/real-time-audio-programming-101-time-waits-for-nothing",
+      description: "Essential guide to real-time audio programming concepts"
+    },
+    {
+      type: "tutorial",
+      title: "Software-Defined Radio with Zig",
+      url: "https://github.com/ggerard/zig-liquid-dsp",
+      description: "SDR programming tutorial using zig-liquid-dsp"
+    },
+    {
+      type: "example",
+      title: "Bonk DSP Effects",
+      url: "https://github.com/chr15m/bonk/tree/master/examples",
+      description: "Creative DSP effects and filter examples"
+    },
+    {
+      type: "reference",
+      title: "Audio EQ Cookbook",
+      url: "https://www.w3.org/TR/audio-eq-cookbook/",
+      description: "Standard biquad filter coefficient calculations"
+    },
+    {
+      type: "tutorial",
+      title: "Cross-Platform Audio Development",
+      url: "https://miniaud.io/docs/manual/index.html",
+      description: "Miniaudio documentation (used by zaudio)"
+    }
+  ];
+  
+  let filtered = resources;
+  if (input.resource_type) {
+    filtered = resources.filter(r => r.type === input.resource_type);
+  }
+  
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(filtered, null, 2)
+    }]
+  };
+}
+
+async function handleGetConcepts(args: unknown) {
+  const concepts = {
+    "sample-rate": {
+      description: "Number of samples captured per second (e.g., 44100 Hz, 48000 Hz)",
+      typicalValues: [44100, 48000, 96000],
+      impact: "Higher rates = more accurate audio but more CPU/memory"
+    },
+    "bit-depth": {
+      description: "Number of bits per sample for amplitude resolution",
+      typicalValues: [16, 24, 32],
+      impact: "Higher depth = more dynamic range, less quantization noise"
+    },
+    "buffer-size": {
+      description: "Number of samples processed per callback cycle",
+      typicalValues: [64, 128, 256, 512, 1024],
+      impact: "Smaller = lower latency, higher CPU; larger = more stable, more latency"
+    },
+    "nyquist-frequency": {
+      description: "Maximum representable frequency (sample_rate / 2)",
+      formula: "f_nyquist = sample_rate / 2"
+    },
+    "aliasing": {
+      description: "Distortion from sampling frequencies above Nyquist",
+      prevention: "Use anti-aliasing filters before downsampling"
+    }
+  };
+
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(concepts, null, 2)
+    }]
+  };
+}
+
+async function handleRecommendLibrary(args: unknown) {
+  const input = RecommendLibraryInput.parse(args);
+
+  const recommendations = {
+    synthesizer: {
+      primary: "zang",
+      reason: "Purpose-built for audio synthesis with oscillators, envelopes, and filters. No dynamic allocations makes it ideal for real-time performance.",
+      alternatives: ["dalek", "bonk"],
+      considerations: "If you need more complex synthesis, consider dalek for data-oriented approaches."
+    },
+    "audio-player": {
+      primary: "zaudio",
+      reason: "Direct wrapper around miniaudio provides cross-platform playback with minimal overhead.",
+      alternatives: ["zang", "dalek"],
+      considerations: "For synthesis + playback, combine zaudio with zang."
+    },
+    "dsp-effects": {
+      primary: "bonk",
+      reason: "Specializes in DSP objects like filters, delays, and waveshapers.",
+      alternatives: ["zig-liquid-dsp", "zang"],
+      considerations: "For SDR/communications DSP, use zig-liquid-dsp instead."
+    },
+    "file-processing": {
+      primary: "pcm",
+      reason: "Simple, efficient WAV/AIFF file I/O with multiple sample formats.",
+      alternatives: ["zaudio"],
+      considerations: "zaudio includes some file support but pcm is more comprehensive for file operations."
+    },
+    "sdr-radio": {
+      primary: "zig-liquid-dsp",
+      reason: "Comprehensive DSP library specifically for software-defined radio applications.",
+      alternatives: ["bonk"],
+      considerations: "For general DSP (not SDR-specific), bonk may be more appropriate."
+    },
+    "game-audio": {
+      primary: "zang",
+      reason: "Low-latency, no-allocation design perfect for games. Includes all essential synthesis components.",
+      alternatives: ["dalek", "zaudio"],
+      considerations: "Combine with zaudio for playback if zang's output isn't sufficient."
+    },
+    "embedded-audio": {
+      primary: "zang",
+      reason: "No dynamic allocations and low-level control make it ideal for embedded systems.",
+      alternatives: ["bonk"],
+      considerations: "Ensure your target platform supports Zig compilation."
+    }
+  };
+
+  // Find best match based on use case keywords
+  const useCase = input.use_case.toLowerCase();
+  let bestMatch = null;
+  let score = 0;
+
+  for (const [key, rec] of Object.entries(recommendations)) {
+    if (useCase.includes(key) || key.split('-').some(k => useCase.includes(k))) {
+      bestMatch = rec;
+      score = 1;
+      break;
+    }
+  }
+
+  // If no direct match, try partial matches
+  if (!bestMatch) {
+    for (const [key, rec] of Object.entries(recommendations)) {
+      const keywords = key.split('-');
+      const matchScore = keywords.filter(k => useCase.includes(k)).length / keywords.length;
+      if (matchScore > score) {
+        bestMatch = rec;
+        score = matchScore;
+      }
+    }
+  }
+
+  // Default recommendation if nothing matches
+  if (!bestMatch) {
+    bestMatch = {
+      primary: "zang",
+      reason: "General-purpose audio synthesis library suitable for most applications.",
+      alternatives: ["zaudio", "bonk"],
+      considerations: "Consider your specific requirements - playback, effects, file I/O, etc."
+    };
+  }
+
+  // Apply requirement filters
+  if (input.requirements) {
+    const reqs = input.requirements.map(r => r.toLowerCase());
+
+    if (reqs.includes("low latency") || reqs.includes("real-time")) {
+      if (bestMatch.primary !== "zang") {
+        bestMatch.primary = "zang";
+        bestMatch.reason = "Zang's no-allocation design provides the lowest latency.";
+      }
+    }
+
+    if (reqs.includes("cross-platform") || reqs.includes("playback")) {
+      bestMatch.primary = "zaudio";
+      bestMatch.reason = "Zaudio provides the most reliable cross-platform audio I/O.";
+    }
+
+    if (reqs.includes("no allocations") || reqs.includes("embedded")) {
+      bestMatch.primary = "zang";
+      bestMatch.reason = "Zang is specifically designed with zero dynamic allocations.";
+    }
+  }
+
+  const result = {
+    use_case: input.use_case,
+    recommendation: bestMatch,
+    library_details: ZIG_AUDIO_LIBRARIES[bestMatch.primary as keyof typeof ZIG_AUDIO_LIBRARIES]
+  };
+
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(result, null, 2)
+    }]
+  };
+}
+
+async function handleDesignFilter(args: unknown) {
+  const input = DesignFilterInput.parse(args);
+
+  // Basic filter coefficient calculation
+  function calculateBiquadCoefficients(type: string, fs: number, fc: number, q: number = 0.707, gain: number = 0) {
+    const omega = 2 * Math.PI * fc / fs;
+    const alpha = Math.sin(omega) / (2 * q);
+    const cos_omega = Math.cos(omega);
+    const A = Math.pow(10, gain / 40);
+
+    let b0, b1, b2, a0, a1, a2;
+
+    switch (type) {
+      case "lowpass":
+        b0 = (1 - cos_omega) / 2;
+        b1 = 1 - cos_omega;
+        b2 = (1 - cos_omega) / 2;
+        a0 = 1 + alpha;
+        a1 = -2 * cos_omega;
+        a2 = 1 - alpha;
+        break;
+      case "highpass":
+        b0 = (1 + cos_omega) / 2;
+        b1 = -(1 + cos_omega);
+        b2 = (1 + cos_omega) / 2;
+        a0 = 1 + alpha;
+        a1 = -2 * cos_omega;
+        a2 = 1 - alpha;
+        break;
+      case "bandpass":
+        b0 = alpha;
+        b1 = 0;
+        b2 = -alpha;
+        a0 = 1 + alpha;
+        a1 = -2 * cos_omega;
+        a2 = 1 - alpha;
+        break;
+      case "notch":
+        b0 = 1;
+        b1 = -2 * cos_omega;
+        b2 = 1;
+        a0 = 1 + alpha;
+        a1 = -2 * cos_omega;
+        a2 = 1 - alpha;
+        break;
+      default:
+        throw new Error(`Unsupported filter type: ${type}`);
+    }
+
+    // Normalize by a0
+    return {
+      b: [b0 / a0, b1 / a0, b2 / a0],
+      a: [1, a1 / a0, a2 / a0]
+    };
+  }
+
+  const params = input.parameters;
+  const coeffs = calculateBiquadCoefficients(
+    input.filter_type,
+    params.sample_rate,
+    params.cutoff || 1000,
+    params.q || 0.707,
+    params.gain || 0
+  );
+
+  const result = {
+    filter_type: input.filter_type,
+    parameters: params,
+    coefficients: coeffs,
+    stability_check: Math.abs(coeffs.a[1]) + Math.abs(coeffs.a[2]) < 1,
+    zig_code: `// ${input.filter_type} filter coefficients
+const coeffs = struct {
+    b: [3]f32 = .{${coeffs.b.map((x: number) => x.toFixed(6)).join(", ")}},
+    a: [3]f32 = .{${coeffs.a.map((x: number) => x.toFixed(6)).join(", ")}},
+};
+
+// Apply to signal using difference equation:
+// y[n] = b[0]*x[n] + b[1]*x[n-1] + b[2]*x[n-2] - a[1]*y[n-1] - a[2]*y[n-2]`
+  };
+
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(result, null, 2)
+    }]
+  };
+}
+
+// Create and configure the MCP server
+const server = new Server(
+  {
+    name: "mcp-zig-audio",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+
+// Set up request handlers
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "zig_audio_list_libraries",
+        description: "List available Zig audio/DSP libraries with optional filtering",
+        inputSchema: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              enum: ["synthesis", "effects", "filters", "dsp", "playback", "recording", "file-io", "encoding", "sdr", "engine", "wrapper", "experimental", "all"],
+              description: "Filter by category"
+            },
+            feature: {
+              type: "string",
+              description: "Filter by feature keyword"
+            }
+          }
+        }
+      },
+      {
+        name: "zig_audio_library_info",
+        "description": "Get detailed information about a specific Zig audio library",
+        inputSchema: {
+          type: "object",
+          properties: {
+            library: {
+              type: "string",
+              enum: ["zang", "zaudio", "bonk", "pcm", "zig-liquid-dsp", "dalek"],
+              description: "Library name"
+            }
+          },
+          required: ["library"]
+        }
+      },
+      {
+        name: "zig_dsp_explain_filter",
+        "description": "Explain a DSP filter type with formula and use cases",
+        inputSchema: {
+          type: "object",
+          properties: {
+            filter_type: {
+              type: "string",
+              enum: ["lowpass", "highpass", "bandpass", "notch", "biquad", "one-pole"],
+              description: "Filter type to explain"
+            }
+          },
+          required: ["filter_type"]
+        }
+      },
+      {
+        name: "zig_audio_generate_code",
+        "description": "Generate starter code for common audio/DSP tasks",
+        inputSchema: {
+          type: "object",
+          properties: {
+            task: {
+              type: "string",
+              enum: ["oscillator", "envelope", "filter", "delay", "mixer", "player", "recorder", "file-write", "file-read"],
+              description: "Type of code to generate"
+            },
+            parameters: {
+              type: "object",
+              description: "Optional parameters for code generation"
+            }
+          },
+          required: ["task"]
+        }
+      },
+      {
+        name: "zig_audio_list_resources",
+        "description": "List learning resources for Zig audio development",
+        inputSchema: {
+          type: "object",
+          properties: {
+            resource_type: {
+              type: "string",
+              enum: ["tutorial", "reference", "example", "article"],
+              description: "Filter by resource type"
+            }
+          }
+        }
+      },
+      {
+        name: "zig_dsp_get_concepts",
+        "description": "Get explanations of fundamental audio/DSP concepts",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "zig_audio_recommend_library",
+        description: "Get library recommendations based on your audio programming needs",
+        inputSchema: {
+          type: "object",
+          properties: {
+            use_case: {
+              type: "string",
+              description: "Describe what you want to build (e.g., 'synthesizer', 'audio player', 'DSP effects')"
+            },
+            requirements: {
+              type: "array",
+              items: { type: "string" },
+              description: "Specific requirements like 'low latency', 'no allocations', 'cross-platform'"
+            }
+          },
+          required: ["use_case"]
+        }
+      },
+      {
+        name: "zig_dsp_design_filter",
+        description: "Design DSP filters and calculate biquad coefficients",
+        inputSchema: {
+          type: "object",
+          properties: {
+            filter_type: {
+              type: "string",
+              enum: ["lowpass", "highpass", "bandpass", "notch", "biquad"],
+              description: "Type of filter to design"
+            },
+            parameters: {
+              type: "object",
+              properties: {
+                sample_rate: {
+                  type: "number",
+                  description: "Sample rate in Hz"
+                },
+                cutoff: {
+                  type: "number",
+                  description: "Cutoff frequency in Hz"
+                },
+                q: {
+                  type: "number",
+                  description: "Quality factor (resonance)"
+                },
+                gain: {
+                  type: "number",
+                  description: "Gain in dB for parametric filters"
+                }
+              },
+              required: ["sample_rate"]
+            }
+          },
+          required: ["filter_type", "parameters"]
+        }
+      },
+      {
+        name: "zig_audio_verify_code",
+        description: "Verify Zig code for basic syntax and common issues",
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: {
+              type: "string",
+              description: "Zig code to verify"
+            },
+            libraries: {
+              type: "array",
+              items: { type: "string" },
+              description: "Expected libraries that should be imported"
+            }
+          },
+          required: ["code"]
+        }
+      },
+      {
+        name: "zig_audio_project_template",
+        description: "Generate project templates for different audio application types",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project_type: {
+              type: "string",
+              enum: ["synthesizer", "audio-player", "dsp-processor", "file-processor", "game-audio"],
+              description: "Type of audio project"
+            },
+            features: {
+              type: "array",
+              items: { type: "string" },
+              description: "Additional features to include"
+            }
+          },
+          required: ["project_type"]
+        }
+      }
+    ]
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  
+  try {
+    switch (name) {
+      case "zig_audio_list_libraries":
+        return await handleListLibraries(args);
+      case "zig_audio_library_info":
+        return await handleGetLibraryInfo(args);
+      case "zig_dsp_explain_filter":
+        return await handleExplainFilter(args);
+      case "zig_audio_generate_code":
+        return await handleGenerateCode(args);
+      case "zig_audio_list_resources":
+        return await handleListResources(args);
+      case "zig_dsp_get_concepts":
+        return await handleGetConcepts(args);
+      case "zig_audio_recommend_library":
+        return await handleRecommendLibrary(args);
+      case "zig_dsp_design_filter":
+        return await handleDesignFilter(args);
+      case "zig_audio_verify_code":
+        return await handleVerifyCode(args);
+      case "zig_audio_project_template":
+        return await handleProjectTemplate(args);
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
+
+// Start the server with stdio transport
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("MCP Zig Audio server running on stdio");
+}
+
+main().catch(console.error);