Transcribe Genesys Cloud Recordings with AssemblyAI

1
// Import required AWS SDK modules
2
import { S3 } from '@aws-sdk/client-s3';
3
import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
4
import { GetObjectCommand } from '@aws-sdk/client-s3';
5
6
// Configure logging
7
const logger = {
8
  info: (data) => console.log(JSON.stringify(data)),
9
  error: (data) => console.error(JSON.stringify(data))
10
};
11
12
// Configuration settings for AssemblyAI
13
// See config parameters here: https://www.assemblyai.com/docs/api-reference/transcripts/submit
14
const ASSEMBLYAI_CONFIG = {
15
  multichannel: true // Using multichannel here as we told Genesys to send us multichannel audio.
16
};
17
18
// Initialize AWS S3 client
19
const s3Client = new S3();
20
21
/**
22
 * Generate a presigned URL for the S3 object
23
 * @param {string} bucket - S3 bucket name
24
 * @param {string} key - S3 object key
25
 * @param {number} expiration - URL expiration time in seconds
26
 * @returns {Promise<string>} Presigned URL
27
 */
28
const getPresignedUrl = async (bucket, key, expiration = 3600) => {
29
  logger.info({
30
    message: "Generating presigned URL",
31
    bucket: bucket,
32
    key: key,
33
    expiration: expiration
34
  });
35
36
  const command = new GetObjectCommand({
37
    Bucket: bucket,
38
    Key: key
39
  });
40
41
  return getSignedUrl(s3Client, command, { expiresIn: expiration });
42
}
43
44
/**
45
 * Delete transcript data from AssemblyAI's database
46
 * @param {string} transcriptId - The AssemblyAI transcript ID to delete
47
 * @param {string} apiKey - The AssemblyAI API key
48
 * @returns {Promise<boolean>} True if deletion was successful, False otherwise
49
 */
50
const deleteTranscriptFromAssemblyAI = async (transcriptId, apiKey) => {
51
  try {
52
    const response = await fetch(`https://api.assemblyai.com/v2/transcript/${transcriptId}`, {
53
      method: 'DELETE',
54
      headers: {
55
        'authorization': apiKey,
56
        'content-type': 'application/json'
57
      }
58
    });
59
    
60
    if (response.ok) {
61
      logger.info(`Successfully deleted transcript ${transcriptId} from AssemblyAI`);
62
      return true;
63
    } else {
64
      const errorData = await response.text();
65
      logger.error(`Failed to delete transcript ${transcriptId}: HTTP ${response.status} - ${errorData}`);
66
      return false;
67
    }
68
  } catch (error) {
69
    logger.error(`Error deleting transcript ${transcriptId}: ${error.message}`);
70
    return false;
71
  }
72
}
73
74
/**
75
 * Submit audio for transcription
76
 * @param {object} requestData - Request data including audio URL and config
77
 * @param {string} apiKey - AssemblyAI API key
78
 * @returns {Promise<string>} Transcript ID
79
 */
80
const submitTranscriptionRequest = async (requestData, apiKey) => {
81
  const response = await fetch('https://api.assemblyai.com/v2/transcript', {
82
    method: 'POST',
83
    headers: {
84
      'authorization': apiKey,
85
      'content-type': 'application/json'
86
    },
87
    body: JSON.stringify(requestData)
88
  });
89
90
  if (!response.ok) {
91
    const errorText = await response.text();
92
    throw new Error(`Failed to submit audio for transcription: ${errorText}`);
93
  }
94
95
  const responseData = await response.json();
96
  const transcriptId = responseData.id;
97
  
98
  logger.info({
99
    message: "Audio submitted for transcription",
100
    transcript_id: transcriptId
101
  });
102
  
103
  return transcriptId;
104
}
105
106
/**
107
 * Poll for transcription completion
108
 * @param {string} transcriptId - Transcript ID
109
 * @param {string} apiKey - AssemblyAI API key
110
 * @returns {Promise<object>} Transcription data
111
 */
