Integrations

Installation:

Install the required packages:

pip install strands-agents strands-agents-tools

Run this example:

import asyncio
from strands.experimental.bidi.agent import BidiAgent
from strands.experimental.bidi.io.audio import BidiAudioIO
from strands.experimental.bidi.io.text import BidiTextIO
from strands.experimental.bidi.models.novasonic import BidiNovaSonicModel
from strands_tools import calculator

async def main():
    """Test the BidirectionalAgent API."""
    # Audio and Text input/output utility
    audio_io = BidiAudioIO(audio_config={})
    text_io = BidiTextIO()
    
    # Nova Sonic model
    model = BidiNovaSonicModel(region="us-east-1")
    
    async with BidiAgent(model=model, tools=[calculator]) as agent:
        print("New BidiAgent Experience")
        print("Try asking: 'What is 25 times 8?' or 'Calculate the square root of 144'")
        
        await agent.run(
            inputs=[audio_io.input()],
            outputs=[audio_io.output(), text_io.output()]
        )

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\nConversation ended by user")
    except Exception as e:
        print(f"Error: {e}")
        import traceback
        traceback.print_exc()

from strands.experimental.bidi.agent import BidiAgent 
from strands.experimental.bidi.io.audio import BidiAudioIO 
from strands.experimental.bidi.io.text import BidiTextIO 
from strands.experimental.bidi.models.novasonic import BidiNovaSonicModel 
from strands_tools import calculator

audio_io = BidiAudioIO(audio_config={}) 
text_io = BidiTextIO()

The BidiAudioIO manages microphone input and speaker output, while BidiTextIO displays text transcriptions and responses in the console.

model = BidiNovaSonicModel(region="us-east-1")

Create a Nova Sonic model instance. The region parameter specifies the AWS region where the model is deployed.

async with BidiAgent(model=model, tools=[calculator]) as agent: 
    await agent.run( 
        inputs=[audio_io.input()],  
        outputs=[audio_io.output(), text_io.output()] 
    )

The agent is created with:

Amazon Bedrock AgentCore provides a managed runtime environment for deploying Nova 2 Sonic applictions with enterprise-grade security and scalability. AgentCore simplifies the deployment of real-time voice AI applications by handling infrastructure, authentication, and WebSocket connectivity.

Key features:

The architecture shows how client applications connect to AgentCore Runtime via WebSocket with SigV4 authentication. The containerized environment includes your WebSocket server, application logic, and Nova Sonic client, all communicating with Nova Sonic through the bidirectional streaming API.

Benefits:

Use cases

For detailed documentation on deploying Nova Sonic with AgentCore, visit the Amazon Bedrock AgentCore Documentation.

LiveKit is an open-source platform for building real-time audio and video applications. Integration with Amazon Nova 2 Sonic enables developers to build conversational voice interfaces without managing complex audio pipelines or signaling protocols.

For detailed implementation examples and code examples, visit the LiveKit AWS Integration Documentation.

How it works:

Pipecat is a framework for building voice and multimodal conversational AI applications. It provides a modular, pipeline-based architecture that orchestrates multiple components to create intelligent voice applications with Amazon Nova Sonic and other AWS services.

For detailed implementation examples and code samples, visit the PipeCat AWS Integration Documentation.

Key features:

The architecture includes:

Deploy your Nova Sonic applications to AWS using infrastructure as code with AWS CDK (Cloud Development Kit). This approach provides repeatable, version-controlled deployments with best practices built in.

Deployment options

For a complete, production-ready example of deploying Nova Sonic with AWS CDK, see the Speech-to-Speech CDK Sample on GitHub. This sample demonstrates:

Multi-agent architecture is a widely used pattern for designing AI assistants that handle complex tasks. In a voice assistant powered by Nova 2 Sonic, this architecture coordinates multiple specialized agents, where each agent operates independently to enable parallel processing, modular design, and scalable solutions.

Nova Sonic serves as the orchestrator in a multi-agent system, performing two key functions:

Conversation flow management: Ensures all necessary information is collected before proceeding to the next step in the conversation.

Intent classification: Analyzes user inquiries and routes them to the appropriate specialized sub-agent.

The diagram above shows a banking voice assistant that uses a multi-agent architecture. The conversation flow begins with a greeting and collecting the user's name, then handles inquiries related to banking or mortgages through specialized sub-agents.

Conversation flow example:

While this example demonstrates sub-agents using the Strands Agents framework deployed on Amazon Bedrock AgentCore, the architecture is flexible. You can choose:

Benefits:

Refer to this blog for more details and code examples.

See the Nova Sonic Workshop Multi-Agent Lab for hands-on samples.

Amazon Nova 2 Sonic integrates with telephony providers to enable AI-powered voice applications accessible via phone calls. This guide covers integration with Twilio, Vonage, and other SIP-based systems for building contact center solutions and voice agents.

Twilio: Cloud communications platform with programmable voice and media streaming capabilities.

Vonage: Global communications APIs with voice, WebSocket audio streaming, and SIP connectivity.

AWS provides a comprehensive sample implementation demonstrating Nova Sonic in a contact center environment with real-time analytics and telephony integration.

Repository: Sample Sonic Contact Center with Telephony