FAQ Assist

FAQ Assist suggère des réponses pertinentes à des agents humains pendant une conversation avec un utilisateur final. Cette fonctionnalité peut être utilisée pour aider un agent humain à répondre aux questions courantes de l'utilisateur final lorsque celui-ci et l'utilisateur final sont en train de discuter.

Agent Assist suit la conversation et analyse les documents de questions fréquentes stockés dans des bases de connaissances pour suggérer des réponses aux questions de l'utilisateur final. Un agent humain peut examiner ces suggestions pendant le déroulement de la conversation et décider des suggestions à partager avec l'utilisateur final.

Ce document vous explique comment utiliser l'API pour mettre en œuvre FAQ Assist et obtenir des suggestions de cette fonctionnalité pendant 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 FAQ. Cet exemple utilise le document Questions fréquentes sur Cloud Storage 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.

Le document de FAQ peut se présenter sous l'un des trois formats suivants :

  • Une URL publique.
  • Chemin d'accès GCS d'un fichier .csv.
  • Un fichier .csv (que vous allez inclure dans la requête d'API).

Si votre document est au format .csv, il doit contenir deux colonnes: les questions fréquentes doivent être répertoriées dans la première colonne et les réponses à chaque question dans la deuxième colonne. Chaque question fréquentes et la réponse associée s'appelle une pair FAQ. Assurez-vous que le fichier .csv ne contient pas de ligne d'en-tête. Si votre document est une URL publique, il doit s'agir d'une page de FAQ répertoriant plusieurs paires de questions fréquentes.

Consultez la documentation sur les documents de base de connaissances pour obtenir des informations sur les bonnes pratiques.

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": "FAQ",
  "contentUri": "https://cloud.google.com/storage/docs/faq"
}

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.

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 :

{
  "displayName": "my-conversation-profile-display-name",
  "humanAgentAssistantConfig": {
    "humanAgentSuggestionConfig": {
      "featureConfigs": [
        {
          "suggestionFeature": {
            "type": "FAQ"
          },
          "queryConfig": {
            "knowledgeBaseQuerySource": {
              "knowledgeBases": ["projects/PROJECT_ID/knowledgeBases/KNOWLEDGE_BASE_ID"]
            }
          },
          "enableEventBasedSuggestion": false,
          "enableInlineSuggestion": true,
          "SuggestionTriggerSettings": {
             "noSmallTalk": true,
             "onlyEndUser": true,
           }
        }
      ]
    }
  }
}

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 le nouvel ID de votre 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 d'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 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 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, l'utilisateur final demande "Comment m'inscrire ?". La réponse contient une liste de réponses suggérées à la question de l'utilisateur final, ainsi qu'un score de confiance pour chacune. Toutes les réponses proviennent du document de base de connaissances des questions fréquentes que nous avons ajouté précédemment dans ce tutoriel. Le seuil de confiance fait référence au niveau de confiance du modèle indiquant que chaque suggestion de FAQ est pertinente pour la requête de l'agent. Un niveau de confiance plus élevé augmente la probabilité de réponse pertinente, mais peut avoir moins de réponses ou aucune réponse si aucune option disponible ne correspond à la valeur du seuil élevé. Nous vous recommandons de définir un score de confiance de départ de 0,4. Vous pouvez ajuster cette valeur ultérieurement pour améliorer vos résultats si nécessaire.

