Remarques :

Créez un chatbot d'entreprise avec Oracle Digital Assistant, OCI Data Science, LangChain et Oracle Database 23ai

Introduction

Dans le paysage numérique actuel, les chatbots évoluent pour devenir plus intelligents, réactifs et capables de gérer des interactions complexes. Dans ce tutoriel, nous étudions la création d'un chatbot nouvelle génération en exploitant la puissance des fonctionnalités de data science d'Oracle Cloud Infrastructure (OCI), telles que les actions rapides d'IA et le déploiement de modèles, Mistral-7B-Instruct-v0.2, Oracle Database 23ai, LangChain et Oracle Digital Assistant. Chacune de ces technologies apporte des atouts uniques à la table, nous permettant de créer un chatbot qui comprend et répond non seulement aux requêtes des utilisateurs avec une précision remarquable, mais offre également une expérience conversationnelle transparente et attrayante.

L'une des caractéristiques remarquables d'Oracle Database 23ai est ses fonctionnalités avancées de recherche vectorielle. Cette technologie permet une récupération efficace de l'information en convertissant le texte en vecteurs à haute dimension, qui sont ensuite comparés pour la pertinence. Lorsqu'elle est intégrée au pipeline de génération augmentée de récupération (RAG), la recherche vectorielle d'Oracle Database 23ai améliore la capacité du chatbot à accéder aux informations les plus pertinentes et à les fournir à partir de vastes ensembles de données. Cela garantit que les réponses générées sont non seulement précises sur le plan contextuel, mais également très pertinentes pour la requête de l'utilisateur.

Oracle Digital Assistant améliore encore les fonctionnalités du chatbot en fournissant une plate-forme robuste pour la création, le déploiement et la gestion de solutions d'IA conversationnelle. Il propose des connecteurs prédéfinis, une compréhension du langage naturel (NLU) et une gestion du dialogue, qui rationalisent le processus de développement et garantissent une expérience utilisateur fluide. La combinaison d'Oracle Digital Assistant et du pipeline RAG permet au chatbot de gérer des interactions complexes et de maintenir un flux de conversation naturel, améliorant ainsi l'engagement et la satisfaction des utilisateurs.

En tirant parti de la synergie entre Oracle Database 23ai et Oracle Digital Assistant dans le pipeline RAG, les développeurs peuvent créer un chatbot qui excelle à la fois dans la précision de l'extraction et la fluidité de la conversation. Cette approche intégrée réduit non seulement le temps et les efforts nécessaires pour créer des chatbots sophistiqués, mais se traduit également par une solution évolutive, efficace et capable de fournir des expériences utilisateur supérieures. Que vous soyez un développeur, un passionné de technologie ou un chef d'entreprise cherchant à améliorer l'engagement client, ce tutoriel vous fournira les connaissances et les outils nécessaires pour créer un chatbot avancé qui se démarque dans l'arène numérique bondée.

Pour consulter la procédure pas à pas, reportez-vous à Référentiel GitHub d'échantillons AI.

Cas d'emploi

Voici quelques exemples de cas d'emploi où cela peut être utile :

Avantages de la recherche vectorielle Oracle AI

Oracle Database est un référentiel leader de données opérationnelles et d'entreprise. Les applications d'entreprise doivent généralement rechercher une combinaison de données d'entreprise et de données non structurées. Par exemple, un site Web de vente au détail peut comporter des recherches basées sur une description de produit en langage naturel et une image de produit cible, ainsi que d'autres filtres, tels que le prix, l'emplacement du magasin, le fabricant et la disponibilité actuelle. Cette recherche nécessite la recherche simultanée de données de catalogue non structurées (description et image du produit), de données de catalogue structurées (prix, emplacement de stockage et fabricant) ainsi que de données transactionnelles en temps réel (comme le stock actuel).

Présentation de la solution d'architecture de haut niveau

image

Figure : Architecture de haut niveau du pipeline RAG

