Suggestion d'article

La fonctionnalité de suggestion d'article d'Agent Assist suit une conversation entre un agent humain et un utilisateur final, et fournit à l'agent humain des suggestions de documents pertinentes. Un agent humain peut examiner ces suggestions pendant la conversation et prendre une décision quant aux documents à lire ou à partager avec l'utilisateur final. Vous pouvez utiliser la suggestion d'articles pour aider un agent humain à comprendre et résoudre les problèmes de l'utilisateur final lors d'une conversation.

Agent Assist fournit des modèles de base de suggestions d'articles que vous pouvez utiliser pour suggérer des articles à vos agents. Si vous le souhaitez, vous pouvez entraîner un modèle personnalisé en utilisant vos propres données de conversation importées pour améliorer les performances. Si vous souhaitez entraîner un modèle de suggestion personnalisé à utiliser avec la suggestion d'articles, veuillez contacter votre représentant Google.

Ce document vous explique comment utiliser l'API pour implémenter la suggestion d'article et obtenir des suggestions de cette fonctionnalité lors de l'exécution. Vous avez la possibilité d'utiliser la console Agent Assist pour tester les résultats de la suggestion d'articles pendant la conception, mais vous devez appeler l'API directement pendant l'exécution. Consultez la section des tutoriels pour en savoir plus sur les tests de performances des fonctionnalités à l'aide de la console Assist de l'agent.

Avant de commencer

Avant de commencer ce guide, procédez comme suit:

  1. Activez l'API Dialogflow pour votre projet GCP.
  2. Activez l'API Data Labeling pour votre projet.

Configurer un profil de conversation

Pour obtenir des suggestions de Agent Assist, vous devez créer une base de connaissances contenant les documents importés, puis configurer un profil de conversation. Vous pouvez également effectuer ces actions à l'aide de la console Agent Assist si vous préférez ne pas appeler directement l'API.

Créer une base de connaissances

Avant de pouvoir importer des documents, vous devez d'abord créer une base de connaissances pour les y placer. Pour créer une base de connaissances, appelez la méthode create sur le type KnowledgeBase.

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : votre ID de projet GCP
  • KNOWLEDGE_BASE_DISPLAY_NAME : nom de base de connaissances souhaité

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/knowledgeBases

Corps JSON de la requête :

{
  "displayName": "KNOWLEDGE_BASE_DISPLAY_NAME"
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/knowledgeBases/NDA4MTM4NzE2MjMwNDUxMjAwMA",
  "displayName": "KNOWLEDGE_BASE_DISPLAY_NAME"
}

Le segment de chemin d'accès indiqué après knowledgeBases contient le nouvel ID de votre base de connaissances.

Python

def create_knowledge_base(project_id, display_name):
    """Creates a Knowledge base.

    Args:
        project_id: The GCP project linked with the agent.
        display_name: The display name of the Knowledge base."""
    from google.cloud import dialogflow_v2beta1 as dialogflow
    client = dialogflow.KnowledgeBasesClient()
    project_path = client.common_project_path(project_id)

    knowledge_base = dialogflow.KnowledgeBase(
        display_name=display_name)

    response = client.create_knowledge_base(
        parent=project_path,
        knowledge_base=knowledge_base
    )

    print('Knowledge Base created:\n')
    print('Display Name: {}\n'.format(response.display_name))
    print('Knowledge ID: {}\n'.format(response.name))

Créer un document de base de connaissances

Vous pouvez désormais ajouter des documents à la base de connaissances. Pour créer un document dans la base de connaissances, appelez la méthode create sur le type Document. Définissez KnowledgeType sur ARTICLE_SUGGESTION. Cet exemple utilise un fichier HTML contenant des informations de commande de retour qui a été importé dans un bucket Cloud Storage partagé publiquement. Lorsque vous configurez la suggestion d'article dans votre propre système, les documents doivent être dans l'un des formats suivants. Consultez la documentation des documents de base de connaissances pour en savoir plus sur les bonnes pratiques en matière de documents.

