Speech Analytics Data Processing with Amazon Connect

Question

Pulumi · Accepted Answer

Speech analytics data processing with Amazon Connect can be set up using a variety of AWS services in conjunction with Amazon Connect. To implement a solution on AWS for this, we could take advantage of the following AWS services:

- **Amazon Connect**: Serves as the cloud-based contact center service that captures voice calls.
- **Amazon Transcribe**: Automatically converts speech to text.
- **AWS Lambda**: This serverless compute service can be used to process the transcription results.
- **Amazon S3**: For storing call recordings and transcriptions.
- **Amazon Comprehend**: Used for natural language processing (NLP) to analyze the transcription content.

The process flow would look like this:

1. A call is made and managed using the **Amazon Connect** contact flow.
2. The call is recorded and saved in an **Amazon S3** bucket.
3. **AWS Lambda** is triggered when a new recording is saved to the S3 bucket.
4. The Lambda function invokes **Amazon Transcribe** to convert the speech from the call recording into text.
5. Once the transcription is complete, the resulting text is passed to **Amazon Comprehend** for sentiment analysis.
6. The analysis results can then be stored for further processing or analytics.

Here is a Pulumi program written in Python demonstrating how you could set up the AWS resources to facilitate such a process. The program doesn't cover the full setup but gives an overview of how you could use Pulumi to create an Amazon Connect instance, an S3 bucket, and specify the interaction between AWS Lambda and Amazon Transcribe.

```python
import pulumi
import pulumi_aws as aws

# Create an Amazon Connect instance
connect_instance = aws.connect.Instance("connectInstance")

# Create an S3 bucket to store call recordings and transcriptions
recordings_bucket = aws.s3.Bucket("recordingsBucket")

# IAM role for Lambda to access S3, Transcribe, and Comprehend
lambda_role = aws.iam.Role("lambdaRole",
    assume_role_policy="""{
      "Version": "2012-10-17",
      "Statement": [
        {
          "Action": "sts:AssumeRole",
          "Principal": {
            "Service": "lambda.amazonaws.com"
          },
          "Effect": "Allow",
          "Sid": ""
        }
      ]
    }""")

# Attach required policies to the IAM role
aws.iam.RolePolicyAttachment("lambdaS3",
    role=lambda_role.name,
    policy_arn=aws.iam.ManagedPolicy.AWS_LAMBDA_BASIC_EXECUTION_ROLE.value)

aws.iam.RolePolicyAttachment("lambdaTranscribe",
    role=lambda_role.name,
    policy_arn=aws.iam.ManagedPolicy.AMAZON_TRANSCRIBE_FULL_ACCESS.value)

aws.iam.RolePolicyAttachment("lambdaComprehend",
    role=lambda_role.name,
    policy_arn=aws.iam.ManagedPolicy.COMPREHEND_FULL_ACCESS.value)

# The Lambda function that will be triggered and process the call recording
transcription_lambda = aws.lambda_.Function("transcriptionLambda",
    runtime=aws.lambda_.Runtime.PYTHON3_8.value,
    code=pulumi.FileArchive("lambda.zip"),
    handler="lambda_function.handler",
    role=lambda_role.arn,
    environment=aws.lambda_.FunctionEnvironmentArgs(
        variables={
            "TRANSCRIBE_BUCKET": recordings_bucket.bucket
        }
    ))

# Create an S3 bucket event to trigger the Lambda function when a new recording is added
bucket_event = aws.s3.BucketNotification("bucketEvent",
    bucket=recordings_bucket.id,
    lambda_functions=[aws.s3.BucketNotificationLambdaFunctionArgs(
        lambda_function_arn=transcription_lambda.arn,
        events=["s3:ObjectCreated:*"],
        filter_prefix="recordings/"
    )])

# Lambda permission to allow S3 to invoke the Lambda function
lambda_permission = aws.lambda_.Permission("lambdaPermission",
    action="lambda:InvokeFunction",
    function=transcription_lambda.arn,
    principal="s3.amazonaws.com",
    source_arn=recordings_bucket.arn,
    source_account=aws.config.current_account_id())

# Export relevant data
pulumi.export("connect_instance_arn", connect_instance.arn)
pulumi.export("recordings_bucket_name", recordings_bucket.bucket)
pulumi.export("lambda_function_name", transcription_lambda.name)
```

This program sets up the foundational AWS services and resources needed:

- The `aws.connect.Instance` creates an Amazon Connect instance.
- The S3 bucket is set up using `aws.s3.Bucket`.
- The `aws.iam.Role` together with `aws.iam.RolePolicyAttachment` is used to grant the Lambda function the necessary permissions to access Transcribe, S3, and Comprehend.
- With `aws.lambda_.Function`, we create an AWS Lambda function which will process the call recordings. Note that we expect the Lambda function code to be packaged in a zip file (`lambda.zip`) in the actual deployment.
- The `aws.s3.BucketNotification` sets up an event that will trigger the Lambda function when a new recording is added to the specified S3 bucket.
- `aws.lambda_.Permission` grants the necessary permissions for S3 to be able to invoke the Lambda function.

The lambda handler (referenced as "lambda_function.handler") will need to identify the new recording in the S3 bucket, use Amazon Transcribe to convert it to text, and potentially feed the text to Amazon Comprehend for further analysis. Outputs at the end of the program allow you to get the ARNs and names of the resources created, which can be used for configuration or in stack references.