Le diagramme suivant illustre l'architecture et le workflow de création d'un chatbot avancé à l'aide de Mistral-7B-Instruct-v0.2, d'Oracle Database 23ai, RAG, LangChain et d'Oracle Digital Assistant. Voici les étapes détaillées de l'architecture suivante.

  1. Interaction utilisateur : l'utilisateur envoie une demande au chatbot via l'interface d'Oracle Digital Assistant.

  2. Gestion des demandes : Oracle Digital Assistant reçoit la demande et la transmet à l'infrastructure OCI Data Science.

  3. Traitement des requêtes : 2 étapes sont impliquées.

    • Dans OCI Data Science, la demande est acheminée vers LangChain, qui sert d'orchestrateur pour la gestion de l'interaction entre différents déploiements de modèle.
    • LangChain traite la demande et identifie la nécessité d'extraire des informations à partir de documents externes et de données d'entreprise.

  4. Vectorisation : cette étape implique les sous-processus suivants :

    • La demande est envoyée à un déploiement de modèle d'intégration, qui transforme la requête en une représentation vectorielle haute dimension.
    • Cette requête vectorisée est ensuite envoyée à Oracle Database 23ai pour la recherche vectorielle.

  5. Extraction de données : cette étape implique les sous-processus suivants :

    • Oracle Database 23ai effectue une recherche de similarité sur des données non structurées sous forme de documents au format PDF et HTML et combine cette recherche avec une recherche régulière sur d'autres données métier de la base de données.
    • Les documents ou blocs pertinents sont récupérés et seront envoyés à l'étape suivante pour traitement ultérieur.

  6. Réorganisation :

    • La réponse générée peut être affinée davantage par un déploiement de modèle de rang supérieur.
    • Le modèle de reclassement évalue et classe les réponses pour s'assurer que la réponse la plus pertinente et la plus précise est sélectionnée.

  7. Interroger les modèles externes : à cette étape, les données sont extraites et une réponse est générée.

    • Les informations extraites sont utilisées pour générer une requête pour le déploiement de modèle Mistral-7B-Instruct-v0.2 provisionné à l'aide des fonctionnalités d'actions rapides d'IA dans OCI Data Science.
    • Le modèle Mistral-7B-Instruct-v0.2 traite la requête et génère une réponse en fonction de son entraînement et du contexte extrait.

  8. Génération de réponse : la réponse affinée est renvoyée à LangChain, qui consolide la sortie finale.

  9. Renvoi de la réponse à l'utilisateur :

    • La réponse finale est renvoyée à l'assistant numérique.
    • Oracle Digital Assistant fournit ensuite la réponse à l'utilisateur.

Objectifs

Prérequis

Prérequis clés à configurer avant de pouvoir exécuter le processus d'affinage distribué sur OCI Data Science Service.

Tâche 1 : déployer les modèles requis

Tâche 1.1 : Déployer le modèle Mistral-7B-Instruct-v0.2

Nous tirerons parti de la fonctionnalité de déploiement de modèle d'actions rapides d'IA pour déployer Mistral-7B-Instruct-v0.2 en quelques clics. Le déploiement du modèle d'actions rapides d'IA aide les utilisateurs à déployer le modèle Mistral-7B-Instruct-v0.2 en quelques clics et à fournir aux utilisateurs une adresse.

image

image

Tâche 1.2 : Déployer le modèle d'intégration Jina

  1. Dans le bloc-notes, copiez les fichiers de modèle Jine Embedding de https://huggingface.co/jinaai/jina-embeddings-v2-base-en/tree/main vers le répertoire ads_embedding_model_dir.

  2. Téléchargez le fichier score.py vers le répertoire en cours (par exemple, /home/datascience/).

  3. Exécutez le code suivant.

    import tempfile
import ads
from ads.model.generic_model import GenericModel
from config import CONDA_PACK_PATH, LOG_GROUP_ID, EMBEDDING_MODEL_ACCESS_LOG_LOG_ID, EMBEDDING_MODEL_PREDICT_LOG_LOG_ID
ads.set_auth("resource_principal")
embedding_model = GenericModel( model_file_name="model-w-mean-pooling.onnx" ,artifact_dir="ads_embedding_model_dir",estimator=None, serialize=False)
embedding_model.summary_status()

embedding_model.prepare(
        inference_conda_env=CONDA_PACK_PATH,
        inference_python_version = "3.9",
        model_file_name="model.onnx",
        score_py_uri= "score.py",
        force_overwrite=True
    )
op=embedding_model.verify(['Can you please give some overview on Oracle Database 23.4'])
print(op['embeddings']);

embedding_model.save(display_name="jina-embedding")
embedding_md = embedding_model.deploy(
    display_name = "Jina Embedding Model Deployment",
    deployment_log_group_id = LOG_GROUP_ID,
    deployment_access_log_id = EMBEDDING_MODEL_ACCESS_LOG_LOG_ID,
    deployment_predict_log_id = EMBEDDING_MODEL_PREDICT_LOG_LOG_ID,
)
output = embedding_md.predict(['Can you please give some overview on Oracle Database 23.4'])
print(output['embeddings']);

