Action Table - Audio

Introduction

This tutorial will guide you through using the JamAI Base TypeScript SDK to create a simple audio information processing system.

What We'll Build

Automate tasks with audio! Imagine processing meeting recordings or voice memos automatically.

In this tutorial, we'll create an audio processing system that:

• Takes an audio file as input (e.g., .mp3, .wav).

• Uploads it to a JamAI Base action table.

• Extracts and generates key information such as:

  • Transcription of the audio content.

  • Summary of the audio.

Prerequisites

Before starting, you'll need:

• Node.js 16.x or higher installed

• Project ID and Personal Access Token (PAT)

Installation and Setup

Installing the SDK

npm install jamaibase

Basic Configuration

Get your Personal Access Token (PAT) here:

Get your Project ID here:

import JamAI from "jamaibase";

const PROJECT_ID = "your_project_id";
const PAT = "your_PAT";

const client = new JamAI({
  projectId: PROJECT_ID,
  token: PAT,
});

Creating Your Action Table

1

Create the action table

Navigate to your JamAI Base action table tab and create a new action table named "AudioProcessor".

2

Configure columns

Configure the following columns:

Input Column:

• Name: "Audio"

• Type: Audio

Output Columns:

• Name: "Transcription" Type: Text ☑️ Output checkbox enabled

• Name: "Summary" Type: Text ☑️ Output checkbox enabled

3

Verify table

Create and confirm the table:

Basic Implementation

4.1 Simple Audio Processor

async function processSingleAudio(audioPath: string) {
  // Upload audio file
  const fileResponse = await client.file.uploadFile({
    file_path: audioPath,
  });

  // Process in action table
  const response = await client.table.addRow({
    table_type: "action",
    table_id: "AudioProcessor",
    data: [{ Audio: fileResponse.uri }],
    concurrent: false,
  });

  // Extract results
  return {
    transcription:
      response.rows[0]?.columns["Transcription"]?.choices[0]?.message?.content,
    summary: response.rows[0]?.columns["Summary"]?.choices[0]?.message?.content,
  };
}

4.2 Complete Implementation with Error Handling

import JamAI from "jamaibase";
import * as fs from "fs";
import * as path from "path";

class AudioProcessor {
  private client: JamAI;

  constructor(projectId: string, pat: string) {
    this.client = new JamAI({
      projectId: projectId,
      token: pat,
    });
  }

  validateAudio(audioPath: string): boolean {
    // Validate if file exists and has correct extension
    if (!fs.existsSync(audioPath)) {
      throw new Error(`Audio file not found: ${audioPath}`);
    }

    const validExtensions = [".mp3", ".wav"];
    const fileExt = path.extname(audioPath).toLowerCase();
    if (!validExtensions.includes(fileExt)) {
      throw new Error(
        `Unsupported file format. Use: ${validExtensions.join(", ")}`
      );
    }

    return true;
  }

  async processAudio(
    audioPath: string
  ): Promise<{ transcription: string; summary: string } | null> {
    try {
      // Validate audio
      this.validateAudio(audioPath);

      // Upload file
      console.log("Uploading audio...");
      const fileResponse = await this.client.file.uploadFile({
        file_path: audioPath,
      });
      console.log(`Upload successful: ${fileResponse.uri}`);

      // Process in action table
      console.log("Processing audio...");
      const response = await this.client.table.addRow({
        table_type: "action",
        table_id: "AudioProcessor",
        data: [{ Audio: fileResponse.uri }],
        concurrent: false,
      });

      const results = {
        transcription: String(
          response.rows[0]?.columns["Transcription"]?.choices[0]?.message
            ?.content ?? ""
        ),
        summary: String(
          response.rows[0]?.columns["Summary"]?.choices[0]?.message?.content ??
            ""
        ),
      };

      console.log("Processing complete!");
      return results;
    } catch (error) {
      console.error(`Error processing audio: ${error}`);
      return null;
    }
  }
}

Usage Examples

Basic Usage

// Initialize processor
const processor = new AudioProcessor(PROJECT_ID, PAT);

// Process single audio
const result = await processor.processAudio("path/to/audio.mp3");

if (result) {
  console.log(`Transcription: ${result.transcription}`);
  console.log(`Summary: ${result.summary}`);
}

Batch Processing

async function processAudioBatch(audioFolder: string) {
  const processor = new AudioProcessor(PROJECT_ID, PAT);
  const results = [];

  const files = fs.readdirSync(audioFolder);

  for (const filename of files) {
    if (filename.toLowerCase().match(/\.(mp3|wav)$/)) {
      const audioPath = path.join(audioFolder, filename);
      const result = await processor.processAudio(audioPath);
      if (result) {
        results.push({
          filename: filename,
          ...result,
        });
      }
    }
  }

  return results;
}