Formats de document de base de connaissances:

  • Fichier stocké dans un bucket GCS. Vous pouvez spécifier le chemin d'accès lorsque vous appelez l'API.
  • Contenu textuel d'un document, que vous pouvez envoyer dans une requête API.
  • URL publique.

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : votre ID de projet GCP
  • KNOWLEDGE_BASE_ID : ID de votre base de connaissances, renvoyé par une requête précédente
  • DOCUMENT_DISPLAY_NAME : nom de document de base de connaissances souhaité

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/knowledgeBases/KNOWLEDGE_BASE_ID/documents

Corps JSON de la requête :

{
  "displayName": "DOCUMENT_DISPLAY_NAME",
  "mimeType": "text/html",
  "knowledgeTypes": "ARTICLE_SUGGESTION",
  "contentUri": "gs://agent-assist-public-examples/public_article_suggestion_example_returns.html"
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/operations/ks-add_document-MzA5NTY2MTc5Mzg2Mzc5NDY4OA"
}

La réponse est une opération de longue durée que vous pouvez interroger pour vérifier l'avancement.

Python

def create_document(project_id, knowledge_base_id, display_name, mime_type,
                    knowledge_type, content_uri):
    """Creates a Document.

    Args:
        project_id: The GCP project linked with the agent.
        knowledge_base_id: Id of the Knowledge base.
        display_name: The display name of the Document.
        mime_type: The mime_type of the Document. e.g. text/csv, text/html,
            text/plain, text/pdf etc.
        knowledge_type: The Knowledge type of the Document. e.g. FAQ,
            EXTRACTIVE_QA.
        content_uri: Uri of the document, e.g. gs://path/mydoc.csv,
            http://mypage.com/faq.html."""
    from google.cloud import dialogflow_v2beta1 as dialogflow
    client = dialogflow.DocumentsClient()
    knowledge_base_path = dialogflow.KnowledgeBasesClient.knowledge_base_path(
        project_id, knowledge_base_id)

    document = dialogflow.Document(
        display_name=display_name, mime_type=mime_type,
        content_uri=content_uri)

    document.knowledge_types.append(
        getattr(dialogflow.Document.KnowledgeType, knowledge_type)
    )

    response = client.create_document(parent=knowledge_base_path, document=document)
    print('Waiting for results...')
    document = response.result(timeout=120)
    print('Created Document:')
    print(' - Display Name: {}'.format(document.display_name))
    print(' - Knowledge ID: {}'.format(document.name))
    print(' - MIME Type: {}'.format(document.mime_type))
    print(' - Knowledge Types:')
    for knowledge_type in document.knowledge_types:
        print('    - {}'.format(KNOWLEDGE_TYPES[knowledge_type]))
    print(' - Source: {}\n'.format(document.content_uri))

Créer un profil de conversation

Un profil de conversation configure un ensemble de paramètres qui contrôlent les suggestions adressées à un agent au cours d'une conversation. Les étapes suivantes permettent de créer ConversationProfile avec un objet HumanAgentAssistantConfig. Vous pouvez également effectuer ces actions à l'aide de la console Agent Assist si vous préférez ne pas appeler directement l'API.

Nous vous recommandons de définir un seuil de confiance initial de 0,1. Si nécessaire, vous pouvez augmenter le seuil au-delà de la plage recommandée. l'augmentation du seuil permet d'améliorer la précision et de réduire les résultats (moins de suggestions) ; la diminution du seuil entraîne une précision moindre et une couverture plus élevée (plus de suggestions).

API REST et ligne de commande

Pour créer un profil de conversation, appelez la méthode create sur la ressource ConversationProfile.

noSmallTalk: si la valeur est true, les suggestions ne seront pas déclenchées après les messages de petite envergure (par exemple, "bonjour", "comment allez-vous", etc.). Si la valeur est false, les suggestions sont déclenchées après les messages d'échange de politesse.