Tâche 1.3 : Déployer le modèle Bge-Reranker

Exécutez le code suivant.

import ads
from FlagEmbedding import FlagReranker
from ads.model.generic_model import GenericModel
from ads.model.model_metadata import MetadataCustomCategory
from config import CONDA_PACK_PATH, LOG_GROUP_ID, RERANKER_MODEL_ACCESS_LOG_LOG_ID, RERANKER_MODEL_PREDICT_LOG_LOG_ID

#
# This custom class wrap the reranker model
#
class Reranker:
    def __init__(self, model_id):
        self.model_id = model_id
        self.reranker = FlagReranker(self.model_id, use_fp16=True)

    def predict(self, x):
        # x is expected as a list of list of str
        # [["x1", "x2"]] -> y = [score12]
        scores = self.reranker.compute_score(x)

        return scores
reranker_model = Reranker(model_id="BAAI/bge-reranker-large")
reranker_payload = [
    ["what is panda?", "It is an animal living in China. In the future model input will be serialized by.In the future model input will be serialized by.In the future model input will be serialized by"],
    ["what is panda?", "The giant panda is a bear species endemic to China.In the future model input will be serialized by.In the future model input will be serialized by.In the future model input will be serialized by.In the future model input will be serialized by"],
]
reranker_model.predict(reranker_payload)

reranker_generic_model = GenericModel(estimator=reranker_model, artifact_dir="./reranker_dir")
reranker_generic_model.summary_status()
reranker_generic_model.prepare(
    reload=False,
    inference_conda_env=CONDA_PACK_PATH,
    inference_python_version="3.9",
    model_file_name="reranker.pkl",
    force_overwrite=True
)

reranker_generic_model.save(
    display_name="reranker2-baai-large",
    bucket_uri="oci://reranker_bucket@bigdatadatasciencelarge/reranker/",
    ignore_introspection=True
)

reranker_md = reranker_generic_model.deploy(
    display_name = "reranker2-baai-large",
    deployment_log_group_id = LOG_GROUP_ID,
    deployment_access_log_id = RERANKER_MODEL_ACCESS_LOG_LOG_ID,
    deployment_predict_log_id = RERANKER_MODEL_PREDICT_LOG_LOG_ID,
    deployment_instance_shape="VM.Standard2.4",
)

Tâche 2 : configurer Oracle Database 23ai

Nous utiliserons les dernières fonctionnalités d'Oracle Database 23ai, en particulier la recherche vectorielle Oracle AI, pour notre cas d'utilisation. Dans ce scénario, nous allons importer les incorporations générées à partir de l'ensemble de données dans Oracle Database 23ai. Lorsqu'un utilisateur interroge à l'aide de la RAG, la réponse est améliorée en fournissant aux LLM un contexte supplémentaire. Le diagramme suivant présente certains des avantages de l'utilisation d'Oracle Database 23ai.

image

Figure : Illustration de la fonctionnalité de recherche d'Oracle Database 23ai (source)

Cela augmentera leurs connaissances, conduisant à des réponses plus précises et pertinentes aux demandes du client. Pour configurer Oracle Database 23ai, suivez les options mentionnées.

Nous utiliserons une instance hébergée d'Oracle Database 23ai pour démontrer les fonctionnalités puissantes d'Oracle AI Vector Search.

Tâche 3 : analyse, découpage et intégration de stockage dans Oracle Database 23ai

Le fragment de code suivant offre un aperçu général de l'analyse du document, de sa conversion en blocs, puis du stockage de l'intégration dans Oracle Database 23ai. Pour plus d'informations, reportez-vous à oda-oci-data-science-oracledb-23ai-llm.

Initialiser Oracle Database 23ai

