Azure Mgmt Botservice Py

MicrosoftOfficialCreated by Microsoft

Skill
Tool integration
Cloud and DevOps
MIT
Low risk

From the author

Azure Bot Service Management SDK for Python. Use for creating, managing, and configuring Azure Bot Service resources. Triggers: "azure-mgmt-botservice", "AzureBotService", "bot management", "conversational AI", "bot channels".

— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The azure-mgmt-botservice-py skill provides a comprehensive guide for using the Azure Bot Service Management SDK for Python. It covers the lifecycle management of bot resources, including creation, configuration, updates, and deletion. The documentation emphasizes secure authentication practices using DefaultAzureCredential and provides patterns for managing bot channels and OAuth connections, ensuring developers can integrate conversational AI capabilities into their infrastructure workflows.

What it does

Create and configure Azure Bot Service resources.
Manage bot channels such as Microsoft Teams, Direct Line, and Web Chat.
Handle OAuth connection settings for bot authentication.
List and retrieve details for existing bots and channels.
Update and delete bot service resources.
Implement secure authentication using Azure identity best practices.

When to use it

Automating the deployment and configuration of conversational AI bots on Azure.
Integrating bot management into infrastructure-as-code pipelines.
Programmatically updating bot settings or channel configurations.
Managing OAuth connections for bot services.

Advantages

Enables programmatic control over bot service lifecycles.
Promotes secure authentication patterns via DefaultAzureCredential.
Supports various channel integrations for flexible bot deployment.
Provides clear patterns for resource cleanup and management.

Usage examples

“How do I create a new Azure bot using the Python SDK?”: The agent provides a code snippet using the AzureBotService client to instantiate a bot with specific properties, SKU, and endpoint configuration.
“Show me how to add a Microsoft Teams channel to my existing bot.”: The agent provides the necessary imports and a code block using client.channels.create to enable the MsTeamsChannel for a specified bot.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/microsoft/azure-mgmt-botservice-py/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip azure-mgmt-botservice-py.zip -d .agents/skills

Documentation by Microsoft

Azure Bot Service Management SDK for Python

Manage Azure Bot Service resources including bots, channels, and connections.

Installation

pip install azure-mgmt-botservice
pip install azure-identity

Environment Variables

AZURE_SUBSCRIPTION_ID=<your-subscription-id>  # Required for all auth methods
AZURE_RESOURCE_GROUP=<your-resource-group>  # Required for all auth methods
AZURE_TOKEN_CREDENTIALS=prod # Required only if DefaultAzureCredential is used in production

Authentication & Lifecycle

🔑 Two rules apply to every code sample below:
Prefer DefaultAzureCredential. It works locally (Azure CLI / VS Code / Developer CLI) and in Azure (managed identity, workload identity) with no code change. Avoid connection strings, account/API keys — they bypass Entra audit and rotation.
Local dev: DefaultAzureCredential works as-is.
Production: set AZURE_TOKEN_CREDENTIALS=prod (or AZURE_TOKEN_CREDENTIALS=<specific_credential>) to constrain the credential chain to production-safe credentials.
Wrap every client in a context manager so HTTP transports, sockets, and token caches are released deterministically:
Sync: with <Client>(...) as client:
Async: async with <Client>(...) as client: and async with DefaultAzureCredential() as credential: (from azure.identity.aio)
Snippets may abbreviate this setup, but production code should always follow both rules.

from azure.identity import DefaultAzureCredential, ManagedIdentityCredential
from azure.mgmt.botservice import AzureBotService
import os

# Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS=<specific_credential>
credential = DefaultAzureCredential(require_envvar=True)
# Or use a specific credential directly in production:
# See https://learn.microsoft.com/python/api/overview/azure/identity-readme?view=azure-python#credential-classes
# credential = ManagedIdentityCredential()

with AzureBotService(
    credential=credential,
    subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"]
) as client:
    # Use `client` for all subsequent operations (see examples below)
    ...

Create a Bot

from azure.mgmt.botservice import AzureBotService
from azure.mgmt.botservice.models import Bot, BotProperties, Sku
from azure.identity import DefaultAzureCredential
import os

resource_group = os.environ["AZURE_RESOURCE_GROUP"]
bot_name = "my-chat-bot"