112
const pollTranscriptionStatus = async (transcriptId, apiKey) => {
113
  const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
114
  
115
  // Keep polling until we get a completion or error
116
  while (true) {
117
    const response = await fetch(`https://api.assemblyai.com/v2/transcript/${transcriptId}`, {
118
      method: 'GET',
119
      headers: {
120
        'authorization': apiKey,
121
        'content-type': 'application/json'
122
      }
123
    });
124
125
    if (!response.ok) {
126
      const errorText = await response.text();
127
      throw new Error(`Failed to poll transcription status: ${errorText}`);
128
    }
129
130
    const pollingData = await response.json();
131
132
    if (pollingData.status === 'completed') {
133
      logger.info({ message: "Transcription completed successfully" });
134
      return pollingData;
135
    } else if (pollingData.status === 'error') {
136
      throw new Error(`Transcription failed: ${pollingData.error}`);
137
    }
138
    
139
    // Wait before polling again
140
    await sleep(3000);
141
  }
142
}
143
144
/**
145
 * Transcribe audio using AssemblyAI API
146
 * @param {string} audioUrl - URL of the audio file
147
 * @param {string} apiKey - AssemblyAI API key
148
 * @returns {Promise<object>} Transcription data
149
 */
150
const transcribeAudio = async (audioUrl, apiKey) => {
151
  logger.info({ message: "Starting audio transcription" });
152
153
  // Prepare request data with config parameters
154
  const requestData = { audio_url: audioUrl, ...ASSEMBLYAI_CONFIG };
155
  
156
  // Submit the audio file for transcription
157
  const transcriptId = await submitTranscriptionRequest(requestData, apiKey);
158
  
159
  // Poll for transcription completion
160
  return await pollTranscriptionStatus(transcriptId, apiKey);
161
}
162
163
/**
164
 * Lambda function handler
165
 * @param {object} event - S3 event
166
 * @param {object} context - Lambda context
167
 * @returns {Promise<object>} Response
168
 */
169
export const handler = async (event, context) => {
170
  try {
171
    // Get the AssemblyAI API key from environment variables
172
    const apiKey = process.env.ASSEMBLYAI_API_KEY;
173
    if (!apiKey) {
174
      throw new Error("ASSEMBLYAI_API_KEY environment variable is not set");
175
    }
176
177
    // Process each record in the S3 event
178
    const records = event.Records || [];
179
    
180
    for (const record of records) {
181
      // Get the S3 bucket and key
182
      const bucket = record.s3.bucket.name;
183
      const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, ' '));
184
      
185
      // Generate a presigned URL for the audio file
186
      const audioUrl = await getPresignedUrl(bucket, key);
187
      
188
      // Get the full transcript JSON from AssemblyAI
189
      const transcriptData = await transcribeAudio(audioUrl, apiKey);
190
      
191
      // Prepare the transcript key - maintaining path structure but changing directory and extension
192
      const transcriptKey = key
193
        .replace('audio', 'transcripts', 1)
194
        .replace('.wav', '.json');
195
      
196
      // Convert the JSON data to a string
197
      const transcriptJsonStr = JSON.stringify(transcriptData, null, 2);
198
      
199
      // Upload the transcript JSON to the same bucket but in transcripts directory
200
      await s3Client.putObject({
201
        Bucket: bucket,  // Use the same bucket
202
        Key: transcriptKey, // Store under the /transcripts directory
203
        Body: transcriptJsonStr,
204
        ContentType: 'application/json'
205
      });
206
      
207
      logger.info({
208
        message: "Transcript uploaded to transcript bucket successfully.",
209
        key: transcriptKey
210
      });
211
      
212
      // Uncomment the following line to delete transcript data from AssemblyAI after saving to S3
213
      // https://www.assemblyai.com/docs/api-reference/transcripts/delete
214
      // await deleteTranscriptFromAssemblyAI(transcriptData.id, apiKey);
215
    }
216
217
    return {
218
      statusCode: 200,
219
      body: JSON.stringify({
220
        message: "Audio file(s) processed successfully",
221
        detail: "Transcripts have been stored in the AssemblyAITranscripts directory"
222
      })
223
    };
224
  } catch (error) {
225
    console.error(`Error: ${error.message}`);
226
    return {
227
      statusCode: 500,
228
      body: JSON.stringify({
229
        message: "Error processing audio file(s)",
230
        error: error.message
231
      })
232
    };
233
  }
234
};

1
ASSEMBLYAI_CONFIG = {
2
  'multichannel': true,
3
  // 'language_code': 'en_us',
4
  // 'redact_pii': true
5
  // etc.
6
}