def load_documents(embedding_model):
    # connect to db
    # Configure logging
    logging.basicConfig(
        level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
    )
    logging.info("Connecting to Oracle DB...")

    DSN = f"{DB_HOST_IP}/{DB_SERVICE}"

    with oracledb.connect(user=DB_USER, password=DB_PWD, dsn=DSN) as connection:
        logging.info("Successfully connected to Oracle Database...")

        num_pages = []
        for book in INPUT_FILES:
            logging.info(f"Processing book: {book}...")

            if ENABLE_CHUNKING is False:
                # chunks are pages
                logging.info("Chunks are pages of the book...")
                nodes_text, nodes_id, pages_num = read_and_split_in_pages([book])
                num_pages.append(len(nodes_text))
            else:
                logging.info(f"Enabled chunking, chunck_size: {MAX_CHUNK_SIZE}...")
                nodes_text, nodes_id, pages_num = read_and_split_in_chunks([book])

                # create embeddings
                # process in batch (max 96 for batch, chosen BATCH_SIZE, see above)
                logging.info("Computing embeddings...")
                embeddings = compute_embeddings(embedding_model, nodes_text)

                # determine book_id and save in table BOOKS
                logging.info("Registering document...")
                book_id = register_document(book, connection)

                # store embeddings
                # here we save in DB
                save_embeddings_in_db(embeddings, nodes_id, connection)

                # store text chunks (pages for now)
                save_chunks_in_db(nodes_text, nodes_id, pages_num, book_id, connection)

                # a txn is a book
                connection.commit()

Tâche 4 : connexion au LLM d'actions rapides IA Mistral-7B-Instruct-v0.2

Créez un déploiement de modèle avec AI Quick Actions et obtenez l'adresse de déploiement de modèle à partir de là. Exécutez le code suivant pour vous connecter à LLM.

import ads
ads.set_auth("resource_principal")

command_md = OCIModelDeploymentVLLM(
    endpoint="https://modeldeployment.eu-frankfurt-1.oci.customer-oci.com/ocid1.datasciencemodeldeployment.oc1.<ocid>/predict",
    model="odsc-llm"
)

Tâche 5 : configurer la RAG

L'architecture RAG suivante comprendra les étapes suivantes :

Tâche 5.1 : télécharger vers la base de données vectorielle 23ai

class CustomRetriever(BaseRetriever):
    def _get_relevant_documents(
        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
    ) -> List[Document]:
        matching_documents = []

        #Embedding model
        rps = oci.auth.signers.get_resource_principals_signer()
        prediction = requests.post(EMBEDDING_MD_ENDPOINT, data=f'["{query}"]', auth=rps)

        #Search in DB
        q_result = test_oracle_query(prediction.json()['embeddings'][0], TOP_K, True, False)
        text_list = []
        for n, id, sim in zip(q_result.nodes, q_result.ids, q_result.similarities):
            text_list.append(n.text)
        paired_list = [[query, text] for text in text_list]

        print(f'Reranker payload: {paired_list}')

        #ReRanker model
        reranker_results = requests.post(RERANKER_MD_ENDPOINT, data=json.dumps(paired_list), auth=rps)  # make a prediction request
        max_value = max(reranker_results.json()['prediction'])
        if max_value < -3:
            return matching_documents;
        # Find the index of the maximum value
        max_index = reranker_results.json()['prediction'].index(max_value)
        print(f"The maximum value is: {max_value}")
        print(f"The index of the maximum value is: {max_index}")
        doc =  Document(page_content=paired_list[max_index][1], metadata={"source": "local"})
        matching_documents.append(doc)
        return matching_documents

customRetriever = CustomRetriever()
chain = RetrievalQA.from_chain_type(
    llm=command_md,
    retriever=customRetriever
)

prompt = "Can you please give some overview on Oracle Database 23.4?"
res = chain(prompt)
print('Output::')
print(res['result'])

Nous utilisons le modèle d'invite et la chaîne d'assurance qualité fournis par Langchain pour créer le chatbot, ce qui aide à transmettre le contexte et la question directement au LLM.

Tâche 5.2 : déployer le modèle LangChain

import tempfile
import ads
from ads.model.generic_model import GenericModel
from config import CONDA_PACK_PATH, LOG_GROUP_ID, LANGCHAIN_MODEL_ACCESS_LOG_LOG_ID, LANGCHAIN_MODEL_PREDICT_LOG_LOG_ID

ads.set_auth("resource_principal")

langchain_model = GenericModel( artifact_dir="langchain_model",estimator=None, serialize=False)
langchain_model.summary_status()
#Copy required python scripts to artifact dir
langchain_model.prepare(
        inference_conda_env=CONDA_PACK_PATH,
        inference_python_version = "3.9",
        model_file_name="test",
        score_py_uri= "score_langchain_final.py",
        force_overwrite=True
    )