credential = DefaultAzureCredential()
with AzureBotService(
    credential=credential,
    subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"]
) as client:
    bot = client.bots.create(
        resource_group_name=resource_group,
        resource_name=bot_name,
        parameters=Bot(
            location="global",
            sku=Sku(name="F0"),  # Free tier
            kind="azurebot",
            properties=BotProperties(
                display_name="My Chat Bot",
                description="A conversational AI bot",
                endpoint="https://my-bot-app.azurewebsites.net/api/messages",
                msa_app_id="<your-app-id>",
                msa_app_type="MultiTenant"
            )
        )
    )

print(f"Bot created: {bot.name}")

Get Bot Details

bot = client.bots.get(
    resource_group_name=resource_group,
    resource_name=bot_name
)

print(f"Bot: {bot.properties.display_name}")
print(f"Endpoint: {bot.properties.endpoint}")
print(f"SKU: {bot.sku.name}")

List Bots in Resource Group

bots = client.bots.list_by_resource_group(resource_group_name=resource_group)

for bot in bots:
    print(f"Bot: {bot.name} - {bot.properties.display_name}")

List All Bots in Subscription

all_bots = client.bots.list()

for bot in all_bots:
    print(f"Bot: {bot.name} in {bot.id.split('/')[4]}")

Update Bot

bot = client.bots.update(
    resource_group_name=resource_group,
    resource_name=bot_name,
    properties=BotProperties(
        display_name="Updated Bot Name",
        description="Updated description"
    )
)

Delete Bot

client.bots.delete(
    resource_group_name=resource_group,
    resource_name=bot_name
)

Configure Channels

Add Teams Channel

from azure.mgmt.botservice.models import (
    BotChannel,
    MsTeamsChannel,
    MsTeamsChannelProperties
)

channel = client.channels.create(
    resource_group_name=resource_group,
    resource_name=bot_name,
    channel_name="MsTeamsChannel",
    parameters=BotChannel(
        location="global",
        properties=MsTeamsChannel(
            properties=MsTeamsChannelProperties(
                is_enabled=True
            )
        )
    )
)

Add Direct Line Channel

from azure.mgmt.botservice.models import (
    BotChannel,
    DirectLineChannel,
    DirectLineChannelProperties,
    DirectLineSite
)

channel = client.channels.create(
    resource_group_name=resource_group,
    resource_name=bot_name,
    channel_name="DirectLineChannel",
    parameters=BotChannel(
        location="global",
        properties=DirectLineChannel(
            properties=DirectLineChannelProperties(
                sites=[
                    DirectLineSite(
                        site_name="Default Site",
                        is_enabled=True,
                        is_v1_enabled=False,
                        is_v3_enabled=True
                    )
                ]
            )
        )
    )
)

Add Web Chat Channel

from azure.mgmt.botservice.models import (
    BotChannel,
    WebChatChannel,
    WebChatChannelProperties,
    WebChatSite
)

channel = client.channels.create(
    resource_group_name=resource_group,
    resource_name=bot_name,
    channel_name="WebChatChannel",
    parameters=BotChannel(
        location="global",
        properties=WebChatChannel(
            properties=WebChatChannelProperties(
                sites=[
                    WebChatSite(
                        site_name="Default Site",
                        is_enabled=True
                    )
                ]
            )
        )
    )
)

Get Channel Details

channel = client.channels.get(
    resource_group_name=resource_group,
    resource_name=bot_name,
    channel_name="DirectLineChannel"
)

List Channel Keys

keys = client.channels.list_with_keys(
    resource_group_name=resource_group,
    resource_name=bot_name,
    channel_name="DirectLineChannel"
)

# Access Direct Line keys
if hasattr(keys.properties, 'properties'):
    for site in keys.properties.properties.sites:
        print(f"Site: {site.site_name}")
        print(f"Key: {site.key}")

Bot Connections (OAuth)

Create Connection Setting

from azure.mgmt.botservice.models import (
    ConnectionSetting,
    ConnectionSettingProperties
)

connection = client.bot_connection.create(
    resource_group_name=resource_group,
    resource_name=bot_name,
    connection_name="graph-connection",
    parameters=ConnectionSetting(
        location="global",
        properties=ConnectionSettingProperties(
            client_id="<oauth-client-id>",
            client_secret="<oauth-client-secret>",
            scopes="User.Read",
            service_provider_id="<service-provider-id>"
        )
    )
)

