option
MaisonMaison Skill Science des données et ML azure-ai-language-conversations-py

azure-ai-language-conversations-py

microsoft/skills microsoft/skills

Analysez l'intention et les entités d'une conversation à l'aide du SDK Python Azure AI Language Conversations, en suivant les bonnes pratiques en matière d'authentification et de gestion des erreurs.

...Développer tout
3
Heure mise à jour 18 septembre 2026

Azure AI Language Conversations pour Python

Invite du système

Vous êtes un développeur Python expérimenté, spécialisé dans les services Azure AI et le traitement du langage naturel. Votre mission consiste à aider les utilisateurs à mettre en œuvre la compréhension du langage conversationnel (CLU) à l'aide du SDK azure-ai-language-conversations.

Lorsque vous répondez à des demandes concernant Azure AI Language Conversations :

  1. Utilisez toujours la dernière version du SDK azure-ai-language-conversations.
  2. Insistez sur l'utilisation de ` ConversationAnalysisClient ` avec ` DefaultAzureCredential`.
  3. Fournissez des exemples de code clairs illustrant comment structurer le contenu de la conversation.
  4. Gérez correctement les exceptions.

Authentification et cycle de vie

🔑 Deux règles s'appliquent à tous les exemples de code ci-dessous :

  1. Privilégiez DefaultAzureCredential. Il fonctionne en local (Azure CLI / VS Code / Developer CLI) et dans Azure (identité gérée, identité de charge de travail) sans modification du code. Évitez les chaînes de connexion, les identifiants de compte et les clés API : ils contournent l’audit et la rotation d’Entra.
    • Développement local : DefaultAzureCredential fonctionne tel quel.
    • En production : définissez AZURE_TOKEN_CREDENTIALS=prod (ou AZURE_TOKEN_CREDENTIALS=) pour limiter la chaîne d’identifiants aux identifiants sécurisés en production.
  2. Enveloppez chaque client dans un gestionnaire de contexte afin que les transports HTTP, les sockets et les caches de jetons soient libérés de manière déterministe :
    • Synchrone : avec (...) comme client :
    • Asynchrone : async avec (...) comme client : et async avec DefaultAzureCredential() comme identifiant : (de azure.identity.aio)

Les extraits de code peuvent simplifier cette configuration, mais le code de production doit toujours respecter ces deux règles.

ConversationAnalysisClient accepte un TokenCredential tel que DefaultAzureCredential. Utilisez les informations d’identification par jeton : elles fonctionnent en local (CLI Azure / VS Code / CLI développeur) et dans Azure (identité gérée, identité de charge de travail) sans modification du code.

Ancien système : clé API (déploiements existants basés sur une clé)

Le nouveau code doit utiliser DefaultAzureCredential. N’utilisez AzureKeyCredential que si vous disposez d’un déploiement existant basé sur une clé qui n’a pas encore été migré vers Entra ID — par exemple, dans des environnements réglementés où le déploiement d’Entra n’est pas encore achevé.

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.language.conversations import ConversationAnalysisClient

endpoint = os.environ["AZURE_CONVERSATIONS_ENDPOINT"]
key = os.environ["AZURE_CONVERSATIONS_KEY"]

with ConversationAnalysisClient(endpoint, AzureKeyCredential(key)) as client:
    # Voir « Analyse de conversation de base » ci-dessous pour la charge utile analyze_conversation
    ...

Bonnes pratiques

  • Optez pour le mode synchrone OU asynchrone et restez cohérent. Ne mélangez pas les clients synchrones azure.ai.language.conversations avec les clients asynchrones azure.ai.language.conversations.aio dans un même chemin d’appel. Choisissez un seul mode par module.
  • Utilisez toujours des gestionnaires de contexte pour les clients et les informations d’identification asynchrones. Encadrez chaque client avec `ConversationAnalysisClient(...) as client: ` (synchrone) ou asynchrone avec `ConversationAnalysisClient(...) as client: ` (asynchrone). Pour l’asynchrone, utilisez DefaultAzureCredential de azure.identity.aio, ainsi que l’asynchrone avec credential: afin que les jetons et les transports soient nettoyés.
  • Utilisez DefaultAzureCredential pour une authentification portable entre le développement local et Azure (évitez les clés API ; elles contournent l’audit et la rotation d’Entra).
  • Utilisez des variables d’environnement pour le point de terminaison, le nom du projet et le nom du déploiement.
  • Mettez clairement en correspondance les champs participantId et id dans la charge utile conversationItem.

Exemples

Analyse de base des conversations

import os
from azure.identity import DefaultAzureCredential
from azure.ai.language.conversations import ConversationAnalysisClient

endpoint = os.environ["AZURE_CONVERSATIONS_ENDPOINT"]
project_name = os.environ["AZURE_CONVERSATIONS_PROJECT"]
deployment_name = os.environ["AZURE_CONVERSATIONS_DEPLOYMENT"]

# DefaultAzureCredential fonctionne en local et dans Azure sans modification du code.
credential = DefaultAzureCredential()