op=langchain_model.verify('Can you please give some overview on Oracle Database 23.4?')
model_id = langchain_model.save(display_name="langchain-model")
deploy = langchain_model.deploy(
    display_name="Langchain Model Deployment",
    deployment_log_group_id = LOG_GROUP_ID,
    deployment_access_log_id = LANGCHAIN_MODEL_ACCESS_LOG_LOG_ID,
    deployment_predict_log_id = LANGCHAIN_MODEL_PREDICT_LOG_LOG_ID,
    environment_variables={"CRYPTOGRAPHY_OPENSSL_NO_LEGACY":"1"},
    deployment_instance_shape="VM.Standard2.4",
)
deploy.predict('Can you please give some overview on Oracle Database 23.4?')

Tâche 6 : création d'un assistant numérique à l'aide d'Oracle Digital Assistant pour que l'application de chatbot héberge la RAG

Tâche 6.1 : obtenir l'adresse de déploiement de modèle et ajouter une stratégie

Ajoutez un service REST à l'instance qui appelle le fournisseur du modèle. Nous utilisons le déploiement de modèle Oracle comme exemple, mais nous pouvons utiliser un service REST pour tout LLM.

image

Ajoutez une stratégie pour qu'Oracle Digital Assistant puisse accéder à l'adresse de prévision de déploiement de modèle. Accédez à Identité et sécurité, à Stratégies et cliquez sur Créer une stratégie.

image

Stratégies pour le groupe dynamique

Allow any-user to {DATA_SCIENCE_MODEL_DEPLOYMENT_PREDICT} in compartment Demo where request.principal.id='ocid1.odainstance.oc1.iad.<ocid>'

Une fois la stratégie créée, nous pouvons la lancer vers Oracle Digital Assistant et l'ouvrir dans un navigateur.

Tâche 6.2 : créer le service REST de fournisseur de LLM

  1. Accédez à Oracle Digital Assistant, accédez à Paramètres, Services d'API, Services LLM et cliquez sur +Add Service LLM.

  2. Sur la page Créer un service LLM, entrez les informations suivantes pour créer une opération de publication vers l'adresse du fournisseur, puis cliquez sur Créer.

    • Nom : entrez un nom facilement identifiable pour le service. Vous référencez ce nom plus tard.
    • Adresse : copiez et collez l'adresse de déploiement de modèle.
    • Méthodes : sélectionnez POST.

    image

  3. Terminez le service en ajoutant la clé d'API, ainsi que les exemples de charge utile de demande et de réponse.

    • Type d'authentification : sélectionnez Principal de ressource OCI.

    • Type de contenu : sélectionnez application/json.

    • Corps : ajoutez la charge utile envoyée à la demande. Exemple :

      {
    "query": "Can you please give some overview on Oracle Database 23.4?"
}

    image

  4. Cliquez sur Tester la demande pour rechercher une réponse 200.

    image

Tâche 6.3 : création d'une brique

Une fois le service REST du fournisseur de LLM ajouté à l'instance, nous devons maintenant créer une brique qui peut appeler ce service et y connecter les utilisateurs via sa définition de flux de dialogue. Pour créer cette brique, procédez comme suit :

  1. Accédez à Oracle Digital Assistant, puis à Développement et à +Skills.

  2. Cliquez sur + Nouvelle compétence.

  3. Sur la page Créer une brique, entrez les informations suivantes et cliquez sur Créer.

    • Nom d'affichage : ajoutez un nom.
    • Mode de la boîte de dialogue : sélectionnez Visual.
    • Pour les autres champs, conservez les valeurs par défaut.

    image

Tâche 6.4 : connecter la brique au modèle

Nous allons maintenant permettre à la brique d'accéder au service REST de LLM en créant un composant personnalisé avec un gestionnaire d'événements qui transforme les charges utiles REST en formats acceptés par le fournisseur de LLM et Oracle Digital Assistant.

  1. Cliquez sur l'icône Composants dans la barre de navigation de gauche et sur Ajouter un service.

    Icône Composants dans la barre de navigation de gauche

  2. Sur la page Créer un service, entrez les informations suivantes et cliquez sur Créer.

    • Nom : entrez un nom décrivant le service.
    • Type de service : acceptez le paramètre par défaut et sélectionnez Conteneur incorporé.
    • Type de création de package de services de composant : sélectionnez Nouveau composant.
    • Type de composant : sélectionnez Transformation LLM.
    • Nom de composant : entrez un nom descriptif.
    • Modèle : sélectionnez Personnalisé (situé sous autre).

    image

  3. Le composant terminé s'affiche sur la page Composants.

    image

  4. Sélectionnez le composant sur la page Composants pour vérifier son statut de déploiement. Lorsque Prêt s'affiche, vous pouvez passer à l'étape suivante.

    image

    Assurez-vous que l'option Service Enabled (paramètre par défaut) est activée.

    image