onlyEndUser: si la valeur est true, les suggestions ne sont déclenchées qu'après les messages de l'utilisateur final. Si la valeur est false, les suggestions seront déclenchées après les messages de l'utilisateur final et de l'agent humain.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet GCP
  • KNOWLEDGE_BASE_ID : ID de votre base de connaissances

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/conversationProfiles

Corps JSON de la requête :

{
  "name": "projects/PROJECT_ID/conversationProfiles/CONVERSATION_PROFILE_ID",
  "displayName": "my-conversation-profile-display-name",
  "humanAgentAssistantConfig": {
    "notificationConfig": {},
    "humanAgentSuggestionConfig": {
      "featureConfigs": [
        {
          "enableInlineSuggestion": true,
        "SuggestionTriggerSettings": {
             "noSmallTalk": true,
             "onlyEndUser": true,
           }
          "suggestionFeature": {
            "type": "ARTICLE_SUGGESTION"
          },
          "queryConfig": {
            "knowledgeBaseQuerySource": {
              "knowledgeBases": [
                "projects/PROJECT_ID/knowledgeBases/KNOWLEDGE_BASE_ID"
              ]
            }
          }
        }
      ]
    }
  },
  "sttConfig": {},
  "languageCode": "en-US"
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/conversationProfiles/CONVERSATION_PROFILE_ID",
  "displayName": "my-conversation-profile-display-name",
  "humanAgentAssistantConfig": {
    ...
  }
}

Le segment de chemin d'accès indiqué après conversationProfiles contient l'ID du nouveau profil de conversation.

Python

def create_conversation_profile_article_faq(
        project_id,
        display_name,
        article_suggestion_knowledge_base_id=None,
        faq_knowledge_base_id=None):
    """Creates a conversation profile with given values

    Args: project_id:  The GCP project linked with the conversation profile.
        display_name: The display name for the conversation profile to be
        created.
        article_suggestion_knowledge_base_id: knowledge base id for article
        suggestion.
        faq_knowledge_base_id: knowledge base id for faq."""

    client = dialogflow.ConversationProfilesClient()
    project_path = client.common_project_path(project_id)

    conversation_profile = {
        'display_name': display_name,
        'human_agent_assistant_config': {
            'human_agent_suggestion_config': {
                'feature_configs': []
            }
        },
        'language_code': 'en-US'
    }

    if article_suggestion_knowledge_base_id is not None:
        as_kb_path = dialogflow.KnowledgeBasesClient.knowledge_base_path(
            project_id, article_suggestion_knowledge_base_id)
        feature_config = {
            'suggestion_feature': {
                'type_': 'ARTICLE_SUGGESTION'
            },
            'suggestion_trigger_settings': {
                'no_small_talk': True,
                'only_end_user': True,
            },
            'query_config': {
                'knowledge_base_query_source': {
                    'knowledge_bases': [as_kb_path]
                },
                'max_results': 3
            },
        }
        conversation_profile['human_agent_assistant_config'][
            'human_agent_suggestion_config']['feature_configs'].append(
                feature_config)
    if faq_knowledge_base_id is not None:
        faq_kb_path = dialogflow.KnowledgeBasesClient.knowledge_base_path(
            project_id, faq_knowledge_base_id)
        feature_config = {
            'suggestion_feature': {
                'type_': 'FAQ'
            },
            'suggestion_trigger_settings': {
                'no_small_talk': True,
                'only_end_user': True,
            },
            'query_config': {
                'knowledge_base_query_source': {
                    'knowledge_bases': [faq_kb_path]
                },
                'max_results': 3
            },
        }
        conversation_profile['human_agent_assistant_config'][
            'human_agent_suggestion_config']['feature_configs'].append(
                feature_config)

    response = client.create_conversation_profile(
        parent=project_path, conversation_profile=conversation_profile)

    print('Conversation Profile created:')
    print('Display Name: {}'.format(response.display_name))
    # Put Name is the last to make it easier to retrieve.
    print('Name: {}'.format(response.name))
    return response

Gérer les conversations lors de l'exécution

Créer une conversation