// Usage
const results = await processAudioBatch("path/to/audio/folder");
for (const result of results) {
  console.log(`File: ${result.filename}`);
  console.log(`Transcription: ${result.transcription}`);
  console.log(`Summary: ${result.summary}`);
  console.log("---");
}

Best Practices

Error Handling

• Always validate input audio files.

• Handle network errors gracefully.

• Consider adding specific error handling for audio processing failures (e.g., silence, corrupted files).

Performance

• Reuse the client instance.

• Consider batch processing for multiple files.

• Implement rate limiting for large batches if needed.

Security

• Use environment variables for credentials.

Complete Standalone Example

Save this as audio_processor.ts:

import JamAI from "jamaibase";
import * as fs from "fs";
import * as path from "path";

class AudioProcessor {
  private client: JamAI;

  constructor(projectId: string, pat: string) {
    this.client = new JamAI({
      projectId: projectId,
      token: pat,
    });
  }

  validateAudio(audioPath: string): boolean {
    if (!fs.existsSync(audioPath)) {
      throw new Error(`Audio file not found: ${audioPath}`);
    }

    const validExtensions = [".mp3", ".wav"];
    const fileExt = path.extname(audioPath).toLowerCase();
    if (!validExtensions.includes(fileExt)) {
      throw new Error(
        `Unsupported file format. Use: ${validExtensions.join(", ")}`
      );
    }

    return true;
  }

  async processAudio(
    audioPath: string
  ): Promise<{ transcription: string; summary: string } | null> {
    try {
      this.validateAudio(audioPath);

      console.log(`Processing audio: ${audioPath}`);
      console.log("Uploading audio...");
      const fileResponse = await this.client.file.uploadFile({
        file_path: audioPath,
      });
      console.log("Upload successful!");

      console.log("Extracting information...");
      const response = await this.client.table.addRow({
        table_type: "action",
        table_id: "AudioProcessor",
        data: [{ Audio: fileResponse.uri }],
        concurrent: false,
      });

      const results = {
        transcription: String(
          response.rows[0]?.columns["Transcription"]?.choices[0]?.message
            ?.content ?? ""
        ),
        summary: String(
          response.rows[0]?.columns["Summary"]?.choices[0]?.message?.content ??
            ""
        ),
      };
      return results;
    } catch (error) {
      console.error(`Error: ${error}`);
      return null;
    }
  }
}

async function processFolder(
  folderPath: string,
  processor: AudioProcessor
): Promise<void> {
  // Process all audio files in a folder
  if (!fs.existsSync(folderPath)) {
    console.log(`Folder not found: ${folderPath}`);
    return;
  }

  const results = [];
  const files = fs.readdirSync(folderPath);

  for (const filename of files) {
    if (filename.toLowerCase().match(/\.(mp3|wav)$/)) {
      const audioPath = path.join(folderPath, filename);
      const result = await processor.processAudio(audioPath);
      if (result) {
        results.push({
          filename: filename,
          ...result,
        });
      }
    }
  }

  console.log("\n=== Processing Results ===");
  for (const result of results) {
    console.log(`\nFile: ${result.filename}`);
    console.log(`Transcription: ${result.transcription}`);
    console.log(`Summary: ${result.summary}`);
  }
}

// Main execution
async function main() {
  // Get credentials from environment variables
  const PROJECT_ID = "your_project_id";
  const PAT = "your_PAT";

  const processor = new AudioProcessor(PROJECT_ID, PAT);

  // Process a single audio file
  const singleResult = await processor.processAudio("path/to/audio.mp3");
  if (singleResult) {
    console.log("\nSingle Audio Result:");
    console.log(`Transcription: ${singleResult.transcription}`);
    console.log(`Summary: ${singleResult.summary}`);
  }

  // Or process a folder of audio files
  // await processFolder("path/to/audio/folder", processor);
}

main().catch(console.error);

Running the Example

1. Save the code as audio_processor.ts

2. Create a .env file:

   JAMAI_PROJECT_ID=your_project_id
   JAMAI_API_KEY=your_PAT

3. Install dependencies:

   npm install jamaibase dotenv
   npm install --save-dev @types/node typescript ts-node

4. Run with:

   ts-node audio_processor.ts

Or compile and run:

tsc audio_processor.ts
node audio_processor.js

Troubleshooting

File not found error

• Check that the file path is correct

• Use absolute paths or ensure relative paths are correct

Unsupported file format

• Ensure audio is in MP3 or WAV format

• Check file extension matches actual file type

Upload timeout

• Check internet connection

• Verify file size is reasonable (< 25MB recommended)

• Large audio files may take longer to upload

Transcription errors

• Check audio quality (clear speech, minimal background noise)

• Ensure audio file is not corrupted

• Verify audio contains speech content

API errors

• Verify your PAT and Project ID are correct

• Check that the action table "AudioProcessor" exists in your project

• Ensure output columns "Transcription" and "Summary" are configured correctly