Tâche 6.5 : mettre en correspondance le fournisseur de services LLM et les demandes et réponses Oracle Digital Assistant

Les demandes de la brique au fournisseur de services du modèle doivent être transformées à partir de l'interface utilisée par Oracle Digital Assistant, appelée interface LLM commune (CLMI), au format accepté par le fournisseur de services. De même, les résultats renvoyés par le prestataire de services doivent également être transformés en CLMI. Pour activer ce mappage, les méthodes de gestionnaire d'événements de service REST suivantes doivent avoir un code propre au fournisseur.

Pour ouvrir l'éditeur de code du gestionnaire d'événements et mettre à jour le code de transformation (dans ce cas, pour Azure OpenAI), procédez comme suit :

  1. Développez le service et sélectionnez le gestionnaire d'événement.

    image

  2. Cliquez sur l'icône Modifier (Edit) pour ouvrir l'éditeur.

    image

    image

  3. Remplacez le code de méthode d'événement du gestionnaire transformRequestPayload (vers les lignes 24 à 26) par le code suivant.

    • transformRequestPayload:

      transformRequestPayload: async (event, context) => {
    return { "query": event.payload.messages[event.payload.messages.length - 1].content };
    },

      Chaque demande doit simplement transmettre la dernière entrée utilisateur à l'invite LLM.

  4. Remplacez le code de méthode d'événement du gestionnaire transformResponsePayload (vers les lignes 35 à 37) par le code suivant.

    • transformRequestPayload:

      transformResponsePayload: async (event, context) => {
    return { candidates: [ { "content": event.payload.prediction || "" }]};
},

  5. Remplacez le code de méthode d'événement du gestionnaire transformErrorResponsePayload (vers les lignes 47 à 49) par le code suivant.

    • transformRequestPayload:

      transformErrorResponsePayload: async (event, context) => {
    let errorCode = 'unknown';
    if (event.payload.error) {
        if ( 'context_length_exceeded' === event.payload.error.code) {
            errorCode = 'modelLengthExceeded'; }
        else if ('content_filter' === event.payload.error.code) {
            errorCode = 'flagged';
        }
        return {"errorCode" : errorCode, "errorMessage": event.payload.error.message};
    }
    return {"errorCode" : errorCode, "errorMessage": JSON.stringify(event.payload)};
}

  6. Cliquez sur Modifier pour vérifier la syntaxe du code. Utilisez-le pour remplacer le code dans l'éditeur si vous rencontrez des erreurs de syntaxe que vous ne pouvez pas corriger.

    image

  7. Cliquez sur Enregistrer, puis sur Fermer. Attendez la fin du déploiement. Lorsque Prêt s'affiche, vous pouvez passer à l'étape suivante.

Tâche 6.6 : définir le service LLM de la brique

Pour permettre à la brique de connecter les utilisateurs au modèle via le flux de dialogue, vous devez créer un service LLM qui combine le service LLM à l'échelle de l'instance qui appelle le modèle avec le gestionnaire d'événements de transformation (qui, dans ce cas, concerne le déploiement de modèle Oracle).

  1. Cliquez sur l'icône Paramètres dans la barre de navigation de gauche.

    Barre de navigation gauche

  2. Cliquez sur Configuration.

    Onglet Configuration dans Paramètres

  3. Sur la page Services de grands modèles de langage, cliquez sur +New Service LLM.

    Section Large Language Model de la page Configuration.

  4. Entrez les informations suivantes

    • Nom : entrez un nom facilement identifiable pour le service LLM. Vous référencez ce nom lorsque vous créez le flux de dialogue à l'étape suivante.

    • Service LLM : sélectionnez le nom du service LLM à l'échelle de l'instance que vous avez créé dans Tâche 1 : créer le service REST dans le modèle.

    • Gestionnaire de transformation : sélectionnez le nom du composant de gestionnaire d'événements que vous avez créé dans le cadre du service REST dans Tâche 3 : connecter la brique au modèle.

    • Conservez les propriétés restantes dans leurs paramètres par défaut. Notez que l'option Par défaut est activée, s'il s'agit du seul service que vous avez créé jusqu'à présent pour ce tutoriel.

      image

  5. Cliquez sur Save.

    Icône de service Enregistrer

  6. Désélectionnez Retour et autres valeurs par défaut sur les commutateurs.

    image

