Here’s how to Build a Real-Time Voice Assistant in Microsoft Teams with ElevenLabs

In the fast-paced world of enterprise operations, communication is constant. Project updates, system alerts, and team messages flow through platforms like Microsoft Teams in a relentless stream. For a development team, this stream can quickly turn into a flood. Imagine a critical server failure alert buried under a dozen ‘good morning’ messages and a flurry of non-urgent task updates. The cost of missing that one crucial notification can be immense, leading to extended downtime, frustrated customers, and a frantic scramble to identify a problem that was announced hours ago. The sheer volume of text-based information creates a constant state of distraction, forcing team members to either stay glued to their chat windows or risk missing the one message that truly matters.

This notification fatigue is more than just an annoyance; it’s a significant operational risk. How can your organization ensure that critical alerts cut through the noise and command immediate attention? The solution isn’t another notification channel or a brighter-colored alert box. It’s about changing the medium. Imagine, instead of another text message, a clear, calm voice announces in your DevOps channel: “Critical Alert: API Gateway is experiencing 90% latency.” There’s no ambiguity, no delay, and no chance of it getting lost in the scroll. This is the power of a real-time voice assistant integrated directly into your workspace.

This article provides a complete, step-by-step technical walkthrough for building such a system. We will leverage the robust infrastructure of Microsoft Azure, the collaborative power of Teams, and the industry-leading, low-latency voice generation of the ElevenLabs API. We will guide you from the initial setup of your Azure Bot resource to writing the core logic that translates text alerts into spoken words and deploying a functional voice assistant for your team. By the end of this guide, you will have a working prototype that can transform how your team responds to critical information, making your communication workflow more efficient, immediate, and impactful.

Setting the Foundation: Your Azure and Teams Environment

Before we can bring our voice assistant to life, we need to lay the groundwork. This involves preparing our cloud infrastructure on Microsoft Azure and configuring it to communicate with Microsoft Teams. This foundational setup is crucial for enabling the bot to operate securely and seamlessly within your existing enterprise ecosystem.

Prerequisites: What You’ll Need

To follow this guide, you will need access to a few key services and tools. Ensure you have the following ready:
* Azure Subscription: You’ll need an active Azure account to create and host the bot service. A free trial account is sufficient to get started.
* Microsoft 365 Account with Teams: The account must have administrative permissions to add new apps or bots to a Teams environment.
* Node.js or Python: This guide will feature code snippets in Python, but the principles can be applied to Node.js or other supported languages.
* ElevenLabs API Key: You’ll need to sign up for an ElevenLabs account to get an API key. A free tier is available, which provides enough credits for building and testing your proof-of-concept.

Step 1: Creating Your Azure Bot Resource

Our first step is to create an Azure Bot resource, which will serve as the central hub for our application.
1. Navigate to the Azure Portal and search for “Azure Bot” in the marketplace. Select it and click “Create.”
2. In the configuration panel, you’ll need to provide a unique name for your bot (the “Bot handle”).
3. Choose your subscription and resource group. For the pricing tier, the ‘F0’ (Free) plan is adequate for development.
4. Under “Microsoft App ID,” select “Create new Microsoft App ID.” This will automatically create and register a new application identity for your bot, which is essential for secure authentication. The system will generate both an App ID and a secret for you. Be sure to copy and save the secret in a secure location; you will not be able to retrieve it again.

Step 2: Configuring the Teams Channel

With the bot resource created, we need to enable it to communicate with Microsoft Teams.
1. Inside your newly created Azure Bot resource, navigate to the Channels blade in the left-hand menu.
2. You will see a list of featured channels. Click on the Microsoft Teams logo.
3. On the next screen, simply accept the default settings and click “Apply.” This action officially registers your bot with the Teams channels service, making it discoverable and usable within the Teams client.

The Heart of the Voice: Integrating the ElevenLabs API

With the Azure infrastructure in place, we now turn to the most critical component of our assistant: its voice. A real-time notification system is only effective if its audio is clear, immediate, and professional. Any noticeable lag or robotic-sounding speech undermines its purpose and can be more distracting than helpful.

Why Low-Latency Voice is Crucial for Real-Time Assistants

For a voice notification to be perceived as a real-time alert, the delay between the event and the audio playback must be minimal—ideally, under a second. This is where the choice of a text-to-speech (TTS) provider becomes paramount. ElevenLabs has established itself as an industry leader in this domain, offering a powerful API designed for low-latency streaming. This capability is exactly what is needed for building conversational AI and real-time notification systems, directly addressing the need identified by developers for tools that support real-time conversational AI in business settings.

Step 3: Getting Your ElevenLabs API Key and Choosing a Voice

Before we can write any code, you need to get your API key from ElevenLabs.
1. Go to the ElevenLabs website and create an account.
2. Once logged in, navigate to your profile section, where you will find your API Key. Copy this key and store it securely alongside your Azure Bot credentials.
3. Next, explore the Voice Lab. This is where you can browse a vast library of pre-made voices or even clone your own. For this project, select a voice that sounds clear and professional. Each voice has a unique Voice ID, which you will need for your API calls. Note this ID down.

Step 4: Building the Core Function to Generate Speech

Now, let’s write the Python function that will handle the communication with the ElevenLabs API. This function will take a string of text and the Voice ID as input, send it to the ElevenLabs API, and save the returned audio as an MP3 file.

Here is a Python code snippet using the requests library:

import requests