with ConversationAnalysisClient(endpoint, credential) as client:
    query = "Envoyer un e-mail à Carol au sujet de la réunion de demain"
    result = client.analyze_conversation(
        task={
            "kind": "Conversation",
            "analysisInput": {
                "conversationItem": {
                    "participantId": "1",
                    "id": "1",
                    "modality": "text",
                    "language": "en",
                    "text": query
                },
                "isLoggingEnabled": False
            },
            "parameters": {
                "projectName": project_name,
                "deploymentName": deployment_name,
                "verbose": True
            }
        }
    )

    print(f"Intention principale : {result['result']['prediction']['topIntent']}")
Voir sur GitHub
---
name: azure-ai-language-conversations-py
description: Analyze conversation intent and entities using the Azure AI Language Conversations Python SDK with best practices for authentication and error handling.
license: MIT
---

# Azure AI Language Conversations for Python

## System Prompt
You are an expert Python developer specializing in Azure AI Services and Natural Language Processing.
Your task is to help users implement Conversational Language Understanding (CLU) using the `azure-ai-language-conversations` SDK.

When responding to requests about Azure AI Language Conversations:
1. Always use the latest version of the `azure-ai-language-conversations` SDK.
2. Emphasize the use of `ConversationAnalysisClient` with `DefaultAzureCredential`.
3. Provide clear code examples demonstrating how to structure the conversation payload.
4. Handle exceptions properly.

## Authentication & Lifecycle

> **🔑 Two rules apply to every code sample below:**
>
> 1. **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.
> 2. **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.

`ConversationAnalysisClient` accepts a `TokenCredential` such as `DefaultAzureCredential`. Use the token credential — it works locally (Azure CLI / VS Code / Developer CLI) and in Azure (managed identity, workload identity) with no code change.

### Legacy: API Key (existing keyed deployments)

New code should use `DefaultAzureCredential`. Use `AzureKeyCredential` only if you have an existing keyed deployment that hasn't been migrated to Entra ID yet — for example, regulated environments still completing their Entra rollout.

```python
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.language.conversations import ConversationAnalysisClient

endpoint = os.environ["AZURE_CONVERSATIONS_ENDPOINT"]
key = os.environ["AZURE_CONVERSATIONS_KEY"]

with ConversationAnalysisClient(endpoint, AzureKeyCredential(key)) as client:
    # See "Basic Conversation Analysis" below for the analyze_conversation payload
    ...
```

## Best Practices
- **Pick sync OR async and stay consistent.** Do not mix `azure.ai.language.conversations` sync clients with `azure.ai.language.conversations.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 ConversationAnalysisClient(...) as client:` (sync) or `async with ConversationAnalysisClient(...) 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 portable auth across local dev and Azure (avoid API keys; they bypass Entra audit and rotation).
- Use environment variables for the endpoint, project name, and deployment name.
- Clearly map the `participantId` and `id` in the `conversationItem` payload.

## Examples

### Basic Conversation Analysis
```python
import os
from azure.identity import DefaultAzureCredential
from azure.ai.language.conversations import ConversationAnalysisClient

endpoint = os.environ["AZURE_CONVERSATIONS_ENDPOINT"]
project_name = os.environ["AZURE_CONVERSATIONS_PROJECT"]
deployment_name = os.environ["AZURE_CONVERSATIONS_DEPLOYMENT"]

# DefaultAzureCredential works locally and in Azure with no code change.
credential = DefaultAzureCredential()

with ConversationAnalysisClient(endpoint, credential) as client:
    query = "Send an email to Carol about the tomorrow's meeting"
    result = client.analyze_conversation(
        task={
            "kind": "Conversation",
            "analysisInput": {
                "conversationItem": {
                    "participantId": "1",
                    "id": "1",
                    "modality": "text",
                    "language": "en",
                    "text": query
                },
                "isLoggingEnabled": False
            },
            "parameters": {
                "projectName": project_name,
                "deploymentName": deployment_name,
                "verbose": True
            }
        }
    )

    print(f"Top intent: {result['result']['prediction']['topIntent']}")

Tous les fichiers

0 fichiers

Installer azure-ai-language-conversations-py

Téléchargez et décompressez les fichiers de compétences dans votre répertoire .claude/skills/.

Télécharger le ZIP

Clonez le dépôt et copiez les fichiers de compétence dans votre projet.

git clone https://github.com/microsoft/skills/tree/main/.github/plugins/azure-sdk-python/skills/azure-ai-language-conversations-py # Copy SKILL.md to your .claude/skills/ directory

Copier Copier
Configuration rapide: Copiez le dossier de la compétence dans .claude/skills/ Claude détectera automatiquement la compétence et l'utilisera

Compétences similaires

web-search
Heure mise à jour 29 juin 2026
webapp-testing
Heure mise à jour 29 juin 2026
lark-base
Heure mise à jour 5 juillet 2026
agentmail
Heure mise à jour 29 juin 2026
OR