Tâche 6.7 : Intégrer le service

Maintenant que la brique est connectée au LLM, connectez les utilisateurs de la brique au modèle en créant un composant de flux de dialogue qui peut appeler le modèle et lui indiquer ce qu'il faut faire. Le composant transmet ces instructions à l'aide d'une invite, qui est un bloc de texte lisible par l'utilisateur. Dans cette tâche, nous fournirons cette invite, qui indique au modèle d'évaluer les commentaires des utilisateurs comme positifs, négatifs ou neutres.

  1. Cliquez sur l'icône Flux dans la barre de navigation de gauche.

    Icône Flux dans la barre de navigation de gauche

  2. Sélectionnez unresolvedIntent.

    Flux non résolu

  3. Dans l'état unresolvedMessage, cliquez sur l'icône points de suspension(...) et sélectionnez Ajouter un état dans le menu.

    Option Ajouter un état

  4. Sélectionnez Intégration de service et Appeler un modèle de langue volumineux.

  5. Saisissez une description, telle que l'analyse des sentiments, puis cliquez sur Insérer.

    image

    Le flux de dialogue inclut désormais l'état unresolvedMessage (Envoyer un message), l'état invokeLLM et l'état showLLMError.

    Etat invokeLLM avec l'état showError dans le flux de dialogue

  6. Dans l'état unresolvedMessage, cliquez sur l'icône ellipsis(...) et sélectionnez Supprimer dans le menu car nous ne voulons pas afficher de message d'erreur pour UnresolvedIntent.

    image

    Le flux de dialogue inclut désormais l'état invokeLLM et l'état showLLMError uniquement.

    image

  7. Ouvrez l'état invokeLLM. Sur la page Composant, sélectionnez le service LLM que nous avons créé dans la tâche 6.6.

    Le champ LLM Service

  8. Ajoutez une invite qui envoie des instructions au service LLM en collant les éléments suivants dans l'invite. Toute conversation utilisateur doit être transmise en tant qu'entrée d'invite.

    image

  9. Créez la variable PROMPT_INPUT. Cliquez sur Paramètres d'invite + pour ajouter un nouveau paramètre et sa valeur.

    image

  10. Définissez Utiliser Streaming sur False afin que le message soit distribué dans son intégralité, et non pas de manière incrémentielle.

    image

  11. Testez l'invite avec le générateur d'invites et cliquez sur Créer une invite.

    image

  12. Ajoutez Valeur de simulation de paramètre d'invite et cliquez sur Générer une sortie. De cette façon, nous pouvons valider l'intégration LLM.

    image

Tâche 6.8 : tester l'invite avec le testeur de briques

  1. Cliquez sur Aperçu pour ouvrir le testeur de briques.

    Le bouton Preview

  2. Saisissez la demande suivante : Pouvez-vous donner un aperçu d'Oracle Database 23.4 ?.

    La sortie doit ressembler à ceci :

    image

  3. Demandez la requête suivante au LLM : dernière base de données oracle.

    La sortie doit ressembler à ceci :

    image

Tâche 6.9 : configurer le canal utilisateur Oracle Web

Nous allons créer un canal utilisateur Oracle Digital Assistant qui permet à un client Web Oracle d'accéder à la brique. Pour garantir que seuls nos clients Web peuvent utiliser ce canal, nous allons le configurer pour exiger l'authentification client.

  1. Ouvrez Oracle Digital Assistant, accédez à Développement, à Canaux et cliquez sur Canal +Add.

  2. Dans Créer un canal, entrez les informations suivantes pour créer une opération POST vers l'adresse du fournisseur, puis cliquez sur Créer.

    • Nom : nom unique qui commence par une lettre et ne contient que des lettres, des chiffres, des points et des traits de soulignement. Par exemple, OCI_MD_LLM.
    • Description (facultatif) : utilisation du canal.
    • Type de canal : sélectionnez Oracle Web.
    • Domaines autorisés : entrez *.
    • Authentification client activée : désélectionnez.

    image

  3. Désélectionnez Authentification client activée si elle n'est pas déjà désactivée.

  4. Dans Acheminer, sélectionnez la brique à utiliser. Nous avons sélectionné la brique actuelle LLM-MD-Skill.

  5. Activez Canal activé.

  6. Notez l'ID de canal et l'URI de domaine ODA sans HTTPS, qui sont affichés pour ce canal.