def generate_voice_notification(api_key: str, voice_id: str, text_to_speak: str, output_path: str):
    """Generates a voice notification using the ElevenLabs API."""
    api_url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
    headers = {
        "Accept": "audio/mpeg",
        "Content-Type": "application/json",
        "xi-api-key": api_key
    }
    data = {
        "text": text_to_speak,
        "model_id": "eleven_monolingual_v1",
        "voice_settings": {
            "stability": 0.5,
            "similarity_boost": 0.5
        }
    }

    response = requests.post(api_url, json=data, headers=headers)

    if response.status_code == 200:
        with open(output_path, 'wb') as f:
            f.write(response.content)
        print(f"Audio content written to file {output_path}")
        return True
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return False

This function is the core of our voice generation engine. It sends our desired text to ElevenLabs and saves the resulting audio, ready to be delivered to our team.

Building the Bot Logic: From Text to Speech in Teams

Now we will develop the logic that connects our Azure bot to our voice generation function. The bot will receive a text message, pass it to the ElevenLabs API via our function, and then post the generated audio file into a Teams channel.

Step 5: Developing the Bot’s Core Logic

We will build the bot using the Bot Framework SDK for Python. The core logic will be housed in an activity_handler that processes incoming messages. When a message is received, the bot will extract the text, pass it to our generate_voice_notification function, and prepare the resulting audio for delivery.

Step 6: Triggering the Voice Notification

To make this practical, we don’t want the bot to vocalize every message. Instead, we’ll configure it to respond to a specific trigger command, such as /alert. When the bot detects a message starting with this command, it will treat the rest of the message as the text to be converted into speech. This approach aligns with the industry trend of moving toward more context-aware AI systems that act on specific, intentional triggers rather than processing everything indiscriminately.

Step 7: Sending the Audio to Microsoft Teams

This step is nuanced. Microsoft Teams does not natively support embedding and autoplaying an audio file sent directly from a bot. To work around this, we upload the generated MP3 file to a publicly accessible storage location (like Azure Blob Storage) and then post a special ‘Card’ to the Teams channel containing an HTML audio tag pointing to the file’s URL. This provides the best user experience.

Here’s a conceptual code snippet illustrating the handler logic:

from botbuilder.core import ActivityHandler, TurnContext
from botbuilder.schema import ChannelAccount, Attachment

class VoiceBot(ActivityHandler):
    async def on_message_activity(self, turn_context: TurnContext):
        message_text = turn_context.activity.text

        if message_text.startswith('/alert'):
            text_to_speak = message_text.replace('/alert', '', 1).strip()
            output_file = "notification.mp3"

            # 1. Generate the voice audio
            generate_voice_notification(ELEVENLABS_API_KEY, VOICE_ID, text_to_speak, output_file)

            # 2. Upload the audio file to a public URL (e.g., Azure Blob Storage)
            audio_url = upload_to_blob_storage(output_file)

            # 3. Create and send an Adaptive Card with an HTML5 audio tag
            card = self.create_audio_card(audio_url)
            await turn_context.send_activity(MessageFactory.attachment(card))

    def create_audio_card(self, audio_url: str):
        # Logic to create an Adaptive Card with an <audio> element
        # This is a simplified representation.
        pass

Deployment and Next Steps: Bringing Your Voice Assistant to Life

With the core logic defined, the final steps are to deploy the code and consider how to expand its functionality. This is where we transition from a proof-of-concept to a production-ready tool that provides tangible value.

Step 8: Deploying Your Bot Code to Azure

Your Python bot application needs to be deployed to a hosting service so it can run 24/7. Azure App Service is an excellent choice for this. You can configure a CI/CD pipeline from a GitHub repository to automatically deploy your code to the App Service whenever you make changes. Once deployed, you must update the Messaging endpoint in your Azure Bot resource to point to your new App Service URL.

Expanding the Assistant’s Capabilities

Our current implementation triggers voice alerts via a manual command, but the real power comes from automation. The next logical step is to integrate the bot with your critical business systems. You can create a secure API endpoint for your bot that other services can call to trigger a voice notification. Consider these powerful integrations:
* DevOps & Monitoring: Connect your bot to Azure Monitor, Datadog, or Grafana to automatically announce critical alerts for server health, application performance, or security events.
* CI/CD Pipeline: Integrate with GitHub Actions or Azure DevOps to announce successful deployments or build failures.
* Ticketing Systems: Connect to Jira or Zendesk to announce the creation of new high-priority support tickets.

This shift from a manual trigger to an automated, integrated system is what elevates a simple bot into a core component of a modern, context-aware enterprise infrastructure.

In a world saturated with text, the strategic use of voice can restore the urgency and clarity that critical notifications demand. We began with the common problem of notification fatigue in Microsoft Teams, where important messages are easily lost. Throughout this guide, we have systematically built a solution: a real-time voice assistant using Azure Bot Service and the ElevenLabs API that transforms text alerts into immediate, unmissable audio notifications. That busy development team no longer has to fear missing a critical server alert buried in a sea of text. Now, a clear voice cuts through the noise, delivering the information that matters, instantly. You’ve taken the first step toward creating a more intelligent, responsive, and less intrusive communication environment for your team.

The power of this system lies in the quality and speed of its voice. To build a truly professional and reliable voice assistant, you need an API built for enterprise-grade performance. To get started with high-quality, low-latency voice generation, try ElevenLabs for free now.