Lorsqu'un dialogue commence entre un utilisateur final et un agent humain ou virtuel, vous créez une conversation. Pour afficher les suggestions, vous devez également créer un participant utilisateur final et un participant d'agent humain, puis les ajouter à la conversation. Les sections suivantes vous guident tout au long de ce processus.

Vous devez d'abord créer une conversation:

API REST et ligne de commande

Pour créer une conversation, appelez la méthode create sur la ressource Conversation.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet GCP
  • CONVERSATION_PROFILE_ID: ID obtenu lors de la création du profil de conversation

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/conversations

Corps JSON de la requête :

{
  "conversationProfile": "projects/PROJECT_ID/conversationProfiles/CONVERSATION_PROFILE_ID",
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/conversations/CONVERSATION_ID",
  "lifecycleState": "IN_PROGRESS",
  "conversationProfile": "projects/PROJECT_ID/conversationProfiles/CONVERSATION_PROFILE_ID",
  "startTime": "2018-11-05T21:05:45.622Z"
}

Le segment de chemin d'accès après conversations contient le nouvel ID de la conversation.

Python

def create_conversation(project_id, conversation_profile_id):
    """Creates a conversation with given values

    Args:
        project_id:  The GCP project linked with the conversation.
        conversation_profile_id: The conversation profile id used to create
        conversation."""

    client = dialogflow.ConversationsClient()
    conversation_profile_client = dialogflow.ConversationProfilesClient()
    project_path = client.common_project_path(project_id)
    conversation_profile_path = (
        conversation_profile_client.conversation_profile_path(
            project_id, conversation_profile_id))
    conversation = {'conversation_profile': conversation_profile_path}
    response = client.create_conversation(parent=project_path,
                                          conversation=conversation)

    print('Life Cycle State: {}'.format(response.lifecycle_state))
    print('Conversation Profile Name: {}'.format(
        response.conversation_profile))
    print('Name: {}'.format(response.name))
    return response

Créer un participant d'utilisateur final

Vous devez ajouter à la conversation des participants à la fois à l'utilisateur final et à l'agent humain pour voir les suggestions. Commencez par ajouter le participant de l'utilisateur final à la conversation:

API REST et ligne de commande

Pour créer un participant utilisateur final, appelez la méthode create sur la ressource Participant.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet GCP
  • CONVERSATION_ID: ID de votre conversation

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/conversations/CONVERSATION_ID/participants

Corps JSON de la requête :

{
  "role": "END_USER",
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/conversations/CONVERSATION_ID/participants/PARTICIPANT_ID",
  "role": "END_USER"
}

Le segment de chemin d'accès indiqué après participants contient le nouvel ID de participant de l'utilisateur final.

Python

def create_participant(project_id, conversation_id, role):
    """Creates a participant in a given conversation.

    Args:
        project_id: The GCP project linked with the conversation profile.
        conversation_id: Id of the conversation.
        participant: participant to be created."""

    client = dialogflow.ParticipantsClient()
    conversation_path = dialogflow.ConversationsClient.conversation_path(
        project_id, conversation_id)
    if role in ROLES:
        response = client.create_participant(parent=conversation_path,
                                             participant={'role': role})
        print('Participant Created.')
        print('Role: {}'.format(response.role))
        print('Name: {}'.format(response.name))

        return response

Créer un participant d'agent humain

Pour ajouter un participant d'agent humain à la conversation:

API REST et ligne de commande

Pour créer un participant d'agent humain, appelez la méthode create sur la ressource Participant.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet GCP
  • CONVERSATION_ID: ID de votre conversation

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/conversations/CONVERSATION_ID/participants

Corps JSON de la requête :

{
  "role": "HUMAN_AGENT",
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/conversations/CONVERSATION_ID/participants/PARTICIPANT_ID",
  "role": "HUMAN_AGENT"
}

Le segment de chemin d'accès indiqué après participants contient l'ID du nouveau participant de votre agent humain.

Python