Nous utiliserons ces valeurs dans notre application Web et dans la configuration de routage du générateur de jetons.

Tâche 6.10 : installation du kit SDK

Télécharger le fichier ZIP et l'extraire vers votre système local. Ce fichier ZIP inclut un guide utilisateur qui décrit les classes du kit SDK et un exemple d'application présentant de nombreuses fonctionnalités.

  1. Accédez à la section Téléchargements Oracle Digital Assistant (ODA) et Oracle Mobile Cloud (OMC) et SDK client natif Oracle (pour les environnements natifs OCI) Web SDK.

  2. Téléchargez ODA Web SDK 24.06.

  3. Dans Plates-formes, sélectionnez GENERIC.

  4. Cliquez sur cette option pour télécharger le dernier kit SDK ODA Js oda-native-client-sdk-js-24_06 for (GENERIC (All Platforms).

    image

  5. Extrayez le fichier ZIP téléchargé.

Tâche 6.11 : tester l'application Web Oracle

  1. Accédez au dossier ZIP extrait du kit SDK Web Oracle téléchargé.

  2. Ouvrez le fichier samples/web/settings.js et remplacez <URI> et <channelId> par la valeur réelle.

    Exemple :

    • URI : oda-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-dax.data.digitalassistant.oci.oraclecloud.com.
    • ChannelId: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.

  3. Assurez-vous également que isClientAuthEnabled est faux.

    let isClientAuthEnabled = false;

  4. Exécutez le fichier samples/web/index.html sur n'importe quel navigateur.

  5. Ignorez le contenu du fichier d'index. Cliquez sur l'icône de discussion pour afficher le statut Oracle Assistant CONNECTED.

    image

  6. Voici à quoi ressemble notre site Web avec l'icône de chat dans le coin inférieur droit. Nous pouvons démarrer une conversation, comme nous l'avons fait précédemment avec le testeur de briques.

    image

    image

Tâche 6.12 : publication sur l'instance OCI Compute

  1. Créez une instance OCI Compute. Pour plus d'informations, reportez-vous à Création d'une instance

  2. Assurez-vous que vous respectez les règles entrantes.

    image

  3. Copiez tous les dossiers Web vers l'instance nouvellement créée.

  4. Installer NGINX. Pour plus d'informations, reportez-vous à Installation du serveur Web et du proxy NGINX sur Oracle Linux.

  5. Ouvrez un navigateur et accédez à http://<IP_address>/. Si vous disposez d'un certificat auto-signé, vous pouvez accéder à https://<IP_address>/.

Résultats

Comparons les résultats de la demande directe du LLM par rapport à l'utilisation de RAG avec le LLM :

Etapes suivantes

La création d'un chatbot avancé à l'aide d'Oracle Database 23ai, de RAG, de LangChain, de Mistral-7B-Instruct-v0.2 et d'Oracle Digital Assistant démontre la puissance de l'intégration de technologies de pointe pour créer un agent conversationnel hautement réactif et intelligent. Le workflow détaillé, de la gestion des demandes à la génération des réponses, garantit que le chatbot peut extraire et traiter efficacement de grandes quantités d'informations, fournissant des réponses précises et pertinentes en contexte aux utilisateurs. En tirant parti des fonctionnalités de recherche vectorielle d'Oracle Database 23ai et de la plate-forme robuste fournie par Oracle Digital Assistant, les développeurs peuvent améliorer considérablement les performances du chatbot et l'engagement des utilisateurs. Cette approche intégrée rationalise non seulement le processus de développement, mais se traduit également par une solution d'IA évolutive, efficace et hautement efficace qui se distingue dans le paysage concurrentiel des assistants numériques. Que ce soit pour le service client, la récupération d'informations ou le support interactif, cette architecture de chatbot avancée ouvre la voie à la création d'expériences conversationnelles sophistiquées qui répondent aux exigences des utilisateurs modernes.

Pour plus d'informations sur l'utilisation des actions rapides d'IA, accédez à la liste de lecture YouTube d'Oracle Cloud Infrastructure Data Science pour visionner une vidéo de démonstration des actions rapides d'IA, et consultez notre documentation technique, ainsi que notre référentiel Github avec des conseils et des exemples.

Si vous voulez suggérer des modèles spécifiques à ajouter aux actions rapides d'IA ou si vous avez des questions, envoyez un courriel au groupe OCI Data Science : ask-oci-data-science_grp@oracle.com.

Remerciements

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à d'autres contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation produit, consultez le site Oracle Help Center.