Bot State with Azure

We can use Azure Bot Application using FastAPI that integrates with Azure Cache for Redis for session management and uses Azure Cosmos DB for state management. Here are the steps to achieve this:

1. State Management with Azure Cosmos DB:

   • Why do you need state?
     • Maintaining state allows your bot to have more meaningful conversations by remembering certain things about a user or conversation.
     • For example, if you’ve talked to a user previously, you can save previous information about them, so that you don’t have to ask for it again.
     • State also keeps data for longer than the current turn, so your bot retains information over the course of a multi-turn conversation.

2. Storage Layer:

   • The backend storage layer is where the state information is actually stored.
   • You can choose from different storage options:
     • Memory Storage: For local testing only; volatile and temporary.
     • Azure Blob Storage: Connects to an Azure Blob Storage object database.
     • Azure Cosmos DB Partitioned Storage: Connects to a partitioned Cosmos DB NoSQL database.
     • Note: The legacy Cosmos DB storage class has been deprecated.

3. State Management:

   • State management automates reading and writing bot state to the underlying storage layer.
   • State is stored as state properties (key-value pairs).
   • The Bot Framework SDK abstracts the underlying implementation.
   • You can use state property accessors to read and write state without worrying about storage specifics.

4. Setting Up Azure Cosmos DB for Bot State:

   • Create an Azure Cosmos DB Account (globally distributed, multi-model database service).
   • Within the Cosmos DB account, create a SQL Database to store the state of your bot effectively.

5. Implementing in Your Bot:

   • In your bot code, use the appropriate storage provider (e.g., Cosmos DB) to manage state.
   • Initialize state management and property accessors.
   • Example (using FastAPI):

     import azure.functions as func
     from WrapperFunction import app as fastapi_app
     from bot_state import BotState, CosmosDbPartitionedStorage
     
     # Initialize Cosmos DB storage
     cosmos_db_storage = CosmosDbPartitionedStorage(
         cosmos_db_endpoint="your_cosmos_db_endpoint",
         cosmos_db_key="your_cosmos_db_key",
         database_id="your_database_id",
         container_id="your_container_id"
     )
     
     # Initialize bot state
     bot_state = BotState(cosmos_db_storage)
     mple: Writing a user-specific property
     async def save_user_preference(turn_context, preference_value):
         user_id = turn_context.activity.from_property.id
         await bot_state.user_state.set_property(turn_context, f"user_preference_{user_id}", preference_value)
     
     # Example: Reading a user-specific property
     async def get_user_preference(turn_context):
         user_id = turn_context.activity.from_property.id
         preference_value = await bot_state.user_state.get_property(turn_context, f"user_preference_{user_id}")
         return preference_value
     
     # Usage in your bot logic
     async def on_message_activity(turn_context):
         # Get user preference
         preference = await get_user_preference(turn_context)
         await turn_context.send_activity(f"Your preference: {preference}")
     
         # Set user preference
         await save_user_preference(turn_context, "New Preference Value")
         await turn_context.send_activity("Preference updated!")
     # Example: Writing a user-specific property
     async def save_user_preference(turn_context, preference_value):
         user_id = turn_context.activity.from_property.id
         await bot_state.user_state.set_property(turn_context, f"user_preference_{user_id}", preference_value)
     
     # Example: Reading a user-specific property
     async def get_user_preference(turn_context):
         user_id = turn_context.activity.from_property.id
         preference_value = await bot_state.user_state.get_property(turn_context, f"user_preference_{user_id}")
         return preference_value
     
     # Usage in your bot logic
     async def on_message_activity(turn_context):
         # Get user preference
         preference = await get_user_preference(turn_context)
         await turn_context.send_activity(f"Your preference: {preference}")
     
         # Set user preference
         await save_user_preference(turn_context, "New Preference Value")
         await turn_context.send_activity("Preference updated!")
     
     app = func.AsgiFunctionApp(app=fastapi_app, http_auth_level=func.AuthLevel.ANONYMOUS)
     

6. Testing Locally and Deployment:

• Test your bot locally using VS Code or Azure CLI.
• Deploy your bot to Azure using the VS Code Azure Functions extension or Azure CLI.