def create_participant(project_id, conversation_id, role):
    """Creates a participant in a given conversation.

    Args:
        project_id: The GCP project linked with the conversation profile.
        conversation_id: Id of the conversation.
        participant: participant to be created."""

    client = dialogflow.ParticipantsClient()
    conversation_path = dialogflow.ConversationsClient.conversation_path(
        project_id, conversation_id)
    if role in ROLES:
        response = client.create_participant(parent=conversation_path,
                                             participant={'role': role})
        print('Participant Created.')
        print('Role: {}'.format(response.role))
        print('Name: {}'.format(response.name))

        return response

Ajouter et analyser un message de l'agent humain

Chaque fois que l'un des participants saisit un message dans la conversation, vous devez l'envoyer à l'API pour traitement. Les suggestions d'Agent Assist sont basées sur l'analyse des messages des agents humains et des utilisateurs finaux. Dans l'exemple suivant, l'agent humain démarre la conversation en demandant "Comment puis-je vous aider ?". Aucune suggestion n'a encore été renvoyée dans la réponse.

API REST et ligne de commande

Pour ajouter et analyser un message d'agent humain dans la conversation, appelez la méthode analyzeContent sur la ressource Participant.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet GCP
  • CONVERSATION_ID: ID de votre conversation
  • PARTICIPANT_ID: ID de votre participant d'agent humain

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/conversations/CONVERSATION_ID/participants/PARTICIPANT_ID:analyzeContent

Corps JSON de la requête :

{
  "textInput": {
    "text": "How may I help you?",
    "languageCode": "en-US"
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

      {
        "message": {
          "name": "projects/PROJECT_ID/conversations/CONVERSATION_ID/messages/MESSAGE_ID",
          "content": "How may I help you?",
          "languageCode": "en-US",
          "participant": "PARTICIPANT_ID",
          "participantRole": "HUMAN_AGENT",
          "createTime": "2020-02-13T00:01:30.683Z"
        },
        "humanAgentSuggestionResults": [
          {
            "suggestArticlesResponse": {
              "latestMessage": "projects/PROJECT_ID/conversations/CONVERSATION_ID/messages/MESSAGE_ID",
              "contextSize": 1
            }
          }
        ]
      }
    }
  ]
}

Python

def analyze_content_text(project_id, conversation_id, participant_id, text):
    """Analyze text message content from a participant.

    Args:
        project_id: The GCP project linked with the conversation profile.
        conversation_id: Id of the conversation.
        participant_id: Id of the participant.
        text: the text message that participant typed."""

    client = dialogflow.ParticipantsClient()
    participant_path = client.participant_path(project_id, conversation_id,
                                               participant_id)
    text_input = {'text': text, 'language_code': 'en-US'}
    response = client.analyze_content(participant=participant_path,
                                      text_input=text_input)
    print('AnalyzeContent Response:')
    print('Reply Text: {}'.format(response.reply_text))

    for suggestion_result in response.human_agent_suggestion_results:
        if suggestion_result.error is not None:
            print('Error: {}'.format(suggestion_result.error.message))
        if suggestion_result.suggest_articles_response:
            for answer in suggestion_result.suggest_articles_response.article_answers:
                print('Article Suggestion Answer: {}'.format(answer.title))
                print('Answer Record: {}'.format(answer.answer_record))
        if suggestion_result.suggest_faq_answers_response:
            for answer in suggestion_result.suggest_faq_answers_response.faq_answers:
                print('Faq Answer: {}'.format(answer.answer))
                print('Answer Record: {}'.format(answer.answer_record))
        if suggestion_result.suggest_smart_replies_response:
            for answer in suggestion_result.suggest_smart_replies_response.smart_reply_answers:
                print('Smart Reply: {}'.format(answer.reply))
                print('Answer Record: {}'.format(answer.answer_record))

    for suggestion_result in response.end_user_suggestion_results:
        if suggestion_result.error:
            print('Error: {}'.format(suggestion_result.error.message))
        if suggestion_result.suggest_articles_response:
            for answer in suggestion_result.suggest_articles_response.article_answers:
                print('Article Suggestion Answer: {}'.format(answer.title))
                print('Answer Record: {}'.format(answer.answer_record))
        if suggestion_result.suggest_faq_answers_response:
            for answer in suggestion_result.suggest_faq_answers_response.faq_answers:
                print('Faq Answer: {}'.format(answer.answer))
                print('Answer Record: {}'.format(answer.answer_record))
        if suggestion_result.suggest_smart_replies_response:
            for answer in suggestion_result.suggest_smart_replies_response.smart_reply_answers:
                print('Smart Reply: {}'.format(answer.reply))
                print('Answer Record: {}'.format(answer.answer_record))

    return response