La réponse inclut également la source de la réponse, qui correspond au document de base de connaissances d'où provient la réponse. Vous devez fournir les réponses suggérées à votre agent humain, qui peut choisir de fournir ces informations à 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": "How do I sign up?",
    "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/fiiJBeHnQIa6Zx_DUKNlEg/messages/Rjv8ErKYS_yIqVR9SW4CpA",
    "content": "How may I help you?",
    "languageCode": "en-US",
    "participant": "PaZQyeiTQgCOyliHkZjs0Q",
    "participantRole": "HUMAN_AGENT",
    "createTime": "1970-01-01T00:00:00Z"
  },
  "humanAgentSuggestionResults": [
    {
      "suggestFaqAnswersResponse": {
        "faqAnswers": [
          {
            "answer": "Sign up for Cloud Storage by turning on the Cloud Storage service in the Google Cloud Platform Console.",
            "confidence": 0.07266401,
            "question": "How do I sign up?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/MTU0MzE0NDQwOTAwNzEyODU3NjA"
          },
          {
            "answer": "Consider storing your data in a multi-regional or dual-regional bucket location if high availability is a top requirement. This ensures that your data is stored in at least two geographically separated regions, providing continued availability even in the rare event of a region-wide outage, including ones caused by natural disasters. All data, regardless of storage class, is stored geo-redundantly in these types of locations, which allows you to use storage lifecycle management without giving up high availability.",
            "confidence": 0.06937904,
            "question": "How can I maximize the availability of my data?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/MzkwMjIyOTA0NDAwMjgxNjAwMA"
          },
          {
            "answer": "From the Cloud Storage documentation click \"Send feedback\" near the top right of the page. This will open a feedback form. Your comments will be reviewed by the Cloud Storage team.",
            "confidence": 0.069021806,
            "question": "How do I give product feedback?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/MTMxMjU2MDEwODA4NTc1OTE4MDg"
          },
          {
            "answer": "Read the Pricing page for detailed information on pricing, including how Cloud Storage calculates bandwidth and storage usage.",
            "confidence": 0.06681696,
            "question": "Where can I find pricing information?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/ODUxMzkxNTA2MjQzMDIwMzkwNA"
          },
          {
            "answer": "Use Object Versioning. The Object Versioning feature keeps an archived version of an object whenever you overwrite or delete the live version. If you accidentally delete an object, you can copy an archived version of it back to the live version. It's recommended that you use Object Versioning in conjunction with Object Lifecycle Management. Doing so ensures that you don't have multiple, unnecessary copies of an object, which are each subject to storage costs. Caution: Object Versioning does not protect your data if you delete the entire bucket. As an alternative, use object holds. When you place an object hold on an object, it cannot be deleted or overwritten.",
            "confidence": 0.06453417,
            "question": "How do I protect myself from accidental data deletion?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/MTc3MzcyODcwOTkyODQ5Nzk3MTI"
          },
          {
            "answer": "You can share an individual object with a user or group by adding an entry to that object's access control list (ACL) that grants the user or group READ permission. For step-by-step instructions, see Changing ACLs.",
            "confidence": 0.06336816,
            "question": "I want to let someone download an individual object. How do I do that?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/MTAxOTkyNTI4MjQ4NTY5ODU2MA"
          },
          {
            "answer": "You can simply use the gsutil tool to download the data, even without a Google account. You do not need to activate Cloud Storage or turn on billing for this purpose. You also do not need to create credentials or authenticate to Cloud Storage. The gsutil tool is best installed as part of the Google Cloud SDK package, but may also be downloaded and installed as a stand-alone product.",
            "confidence": 0.061990723,
            "question": "I am just trying to download or access some data that is freely available to the public. How can I do that?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/MTAyNDMyOTczMTkzNDA0NzQzNjg"
          },
          {
            "answer": "Certain types of content are not allowed on this service; please refer to the Terms of Services and Platform Policies for details. If you believe a piece of content is in violation of our policies, report it here (select See more products, then Google Cloud Storage & Cloud Bigtable).",
            "confidence": 0.060459033,
            "question": "I believe some content hosted on your service is inappropriate, how do I report it?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/NTYzMTYxMTMwMDkxMzA4NjQ2NA"
          },
          {
            "answer": "For most common Cloud Storage operations, you only need to specify the relevant bucket's name, not the project associated with the bucket. In general, you only need to specify a project identifier when creating a bucket or listing buckets in a project. For more information, see When to specify a project. To find which project contains a specific bucket: If you are searching over a moderate number of projects and buckets, use the Google Cloud Platform Console, select each project, and view the buckets it contains. Otherwise, go to the storage.bucket.get page in the API Explorer and enter the bucket's name in the bucket field. When you click Authorize and Execute, the associated project number appears as part of the response. To get the project name, use the project number in the following terminal command: gcloud projects list | grep [PROJECT_NUMBER]",
            "confidence": 0.05914715,
            "question": "I created a bucket, but don't remember which project I created it in. How can I find it?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/MTQ4NTQ5ODMzMzc3Njc4NjIyNzI"
          },
          {
            "answer": "Cloud Storage is designed for 99.999999999% (11 9's) annual durability, which is appropriate for even primary storage and business-critical applications. This high durability level is achieved through erasure coding that stores data pieces redundantly across multiple devices located in multiple availability zones. Objects written to Cloud Storage must be redundantly stored in at least two different availability zones before the write is acknowledged as successful. Checksums are stored and regularly revalidated to proactively verify that the data integrity of all data at rest as well as to detect corruption of data in transit. If required, corrections are automatically made using redundant data. Customers can optionally enable object versioning to add protection against accidental deletion.",
            "confidence": 0.05035359,
            "question": "How durable is my data in Cloud Storage?",
            "source": "projects/PROJECT_ID/knowledgeBases/NjQ2MzI1MDQwNTQ2MjYzODU5Mg/documents/NTMxOTA4MTAxMzQxMjg4ODU3Ng",
            "metadata": {
              "document_display_name": "my-document-display-name"
            },
            "answerRecord": "projects/PROJECT_ID/answerRecords/MzMyNTc2ODI5MTY5OTM5MjUxMg"
          }
        ],
        "latestMessage": "projects/PROJECT_ID/conversations/fiiJBeHnQIa6Zx_DUKNlEg/messages/Rjv8ErKYS_yIqVR9SW4CpA",
        "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

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.