Note :

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

Présentation

Dans le paysage numérique actuel, les agents conversationnels évoluent pour devenir plus intelligents, plus réactifs et plus capables de gérer des interactions complexes. Dans ce tutoriel, nous étudions la création d'un agent conversationnel de nouvelle génération en tirant parti de la puissance des capacités du service de science des données d'Oracle Cloud Infrastructure (OCI), telles que les actions rapides et le déploiement de modèles avec IA, Mistral-7B-Instruct-v0.2, Oracle Database 23ai, LangChain et Oracle Digital Assistant. Chacune de ces technologies apporte des forces uniques à la table, ce qui nous permet de créer un agent conversationnel qui non seulement comprend et répond aux demandes des utilisateurs avec une précision remarquable, mais offre également une expérience conversationnelle transparente et engageante.

L'une des principales fonctionnalités d'Oracle Database 23ai est ses capacités avancées de recherche vectorielle. Cette technologie permet une récupération efficace des informations en convertissant le texte en vecteurs de haute dimension, qui sont ensuite comparés pour leur pertinence. Lorsqu'elle est intégrée au pipeline de génération augmentée par extraction (RAG), la recherche vectorielle d'Oracle Database 23ai améliore la capacité de l'agent conversationnel à accéder aux informations les plus pertinentes provenant de vastes jeux de données et à les fournir. Cela garantit que les réponses générées sont non seulement contextuellement exactes, mais également très pertinentes pour l'interrogation de l'utilisateur.

Oracle Digital Assistant améliore encore les fonctionnalités de l'agent conversationnel en fournissant une plateforme robuste pour créer, déployer et gérer des solutions d'IA conversationnelle. Il offre des connecteurs prédéfinis, une compréhension du langage naturel (NLU) et une gestion du dialogue, qui simplifient le processus de développement et assurent une expérience utilisateur fluide. La combinaison d'Oracle Digital Assistant et du pipeline RAG permet à l'agent conversationnel 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 d'Oracle Database 23ai et d'Oracle Digital Assistant dans le pipeline RAG, les développeurs peuvent créer un agent conversationnel qui excelle à la fois dans la précision d'extraction et la fluidité conversationnelle. Cette approche intégrée réduit non seulement le temps et les efforts nécessaires pour créer des agents conversationnels sophistiqués, mais aboutit également à une solution évolutive, efficace et capable d'offrir une expérience utilisateur supérieure. Que vous soyez un développeur, un passionné de technologie ou un chef d'entreprise cherchant à améliorer l'engagement des clients, ce tutoriel vous fournira les connaissances et les outils nécessaires pour créer un agent conversationnel avancé qui se démarque dans l'arène numérique bondée.

Pour la présentation pas à pas du processus, voir Référentiel d'échantillons d'intelligence artificielle GitHub.

Cas d'utilisation

Voici quelques exemples de cas d'utilisation qui peuvent être utiles :

Avantages de la recherche de vecteurs dans Oracle AI

Oracle Database est un référentiel de données opérationnelles et d'entreprise de premier plan. 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 de rechercher simultanément des données de catalogue non structurées (description et image du produit), des données de catalogue structurées (prix, emplacement de magasin et fabricant) ainsi que des données transactionnelles en temps réel (telles que le stock courant).

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 flux de travail de création d'un agent conversationnel avancé à l'aide de Mistral-7B-Instruct-v0.2, d'Oracle Database 23ai, de RAG, de LangChain et d'Oracle Digital Assistant. Voici les étapes détaillées impliquées dans l'architecture suivante.

  1. Interaction de l'utilisateur : L'utilisateur envoie une demande à l'agent conversationnel au moyen de l'interface d'Oracle Digital Assistant.

  2. Traitement des demandes : Oracle Digital Assistant reçoit la demande et la transmet à l'infrastructure du service de science des données pour OCI.

  3. Traitement des interrogations : Il y a 2 étapes impliquées.

    • Au sein du service de science des données pour OCI, la demande est acheminée vers LangChain, qui agit en tant qu'orchestrateur pour gérer l'interaction entre divers déploiements de modèle.
    • LangChain traite la demande et identifie le besoin d'extraction d'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 l'interrogation en une représentation vectorielle haute dimension.
    • Cette interrogation vectorielle 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 d'affaires de la base de données.
    • Les documents ou fragments pertinents sont extraits et envoyés à l'étape suivante pour traitement ultérieur.

  6. Reclassement :

    • La réponse générée peut être encore affinée par un déploiement de modèle de reclassement.
    • 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. Interrogation des modèles externes : Dans cette étape, les données sont extraites et génèrent une réponse.

    • Les informations extraites sont utilisées pour générer une interrogation pour le déploiement du modèle Mistral-7B-Instruct-v0.2 provisionné à l'aide des fonctions d'actions rapides d'IA dans le service de science des données pour OCI.
    • Le modèle Mistral-7B-Instruct-v0.2 traite l'interrogation 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. Retour 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éalables

