This chapter provides a comprehensive comparison between Language Understanding (LUIS) and Conversational Language Understanding (CLU), two Azure AI services for extracting intent and entities from natural language. Understanding the differences is critical for the AI-900 exam, which tests your ability to choose the right service for a given scenario. Approximately 5-10% of exam questions touch on this topic, often focusing on key features, use cases, and migration paths. By the end of this chapter, you'll know exactly when to use LUIS vs. CLU and how each works under the hood.
Jump to a section
Imagine you run a business where customers call in with requests. You have two tools: a custom tailor (LUIS) and a smart assistant (CLU). The tailor is highly specialized—you bring in a pattern (intent schema) for exactly one type of clothing, say suits. Every request is measured against that pattern. If a customer asks for a suit, the tailor knows exactly what to do: measure, cut, sew. But if they ask for a dress, the tailor is confused; the pattern doesn't match. To handle dresses, you need a separate tailor with a different pattern. Each tailor works independently, and you must maintain each one separately. The smart assistant, on the other hand, is a generalist. You give it a catalog of all clothing types (multiple intents) and it learns to recognize them all from examples. It can handle suits, dresses, jackets—all in one system. When a customer calls, the assistant listens, understands the intent (e.g., 'I need a suit'), and extracts details like size and color. If a new clothing type becomes popular, you just add examples to the assistant's training; no need to build a new system. The trade-off: the tailor can be extremely precise for its single purpose, while the assistant is more flexible but may require more data to achieve the same accuracy for each specific intent. In Azure, LUIS is the tailor—each app is built for one domain (e.g., booking flights). CLU is the assistant—one project can handle multiple domains (e.g., booking flights, checking weather, setting reminders) within a single language model.
What Are LUIS and CLU?
Language Understanding (LUIS) is a classic Azure AI service that enables applications to understand natural language. It extracts intents (the user's goal) and entities (key data points) from utterances (user input). LUIS has been available for years and is widely used in bots and conversational apps.
Conversational Language Understanding (CLU) is the newer, more advanced service within Azure Cognitive Services for Language. It is part of the unified Language service and offers similar functionality to LUIS but with improved capabilities, such as multi-language support out of the box, project-level versioning, and integration with other Language features like sentiment analysis. CLU is designed to replace LUIS over time.
Why Two Services?
Microsoft introduced CLU as the next generation of language understanding. LUIS remains available for backward compatibility, but new development should use CLU. The exam tests your ability to distinguish between them, especially in scenarios involving migration, advanced features, or specific requirements.
How LUIS Works Internally
LUIS uses machine learning models trained on labeled utterances. The process involves:
Intent classification: Each utterance is assigned an intent (e.g., 'BookFlight'). LUIS uses a multiclass classifier.
Entity extraction: Entities are labeled within utterances (e.g., 'Paris' as a destination). LUIS supports prebuilt entities (e.g., datetimeV2, number) and custom entities.
Training and publishing: You train the model on labeled data and publish to an endpoint. The endpoint receives utterances and returns predicted intents and entities with confidence scores.
Key components: - App: A LUIS app is a container for intents, entities, and utterances. Each app is independent. - Intent: Represents a user goal. Example: 'BookFlight'. - Entity: Extracts specific data. Example: 'Destination' entity. - Utterance: Example user input. Example: 'Book a flight to Paris'. - Endpoint: REST API endpoint for querying.
Default values:
Maximum of 500 intents per app.
Maximum of 100 entities per app.
Utterance limit: 15,000 per app (for active learning).
Training: You must explicitly train and publish after changes.
How CLU Works Internally
CLU is built on top of the Language service and uses advanced transformer models. It supports:
Project: A CLU project can contain multiple intents and entities, similar to a LUIS app.
Multi-language: A single project can handle utterances in multiple languages without separate apps.
Versioning: Projects have version management, allowing you to track changes.
Advanced features: Integration with other Language capabilities (e.g., sentiment analysis, key phrase extraction).
Key differences in mechanism:
CLU uses a unified model that can handle multiple languages, whereas LUIS requires a separate app per language.
CLU supports 'Custom Named Entity Recognition' (NER) and 'Custom Text Classification' as part of the same ecosystem, but for conversational scenarios, you use the 'Conversational Language Understanding' project type.
CLU's training is more automated; you can trigger training and get a model that is ready for deployment.
Configuration and Verification
LUIS:
Create app via Azure portal or LUIS portal (luis.ai).
Train: Use 'Train' button or API.
Publish: To staging or production slot.
Query: https://<region>.api.cognitive.microsoft.com/luis/v2.0/apps/<app-id>?subscription-key=<key>&q=<utterance>
Example response:
{
"query": "book a flight to Paris",
"topScoringIntent": {
"intent": "BookFlight",
"score": 0.99
},
"entities": [
{
"entity": "Paris",
"type": "Destination",
"startIndex": 16,
"endIndex": 20,
"score": 0.95
}
]
}CLU:
Create project via Language Studio (language.cognitive.azure.com) or Azure portal.
Choose 'Conversational Language Understanding' project type.
Add intents, entities, and utterances.
Train: Click 'Train' and select a model.
Deploy: Create a deployment and assign a trained model.
Query: https://<endpoint>/language/:analyze-conversations?api-version=2022-10-01-preview
Example request:
{
"kind": "Conversation",
"analysisInput": {
"conversationItem": {
"id": "1",
"text": "book a flight to Paris",
"modality": "text"
}
},
"parameters": {
"projectName": "MyProject",
"deploymentName": "production"
}
}Example response:
{
"kind": "ConversationResult",
"result": {
"query": "book a flight to Paris",
"prediction": {
"topIntent": "BookFlight",
"intents": [
{"category": "BookFlight", "confidenceScore": 0.99}
],
"entities": [
{"category": "Destination", "text": "Paris", "confidenceScore": 0.95}
]
}
}
}Interaction with Related Technologies
Both LUIS and CLU integrate with: - Azure Bot Service: To build conversational bots. - Power Virtual Agents: For low-code bot creation (CLU preferred). - Azure Cognitive Search: For enriching search with language understanding. - Azure Functions: For custom logic.
CLU also integrates directly with other Language features like sentiment analysis, which can be called in the same API call.
Key Differences for Exam
Multi-language support: LUIS requires separate apps per language; CLU supports multiple languages in one project.
Versioning: CLU has built-in version management; LUIS uses slots (staging/production).
Prebuilt entities: LUIS has a rich set of prebuilt entities; CLU has fewer but can be extended with custom NER.
Active learning: Both support active learning, but CLU's implementation is more integrated.
Migration: Microsoft recommends migrating from LUIS to CLU. There are migration tools available.
Pricing: Both use similar consumption-based pricing, but CLU is part of the Language service which may have different tiers.
Exam Trap Patterns
Choosing LUIS for multi-language scenarios: Wrong because LUIS needs separate apps.
Thinking CLU is only for bots: CLU can be used for any conversational AI, not just bots.
Confusing CLU with Custom Text Classification: CLU is for conversational utterances; Custom Text Classification is for documents.
Assuming LUIS is deprecated: LUIS is still available but not recommended for new projects.
Identify the Scenario Requirements
First, determine the application's needs: single language vs. multiple languages, number of intents, need for versioning, and integration with other Language features. For the exam, if the scenario mentions multiple languages, CLU is the correct choice. If it mentions legacy support or a simple bot, LUIS might still be considered, but CLU is preferred.
Create the Resource in Azure
For LUIS, create a Language Understanding resource in the Azure portal. For CLU, create a Language service resource (which includes CLU). Note the endpoint and key. In the exam, you might be asked which resource type to create for a given scenario.
Define Intents and Entities
In LUIS, add intents and entities via the LUIS portal. In CLU, use Language Studio. For both, label utterances with intents and mark entities. CLU allows adding utterances in multiple languages in one project. The exam may ask about the maximum number of intents (LUIS: 500; CLU: higher limits).
Train and Test the Model
Train the model using the training button or API. LUIS requires explicit training; CLU also requires training but may have faster iterations. Test using the test pane or API. The exam might ask about the training process or how to verify model performance.
Publish and Query the Endpoint
Publish the model to an endpoint. LUIS uses slots (staging/production). CLU uses deployments. Query the endpoint with utterances to get predictions. The exam may ask about the endpoint URL format or the JSON response structure.
Enterprise Scenario 1: Global Customer Support Bot
A multinational company wants a single chatbot that handles customer inquiries in English, Spanish, and French. Using LUIS would require three separate apps, each with its own training and maintenance. With CLU, they create one project that includes utterances in all three languages. The bot uses CLU to understand the intent (e.g., 'CheckOrderStatus') and extract entities like order ID. CLU's multi-language support reduces management overhead. In production, they deploy the model with a single endpoint and monitor performance across languages. Common misconfiguration: failing to provide enough examples for low-resource languages, leading to poor accuracy. They mitigate by using CLU's active learning to gather more examples from real user interactions.
Enterprise Scenario 2: Internal HR Assistant
A company builds an HR bot to answer employee questions about policies, leave balances, and payroll. The bot needs to handle a wide variety of intents (e.g., 'RequestLeave', 'CheckPayroll'). They choose CLU because it supports versioning, allowing the HR team to update intents as policies change without disrupting the production bot. They also integrate CLU with Azure Cognitive Search to retrieve policy documents. Performance considerations: the bot handles thousands of queries daily; latency is critical. CLU's endpoint response times are typically under 200ms. When misconfigured (e.g., overly broad intents), the bot may misclassify queries, leading to incorrect responses. They use confidence score thresholds (e.g., 0.7) to fall back to a human agent.
Enterprise Scenario 3: Legacy Migration
A company has a LUIS-based bot that has been in production for three years. They need to add support for a new language (Japanese). Instead of building a new LUIS app, they decide to migrate to CLU. They use Microsoft's migration tool to export LUIS app data and import into a CLU project. They then add Japanese utterances and retrain. The migration is seamless, but they must update the bot code to use the new CLU endpoint. Common pitfall: assuming CLU supports all LUIS prebuilt entities identically; some prebuilt entities in LUIS are not available in CLU, requiring custom entity definitions.
AI-900 Exam Focus on LUIS vs. CLU
The AI-900 exam objective 4.6 specifically tests your ability to 'describe capabilities of conversational language understanding'. This includes differentiating between LUIS and CLU. The exam is not hands-on; it tests conceptual understanding.
Key objective codes:
AI-900: Describe capabilities of conversational language understanding (LUIS and CLU)
AI-900: Identify scenarios where CLU is preferred over LUIS
Common wrong answers: 1. 'LUIS supports multiple languages in one app' – Wrong. LUIS requires separate apps per language. Candidates confuse LUIS with CLU. 2. 'CLU is only for chatbots' – Wrong. CLU can be used for any conversational AI, including virtual assistants, IVR systems, etc. 3. 'LUIS is deprecated and cannot be used' – Wrong. LUIS is still available and functional, but new projects should use CLU. 4. 'CLU does not support versioning' – Wrong. CLU has built-in version management; LUIS uses slots.
Specific numbers and terms that appear:
LUIS app limits: 500 intents, 100 entities, 15,000 utterances.
CLU project: supports multiple languages, versioning, and deployment slots.
Endpoint URL format for LUIS: https://<region>.api.cognitive.microsoft.com/luis/v2.0/apps/<app-id>?subscription-key=<key>&q=<utterance>
Endpoint for CLU: https://<endpoint>/language/:analyze-conversations?api-version=2022-10-01-preview
Edge cases:
If a scenario requires sentiment analysis along with intent recognition, CLU can provide both in one call; LUIS cannot.
If a scenario requires custom text classification (not conversational), use Custom Text Classification, not CLU.
How to eliminate wrong answers:
If the question mentions 'multiple languages', eliminate LUIS.
If the question mentions 'versioning', eliminate LUIS (or note that CLU has better versioning).
If the question mentions 'prebuilt entities', LUIS has more prebuilt options.
If the question mentions 'migration from LUIS', the answer is CLU.
LUIS requires a separate app per language; CLU supports multiple languages in one project.
CLU offers built-in versioning; LUIS uses staging/production slots.
LUIS has a richer set of prebuilt entities; CLU has fewer but supports custom NER.
Microsoft recommends using CLU for new projects; LUIS remains available for legacy support.
Both services integrate with Azure Bot Service, Power Virtual Agents, and other Azure AI services.
CLU is part of the Azure Language service and can be combined with sentiment analysis and key phrase extraction in a single API call.
The AI-900 exam tests your ability to choose the appropriate service based on multi-language, versioning, and integration requirements.
These come up on the exam all the time. Here's how to tell them apart.
LUIS
Requires separate app per language
Maximum 500 intents per app
Uses staging/production slots for versioning
Richer set of prebuilt entities
Older service, still supported
CLU
Supports multiple languages in one project
Higher limits (project-based, not hard-coded)
Built-in version management with project versions
Fewer prebuilt entities, but extensible with custom NER
Newer service, recommended for new projects
Mistake
LUIS and CLU are the same service with different names.
Correct
They are separate services. LUIS is the older, single-language service. CLU is the newer, multi-language, multi-intent service within Azure Language. CLU offers advanced features like versioning and integration with other Language capabilities.
Mistake
CLU requires a separate resource for each language.
Correct
CLU supports multiple languages in a single project. You can add utterances in different languages and train one model. LUIS, on the other hand, requires a separate app per language.
Mistake
LUIS is deprecated and cannot be used in production.
Correct
LUIS is not deprecated; it is still available and supported. However, Microsoft recommends using CLU for new projects because it is the next-generation service. Existing LUIS apps continue to work.
Mistake
CLU cannot extract custom entities; only prebuilt ones.
Correct
CLU supports custom entity extraction through custom NER. You can define your own entities and label them in utterances. LUIS also supports custom entities.
Mistake
CLU is only for text input, not speech.
Correct
CLU can process both text and speech. It integrates with Azure Speech service to convert speech to text and then perform language understanding. The same CLU endpoint can handle text from speech transcription.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
Yes, but you need to create a separate LUIS app for each language. This increases management overhead. CLU is the better choice for multilingual scenarios because it supports multiple languages in a single project.
Yes, Microsoft positions CLU as the next-generation service that will eventually replace LUIS. For new projects, use CLU. Existing LUIS apps can still be used, but migration is recommended.
CLU supports some prebuilt entities (e.g., numbers, dates), but the set is smaller than LUIS. However, CLU allows you to define custom entities using Custom Named Entity Recognition (NER).
Microsoft provides a migration tool in Language Studio that allows you to export a LUIS app and import it into a CLU project. You may need to adjust entities and retrain the model.
CLU is optimized for conversational utterances (short, user-like input). For long documents or non-conversational text, use Custom Text Classification or Custom NER within the Language service.
Both services use consumption-based pricing. LUIS charges per endpoint call and per training. CLU pricing is part of the Language service, which may have different tiers. Generally, costs are similar.
Yes, CLU supports active learning, where it suggests utterances from real traffic that can be labeled to improve the model. This is similar to LUIS's active learning feature.
You've just covered LUIS vs Conversational Language Understanding — now see how well it sticks with free AI-900 practice questions. Full explanations included, no account needed.
Done with this chapter?