Ajouter un message de l'utilisateur final et recevoir des suggestions

En réponse à l'agent humain, l'utilisateur final dit : "Je souhaite retourner ma commande". Cette fois, la réponse de l'API contient un document suggéré avec le score de confiance associé. Plus tôt dans ce tutoriel, nous avons ajouté un document de base de connaissances à la base de connaissances, et ce document a été renvoyé. Le score de confiance varie de 0 à 1. Des valeurs plus élevées indiquent une plus grande probabilité que le document soit pertinent pour la conversation. Un extrait contenant les 100 premiers caractères du document est également renvoyé. L'extrait peut aider un agent humain à déterminer rapidement si le document est utile. Nous vous recommandons de fournir ces informations à votre agent humain, qui pourra choisir de partager le document recommandé avec l'utilisateur final.

API REST et ligne de commande

Pour ajouter et analyser un message d'utilisateur final pour la conversation, appelez la méthode analyzeContent sur la ressource Participant.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet GCP
  • CONVERSATION_ID: ID de votre conversation
  • PARTICIPANT_ID: ID du participant de l'utilisateur final

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/conversations/CONVERSATION_ID/participants/PARTICIPANT_ID:analyzeContent

Corps JSON de la requête :

{
  "textInput": {
    "text": "I want to return my order.",
    "languageCode": "en-US"
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "message": {
    "name": "projects/PROJECT_ID/conversations/CONVERSATION_ID/messages/MESSAGE_ID",
    "content": "I want to return my order.",
    "languageCode": "en-US",
    "participant": "PARTICIPANT_ID",
    "participantRole": "END_USER",
    "createTime": "2020-02-13T00:07:35.925Z"
  },
  "humanAgentSuggestionResults": [
    {
      "suggestArticlesResponse": {
        "articleAnswers": [
          {
            "title": "Return an order",
            "uri": "gs://agent-assist-public-examples/public_article_suggestion_example_returns.html",
            "snippets": [
              "\u003cb\u003eReturn\u003c/b\u003e an \u003cb\u003eorder\u003c/b\u003e. Follow the steps below for Made-up Store \u003cb\u003ereturns\u003c/b\u003e. At this time, \nwe don't offer exchanges. In most cases, you can drop off \u003cb\u003ereturns\u003c/b\u003e at any Made-up\n ..."
            ],
            "metadata": {
              "title": "Return an order",
              "snippet": "\n  \n\n\u003ch1\u003eReturn an order\u003c/h1\u003e \nFollow the steps below for Made-up Store returns. At this time, we do...",
              "document_display_name": "my-kdoc"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/ANSWER_RECORD_ID"
          }
        ],
        "latestMessage": "projects/PROJECT_ID/conversations/CONVERSATION_ID/messages/MESSAGE_ID",
        "contextSize": 2
      }
    }
  ]
}

Python

def analyze_content_text(project_id, conversation_id, participant_id, text):
    """Analyze text message content from a participant.

    Args:
        project_id: The GCP project linked with the conversation profile.
        conversation_id: Id of the conversation.
        participant_id: Id of the participant.
        text: the text message that participant typed."""

    client = dialogflow.ParticipantsClient()
    participant_path = client.participant_path(project_id, conversation_id,
                                               participant_id)
    text_input = {'text': text, 'language_code': 'en-US'}
    response = client.analyze_content(participant=participant_path,
                                      text_input=text_input)
    print('AnalyzeContent Response:')
    print('Reply Text: {}'.format(response.reply_text))

    for suggestion_result in response.human_agent_suggestion_results:
        if suggestion_result.error is not None:
            print('Error: {}'.format(suggestion_result.error.message))
        if suggestion_result.suggest_articles_response:
            for answer in suggestion_result.suggest_articles_response.article_answers:
                print('Article Suggestion Answer: {}'.format(answer.title))
                print('Answer Record: {}'.format(answer.answer_record))
        if suggestion_result.suggest_faq_answers_response:
            for answer in suggestion_result.suggest_faq_answers_response.faq_answers:
                print('Faq Answer: {}'.format(answer.answer))
                print('Answer Record: {}'.format(answer.answer_record))
        if suggestion_result.suggest_smart_replies_response:
            for answer in suggestion_result.suggest_smart_replies_response.smart_reply_answers:
                print('Smart Reply: {}'.format(answer.reply))
                print('Answer Record: {}'.format(answer.answer_record))

    for suggestion_result in response.end_user_suggestion_results:
        if suggestion_result.error:
            print('Error: {}'.format(suggestion_result.error.message))
        if suggestion_result.suggest_articles_response:
            for answer in suggestion_result.suggest_articles_response.article_answers:
                print('Article Suggestion Answer: {}'.format(answer.title))
                print('Answer Record: {}'.format(answer.answer_record))
        if suggestion_result.suggest_faq_answers_response:
            for answer in suggestion_result.suggest_faq_answers_response.faq_answers:
                print('Faq Answer: {}'.format(answer.answer))
                print('Answer Record: {}'.format(answer.answer_record))
        if suggestion_result.suggest_smart_replies_response:
            for answer in suggestion_result.suggest_smart_replies_response.smart_reply_answers:
                print('Smart Reply: {}'.format(answer.reply))
                print('Answer Record: {}'.format(answer.answer_record))

    return response

Terminer la conversation

À la fin de la conversation, utilisez l'API pour la terminer.

API REST et ligne de commande

Pour terminer la conversation, appelez la méthode complete sur la ressource conversations.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet GCP
  • CONVERSATION_ID: ID obtenu lors de la création de la conversation

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/conversations/CONVERSATION_ID:complete

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/conversations/CONVERSATION_ID",
  "lifecycleState": "COMPLETED",
  "conversationProfile": "projects/PROJECT_ID/conversationProfiles/CONVERSATION_PROFILE_ID",
  "startTime": "2018-11-05T21:05:45.622Z",
  "endTime": "2018-11-06T03:50:26.930Z"
}

Python

def complete_conversation(project_id, conversation_id):
    """Completes the specified conversation. Finished conversations are purged from the database after 30 days.

    Args:
        project_id: The GCP project linked with the conversation.
        conversation_id: Id of the conversation."""

    client = dialogflow.ConversationsClient()
    conversation_path = client.conversation_path(project_id, conversation_id)
    conversation = client.complete_conversation(name=conversation_path)
    print('Completed Conversation.')
    print('Life Cycle State: {}'.format(conversation.lifecycle_state))
    print('Conversation Profile Name: {}'.format(
        conversation.conversation_profile))
    print('Name: {}'.format(conversation.name))
    return conversation

Options de requête de l'API

Les sections ci-dessus montrent comment créer un ConversationProfile simple afin de recevoir des suggestions. Les sections suivantes décrivent certaines fonctionnalités facultatives que vous pouvez mettre en œuvre lors d'une conversation.

Notifications de suggestion Pub/Sub

Dans les sections ci-dessus, le ConversationProfil n'a été créé qu'avec un assistant d'agent humain. Au cours de la conversation, vous devez appeler l'API pour recevoir des suggestions après l'ajout de chaque message à la conversation. Si vous préférez recevoir des événements de notification pour des suggestions, vous pouvez définir le champ notificationConfig lors de la création du profil de conversation. Cette option utilise Cloud Pub/Sub pour envoyer des notifications de suggestion à votre application lorsque la conversation se poursuit et de nouvelles suggestions sont disponibles.