Préalables clés que vous devez configurer avant de pouvoir exécuter le processus de réglage fin distribué dans le service de science des données pour OCI.

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 fonction de déploiement du modèle d'actions rapides de l'IA pour déployer Mistral-7B-Instruct-v0.2 en quelques clics. Le déploiement du modèle d'action rapide de l'IA aide les utilisateurs à déployer le Mistral-7B-Instruct-v0.2 en quelques clics et à fournir aux utilisateurs un point d'extrémité.

Image

Image

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

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

  2. Chargez le fichier score.py dans le répertoire courant (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 de vecteurs dans Oracle AI, pour notre cas d'utilisation. Dans ce scénario, nous importerons les intégrations générées à partir du jeu 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 avantages liés à l'utilisation d'Oracle Database 23ai.

Image

Figure : Illustration de la fonction 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 présenter les puissantes fonctionnalités d'Oracle AI Vector Search.

Tâche 3 : Analyser, fragmenter et stocker l'intégration dans Oracle Database 23ai

L'extrait de code suivant donne un aperçu général de la façon dont le document est analysé, comment le document est converti en fragments, puis comment l'intégration sera stockée dans Oracle Database 23ai. Pour plus d'informations, voir 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 : Se connecter à Mistral-7B-Instruct-v0.2 AI Actions rapides LLM

Créez un déploiement de modèle avec des actions rapides d'IA et obtenez le point d'extrémité 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 ROV

L'architecture RAG suivante comprendra les étapes suivantes :

Tâche 5.1 : Charger dans 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 l'agent conversationnel, 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éer un assistant numérique à l'aide d'Oracle Digital Assistant pour l'application d'agent conversationnel afin d'héberger RAG

Tâche 6.1 : Obtenir le point d'extrémité de déploiement de modèle et ajouter une politique

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

Image

Ajoutez une politique pour qu'Oracle Digital Assistant puisse accéder au point d'extrémité de prédiction du déploiement de modèle. Allez à Identité et sécurité, Politiques et cliquez sur Créer une politique.

Image

Politiques 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 politique créée, nous pouvons la lancer dans Oracle Digital Assistant et l'ouvrir dans un navigateur.

Tâche 6.2 : Créer le service REST du fournisseur LLM

  1. Allez à Oracle Digital Assistant, naviguez jusqu'à Paramètres, Services d'API, Services LLM et cliquez sur +Add Service LLM.

  2. Dans la page Créer un service LLM, entrez les informations suivantes pour créer une opération Post au point d'extrémité du fournisseur et cliquez sur Créer.

    • Nom : Entrez un nom facilement identifiable pour le service. Vous référencerez ce nom plus tard.
    • Point d'extrémité : Copiez et collez le point d'extrémité de déploiement de modèle.
    • Méthodes : Sélectionnez POST.

    Image

  3. Terminez le service en ajoutant la clé d'API et les exemples de données utiles de demande et de réponse.

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

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

    • Corps : Ajoutez les données utiles envoyées à la demande. Par exemple :

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

    Image

  4. Cliquez sur Demande de test pour rechercher une réponse 200.

    Image

Tâche 6.3 : Créer une compétence

Avec le service REST du fournisseur LLM ajouté à l'instance, nous devons maintenant créer une compétence qui peut appeler ce service et y connecter des utilisateurs au moyen de sa définition de flux de dialogue. Pour créer cette compétence, procédez de la façon suivante :

  1. Allez à Oracle Digital Assistant, naviguez jusqu'à Développement et +Skills.

  2. Cliquez sur + New Skill (Nouvelle compétence).

  3. Dans la page Créer une compétence, entrez les informations suivantes et cliquez sur Créer.

    • Nom d'affichage : Ajoutez un nom.
    • Mode de dialogue : Sélectionnez Visuel.
    • Pour les autres champs, laissez les valeurs par défaut.

    Image

Tâche 6.4 : Connecter la compétence au modèle

Nous allons maintenant permettre à la compétence d'accéder au service REST LLM en créant un composant personnalisé avec un programme de traitement d'événements qui transforme les données utiles REST dans des formats acceptés par le fournisseur LLM et Oracle Digital Assistant.

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

    Icône Components (Composants) dans la barre de navigation gauche

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

    • Nom : Entrez un nom qui décrit le service.
    • Type de service : Acceptez le paramètre par défaut, sélectionnez Conteneur intégré.
    • Type de création de l'ensemble de services de composant : Sélectionnez Nouveau composant.
    • Type de composant : Sélectionnez Transformation LLLM.
    • Nom du composant : entrez un nom descriptif.
    • Modèle : Sélectionnez Personnalisé (situé sous autre).

    Image

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

    Image

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

    Image

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

    Image

Tâche 6.5 : Mapper le fournisseur de services LLM et les demandes et réponses d'Oracle Digital Assistant

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

Pour ouvrir l'éditeur de code du programme de traitement 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 programme de traitement d'événements.

    Image

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

    Image

    Image

  3. Remplacez le code de méthode d'événement du programme de traitement transformRequestPayload (autour des 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 passer la dernière entrée utilisateur à l'invite LLM.

  4. Remplacez le code de méthode d'événement du programme de traitement transformResponsePayload (autour des 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 programme de traitement transformErrorResponsePayload (autour des 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 Valider 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 et Fermer. Attendez la fin du déploiement. Lorsque l'option Prêt s'affiche, vous pouvez passer à l'étape suivante.

Tâche 6.6 : Définir le service LLM pour la compétence

Pour permettre à la compétence de connecter des utilisateurs au modèle au moyen du 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 programme de traitement d'événements de transformation (dans ce cas, pour 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.

    L'onglet Configuration dans Paramètres

  3. Dans la page Services de modèles linguistiques étendus, cliquez sur +New Service LLM.

    Section Large Language Model (Modèle de langue large) de la page Configuration.

  4. Entrez les informations suivantes

    • Nom : Entrez un nom facilement identifiable pour le service LLM. Vous référencerez ce nom lorsque vous créerez 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 selon le modèle.

    • Programme de traitement de transformation : Sélectionnez le nom du composant du programme de traitement d'événements que vous avez créé dans le cadre du service REST dans Tâche 3 : Connecter la compétence 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 Enregistrer.

    Icône du service Enregistrer

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

    Image

Tâche 6.7 : Intégrer le service

Maintenant que la compétence est connectée au LLM, connectez les utilisateurs de la compétence au modèle en créant un composant de flux de dialogue qui peut appeler le modèle et lui dire quoi faire. Le composant transmet ces instructions à l'aide d'une invite, qui est un bloc de texte lisible par l'homme. 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 gauche.

    Icône Flows (Flux) dans la barre de navigation gauche

  2. Sélectionnez unresolvedIntent.

    Flux non résolu

  3. À 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 services et Appeler un modèle de langue volumineux.

  5. Entrez une description telle que l'analyse des sentiments et cliquez sur Insérer.

    Image

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

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

  6. À 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 maintenant l'état invokeLLM et l'état showLLMError uniquement.

    Image

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

    Service LLM

  8. Ajoutez une invite qui envoie des instructions au service LLM en collant les éléments suivants dans l'invite. Toute conversation d'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. Réglez Utiliser le service de diffusion en continu à Faux pour que le message soit transmis dans son intégralité, et non 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 fictive de paramètre d'invite et cliquez sur Générer une sortie. Nous pouvons ainsi valider l'intégration LLM.

    Image

Tâche 6.8 : Tester l'invite avec le testeur de compétence

  1. Cliquez sur Preview (Prévisualiser) pour ouvrir le testeur de compétence.

    Bouton Aperçu

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

    La sortie doit ressembler à ceci :

    Image

  3. Demandez l'interrogation suivante à LLM : dernière base de données oracle.

    La sortie doit ressembler à ceci :

    Image

Tâche 6.9 : Configurer le canal d'utilisateur Web Oracle

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

  1. Ouvrez Oracle Digital Assistant, naviguez jusqu'à Développement, Canaux et cliquez sur +Add Canal.

  2. Dans Créer un canal, entrez les informations suivantes pour créer une opération POST vers le point d'extrémité du fournisseur et 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) : À quoi sert le canal.
    • Type de canal : Sélectionnez Oracle Web.
    • Domaines autorisés : Entrez *.
    • Authentification du client activée : Désélectionnez-la.

    Image

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

  4. Dans Route, sélectionnez la compétence à utiliser. Nous avons sélectionné la compétence courante LLM-MD-Skill.

  5. Activer le canal activé.

  6. Notez l'ID 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 la configuration de routage du générateur de jetons.

Tâche 6.10 : Installer la trousse SDK

Téléchargez le fichier zip et extrayez-le sur votre système local. Ce fichier zip comprend un guide d'utilisation qui décrit les classes de la trousse SDK et un exemple d'application qui présente la plupart de ses fonctions.

  1. Allez à la section Téléchargements d'Oracle Digital Assistant (ODA) et d'Oracle Mobile Cloud (OMC) et Trousses SDK Web pour clients natifs Oracle (pour les environnements natifs OCI).

  2. Télécharger la trousse SDK Web ODA 24.06.

  3. Dans Plate-formes, sélectionnez GÉNÉRIQUE.

  4. Cliquez pour télécharger la dernière trousse SDK ODA Js qui est 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. Allez au dossier zip extrait de la trousse SDK Web Oracle téléchargée.

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

    Par 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 dans n'importe quel navigateur.

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

    Image

  6. Voici à quoi ressemble notre site Web avec l'icône de chat en bas à droite. Nous pouvons commencer une conversation, comme nous l'avons fait précédemment avec le testeur de compétence.

    Image

    Image

Tâche 6.12 : Version sur l'instance de calcul OCI

  1. Créez une instance du service de calcul OCI. Pour plus d'informations, voir Création d'une instance

  2. Assurez-vous d'avoir suivi les règles de trafic entrant.

    Image

  3. Copiez tous les dossiers Web dans la nouvelle instance créée.

  4. Installez NGINX. Pour plus d'informations, voir Installer le serveur Web et le mandataire NGINX sur Oracle Linux.

  5. Ouvrez un navigateur et accédez à http://<IP_address>/. Si vous avez 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 LLM :

Étapes suivantes

La création d'un agent conversationnel avancé au moyen d'Oracle Database 23ai, de RAG, de LangChain, de Mistral-7B-Instruct-v0.2 et d'Oracle Digital Assistant présente la puissance de l'intégration de technologies de pointe pour créer un agent conversationnel hautement réactif et intelligent. Le flux de travail détaillé, du traitement des demandes à la génération des réponses, garantit que l'agent conversationnel peut récupérer et traiter efficacement de grandes quantités d'informations, fournissant des réponses précises et pertinentes sur le plan contextuel aux utilisateurs. En tirant parti des capacité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 la performance de l'agent conversationnel et l'engagement des utilisateurs. Cette approche intégrée simplifie non seulement le processus de développement, mais offre aussi une solution d'IA évolutive, efficace et hautement efficace qui se démarque dans le paysage concurrentiel des assistants numériques. Que ce soit pour le service à la clientèle, l'extraction d'informations ou le soutien interactif, cette architecture d'agent conversationnel 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 du service d'intelligence artificielle, allez à la liste de lecture YouTube d'Oracle Cloud Infrastructure Data Science pour voir une vidéo de démonstration des actions rapides du service d'intelligence artificielle. Pour plus d'informations, consultez notre documentation technique et consultez 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 de l'IA ou si vous avez des questions, envoyez un courriel au groupe du service de science des données pour OCI : ask-oci-data-science_grp@oracle.com.

Confirmation

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.