List Connections

connections = client.bot_connection.list_by_bot_service(
    resource_group_name=resource_group,
    resource_name=bot_name
)

for conn in connections:
    print(f"Connection: {conn.name}")

Client Operations

Operation	Method
`client.bots`	Bot CRUD operations
`client.channels`	Channel configuration
`client.bot_connection`	OAuth connection settings
`client.direct_line`	Direct Line channel operations
`client.email`	Email channel operations
`client.operations`	Available operations
`client.host_settings`	Host settings operations

SKU Options

SKU	Description
`F0`	Free tier (limited messages)
`S1`	Standard tier (unlimited messages)

Channel Types

Channel	Class	Purpose
`MsTeamsChannel`	Microsoft Teams	Teams integration
`DirectLineChannel`	Direct Line	Custom client integration
`WebChatChannel`	Web Chat	Embeddable web widget
`SlackChannel`	Slack	Slack workspace integration
`FacebookChannel`	Facebook	Messenger integration
`EmailChannel`	Email	Email communication

Best Practices

Pick sync OR async and stay consistent. Do not mix azure.xxx sync clients with azure.xxx.aio async clients in the same call path. Choose one mode per module.
Always use context managers for clients and async credentials. Wrap every client in with Client(...) as client: (sync) or async with Client(...) as client: (async). For async DefaultAzureCredential from azure.identity.aio, also use async with credential: so tokens and transports are cleaned up.
Use DefaultAzureCredential for code that runs locally. Use a specific token credential for code that runs in Azure.
Start with F0 SKU for development, upgrade to S1 for production
Store MSA App ID/Secret securely — use Key Vault
Enable only needed channels — reduces attack surface
Rotate Direct Line keys periodically
Use managed identity when possible for bot connections
Configure proper CORS for Web Chat channel

Reference Files

File	Contents
references/capabilities.md	Additional non-hero capabilities, operation-group coverage, and production checklists.
references/non-hero-scenarios.md	Dedicated non-hero examples for secondary/advanced scenarios.

Files

ATTRIBUTION.mdAdded by AutoGineer983 B
LICENSELicence file added by AutoGineer1.1 KiB
SKILL.md10.0 KiB
references/capabilities.md2.3 KiB
references/non-hero-scenarios.md4.9 KiB

references/capabilities.md

azure-mgmt-botservice-py capability coverage

SDK/package: azure-mgmt-botservice

This index maps hero scenarios in SKILL.md and links non-hero scenarios documented in dedicated reference files.

Hero scenarios covered in SKILL.md

Create a Bot
Get Bot Details
List Bots in Resource Group
List All Bots in Subscription

Non-hero scenarios

Update Bot: Dedicated example and implementation notes.
See: non-hero-scenarios.md#update-bot
Delete Bot: Dedicated example and implementation notes.
See: non-hero-scenarios.md#delete-bot
Configure Channels: Dedicated example and implementation notes.
See: non-hero-scenarios.md#configure-channels
Get Channel Details: Dedicated example and implementation notes.
See: non-hero-scenarios.md#get-channel-details
List Channel Keys: Dedicated example and implementation notes.
See: non-hero-scenarios.md#list-channel-keys
Bot Connections (OAuth): Dedicated example and implementation notes.
See: non-hero-scenarios.md#bot-connections-oauth
Client Operations: | Operation | Method |
See: non-hero-scenarios.md#client-operations
SKU Options: | SKU | Description |
See: non-hero-scenarios.md#sku-options
Channel Types: | Channel | Class | Purpose |
See: non-hero-scenarios.md#channel-types

non-hero-scenarios.md: Dedicated non-hero examples and implementation notes.

API breadth checklist

Verify client/auth mode for the environment before coding.
Confirm operation-group/method names against current Microsoft Learn API reference.
For Python SDKs with both sync and async clients, document both forms without a blanket preference.
Include cleanup/delete paths for created resources in examples.
Prefer idempotent create/update operations where available.
Validate paging/LRO/error-handling patterns for production paths.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an API key, Needs Python

Security

What our scanner noticed· Low risk

Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Microsoft

Publisher

Microsoft (Official)

Source

microsoft/skills · .github/plugins/azure-sdk-python/skills/azure-mgmt-botservice-py · commit 0696600

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download azure-mgmt-botservice-py.zip