As organizations modernize their AI solutions, migrating from legacy Language Understanding (LUIS) to the newer Conversational Language Understanding (CLU) service has become a common challenge. In this blog post, I'll share my experience using GitHub Copilot to streamline this migration process for our enterprise chatbot application Ramco CHIA.

Ramco CHIA :

Ramco CHIA is an AI-powered virtual assistant that makes interacting with enterprise HR, payroll, and operational functions much simpler. 
This allows users to easily perform tasks such as requesting leave or checking payslips across various platforms like Microsoft Teams, web, and mobile. The framework provides a platform for the product teams to build their BOTS like HR, payroll etc and host the same. Its modular design, utilizing sub-bots and secure APIs, ensures flexible and secure access to information and actions.

CHIA’s Architecture with LUIS:

Chia uses a modular sub-bot design where LUIS handles natural language understanding. It identifies user intents and entities, enabling routing to the right sub-bot (e.g., HR, payroll). The main bot coordinates user sessions, while APIs handle backend operations securely.

What is LUIS?

Language Understanding Intelligent Service (LUIS) is Microsoft's first-generation natural language understanding service that has been a cornerstone for building conversational AI applications. LUIS helps applications understand user intents by analyzing text input, identifying key information, and converting natural language into actionable data.
Key components of LUIS include:

1. Intents: Categories of user intentions (e.g., "BookTimesheet", "ViewPayslip")
2. Entities: Important data points to extract (e.g., dates, locations, numbers)
3. Utterances: Example phrases that map to specific intents

What is CLU?

Conversational Language Understanding (CLU) is Microsoft's next-generation natural language understanding service within the Azure AI platform. CLU represents a significant evolution from LUIS with improved accuracy, more powerful entity extraction capabilities, and better integration with other Azure Cognitive Services.
Benefits of CLU include:

1. Enhanced machine learning models with better contextual understanding
2. More sophisticated entity recognition and relationship modeling
3. Unified development experience within the Azure AI Studio
4. Support for multilingual applications with fewer training examples
5. Better integration with other Azure AI services

Why Migrate from LUIS to CLU?

Migration from LUIS to CLU is necessary for several reasons:

1. Service Deprecation: Microsoft has announced that LUIS will be deprecated, with support ending on October 1, 2025
2. Performance Improvements: CLU offers better intent recognition accuracy and entity extraction capabilities
3. Cost Efficiency: CLU's pricing model is more favorable for most usage patterns
4. Development Integration: CLU integrates more seamlessly with other Azure AI services
5. Future-Proofing: Staying on LUIS means missing out on future AI capabilities and improvements

Migration Complexity:

Migrating from LUIS to CLU is moderately complex. It involves re-mapping intents/entities, updating recognizer logic, handling different confidence models, and ensuring all conversation flows continue to work correctly. Integration points tied to LUIS must be carefully updated for compatibility.

The Migration Challenge

Our team faced the task of migrating our enterprise chatbot application "CHIA" from Microsoft's LUIS service to the new Azure Conversational Language Understanding service. This presented several challenges:

1. The codebase was large with multiple bot components (MainBot, ApprovalsBot, ExpenseBot, etc.)
2. LUIS response structures differed from CLU's modern formats
3. Subtle behavior changes needed to be identified and addressed
4. Regression testing was needed to ensure all conversational flows still worked

How GitHub Copilot Transformed the Experience

1. Understanding the Differences

GitHub Copilot helped us quickly understand the structural differences between LUIS and CLU responses. For example, when examining our implementation, Copilot identified that CLU returns null for empty entity collections whereas LUIS returned empty collections. Copilot helped identify this pattern that needed to be applied across the codebase.

 
           
2. Creating the Response Converter

The most critical part of our migration was converting CLU responses to match the expected LUIS structure. Copilot helps in developing a method ConvertPredictionResponseToLuisResult  that transforms the new JSON structure from CLU into the LUIS format our application expected. Copilot suggested the structure and helped with edge cases like handling datetimeV2 entities that worked differently between the two services.
           
3. Identifying Regression Issues

After implementing the converter, we faced some regressions in our dialogs. For example, once we applied leave , the approval confirmation prompt stopped appearing in our application. Copilot helped identify that with CLU, we needed to ensure entity collections were never null. These null checks fixed multiple cascading issues across the bot's conversation flows.
           

Best Practices Learned

Through this migration process with the help of GitHub Copilot, we developed several best practices:

1. Create a compatibility layer: Rather than rewriting all our dialogue flows, we created a conversion layer that transformed CLU responses into the familiar LUIS structure.
2. Null check everything: CLU can return null for empty collections, which requires defensive programming throughout the codebase.
3. Test with real conversations: Sample real user conversations from production logs to verify that both services produce equivalent results after conversion.
4. Handle entity resolution differences: CLU has a different entity resolution model, particularly for dates, times, and numbers. We needed special handling for these entity types.
5. Update confidence thresholds: CLU's scoring mechanism differs slightly from LUIS, so we needed to recalibrate our confidence thresholds.

Results and Benefits

After completing the migration with GitHub Copilot's assistance:

1. Development time decreased by 60%: What would have been a weeks-long migration, was completed in days.
2. Bug detection improved: Copilot identified subtle patterns and edge cases we might have missed.
3. Knowledge retention: The AI-assisted code contained better documentation, making it easier for new team members to understand.
4. Performance improvements: CLU provided better intent recognition with fewer false positives.

Conclusion

Migrating from LUIS to CLU was a significant undertaking, but GitHub Copilot made the process much more manageable. By identifying common patterns, suggesting code implementations, and helping us understand the new service structure, Copilot became an invaluable pair programming partner.
For teams considering similar migrations, I strongly recommend leveraging AI assistants like GitHub Copilot to accelerate development, improve code quality, and reduce the cognitive load of understanding complex service differences.
The end result is a more modern, maintainable chatbot that leverages Azure's latest language understanding capabilities while maintaining the complex conversational flows we've built over time.