Nota

Crea un chatbot aziendale con Oracle Digital Assistant, OCI Data Science, LangChain e Oracle Database 23ai

Introduzione

Nel panorama digitale di oggi, i chatbot si stanno evolvendo per diventare più intelligenti, reattivi e in grado di gestire interazioni complesse. In questo tutorial, analizziamo la creazione di un chatbot di nuova generazione sfruttando la potenza delle funzionalità di Data Science di Oracle Cloud Infrastructure (OCI) come AI Quick Actions e Model Deployment, Mistral-7B-Instruct-v0.2, Oracle Database 23ai, LangChain e Oracle Digital Assistant. Ognuna di queste tecnologie porta punti di forza unici sul tavolo, consentendoci di creare un chatbot che non solo capisca e risponda alle query degli utenti con notevole precisione, ma offra anche un'esperienza di conversazione fluida e coinvolgente.

Una delle caratteristiche di spicco di Oracle Database 23ai sono le sue funzionalità avanzate di ricerca vettoriale. Questa tecnologia consente un recupero efficiente delle informazioni convertendo il testo in vettori ad alta dimensione, che vengono quindi confrontati per rilevanza. Una volta integrata nella pipeline RAG (Recovery-augmented Generation), la ricerca vettoriale di Oracle Database 23ai migliora la capacità del chatbot di accedere e fornire le informazioni più pertinenti da vasti set di dati. Ciò garantisce che le risposte generate non siano solo accurate dal punto di vista contestuale, ma anche altamente pertinenti per la query dell'utente.

Oracle Digital Assistant migliora ulteriormente le funzionalità del chatbot fornendo una solida piattaforma per creare, distribuire e gestire soluzioni di intelligenza artificiale conversazionale. Offre connettori predefiniti, comprensione del linguaggio naturale (NLU) e gestione del dialogo, che semplificano il processo di sviluppo e garantiscono un'esperienza utente fluida. La combinazione di Oracle Digital Assistant e la pipeline RAG consente al chatbot di gestire interazioni complesse e mantenere un flusso naturale di conversazioni, migliorando così il coinvolgimento e la soddisfazione degli utenti.

Sfruttando la sinergia di Oracle Database 23ai e Oracle Digital Assistant all'interno della pipeline RAG, gli sviluppatori possono creare un chatbot che eccelle sia nell'accuratezza del recupero che nella fluidità della conversazione. Questo approccio integrato non solo riduce il tempo e gli sforzi necessari per creare chatbot sofisticati, ma si traduce anche in una soluzione scalabile, efficiente e in grado di offrire user experience di livello superiore. Che tu sia uno sviluppatore, un appassionato di tecnologia o un leader aziendale che cerca di migliorare il coinvolgimento dei clienti, questo tutorial ti fornirà le conoscenze e gli strumenti per costruire un chatbot avanzato che si distingue nell'affollata arena digitale.

Per una panoramica dettagliata del processo, vedere Repository di GitHub esempi di AI.

Casi d'uso

Ecco alcuni esempi di casi d'uso in cui questo può essere utile:

Vantaggi di Oracle AI Vector Search

Oracle Database è un repository leader di settore di dati operativi e aziendali. Le applicazioni aziendali in genere devono cercare una combinazione di dati aziendali e dati non strutturati. Ad esempio, un sito Web retail potrebbe includere ricerche basate su una descrizione del prodotto in linguaggio naturale e su un'immagine del prodotto target, insieme ad altri filtri, ad esempio prezzo, posizione del negozio, produttore e disponibilità corrente. Questa ricerca richiede la ricerca simultanea di dati di catalogo non strutturati (descrizione e immagine del prodotto), dati di catalogo strutturati (prezzo, posizione del negozio e produttore) e dati transazionali in tempo reale (come l'inventario corrente).

Panoramica della soluzione High Level Architecture

immagine

Figura: un'architettura di alto livello della pipeline RAG

Il seguente diagramma illustra l'architettura e il flusso di lavoro della creazione di un chatbot avanzato utilizzando Mistral-7B-Instruct-v0.2, Oracle Database 23ai, RAG, LangChain e Oracle Digital Assistant. Ecco i passaggi dettagliati coinvolti nella seguente architettura.

  1. Interazione con gli utenti: l'utente invia una richiesta al chatbot tramite l'interfaccia di Oracle Digital Assistant.

  2. Gestione delle richieste: Oracle Digital Assistant riceve la richiesta e la inoltra all'infrastruttura OCI Data Science.

  3. Elaborazione delle query: sono coinvolti 2 passi.

    • All'interno di OCI Data Science, la richiesta viene instradata a LangChain, che funge da orchestratore per la gestione dell'interazione tra varie distribuzioni di modelli.
    • LangChain elabora la richiesta e identifica la necessità di recuperare informazioni da documenti esterni e dati aziendali.

  4. Vettorizzazione: questo passo prevede i seguenti processi secondari:

    • La richiesta viene inviata a una distribuzione del modello di incorporamento, che trasforma la query in una rappresentazione vettoriale ad alta dimensione.
    • Questa query vettoriale viene quindi inviata a Oracle Database 23ai per la ricerca dei vettori.

  5. Recupero dati: questo passo prevede i seguenti processi secondari:

    • Oracle Database 23ai esegue una ricerca di somiglianza su dati non strutturati sotto forma di documenti in formato PDF e HTML e combina tale ricerca con la ricerca regolare su altri dati aziendali nel database.
    • I documenti o i blocchi pertinenti vengono recuperati e verranno inviati al passo successivo per un'ulteriore elaborazione.

  6. Raggruppamento:

    • La risposta generata può essere ulteriormente perfezionata mediante una distribuzione del modello di classificazione.
    • Il modello di classificazione valuta e classifica le risposte per garantire la selezione della risposta più pertinente e accurata.

  7. Esecuzione di query sui modelli esterni: in questo passo i dati vengono recuperati e genera una risposta.

    • Le informazioni recuperate vengono utilizzate per generare una query per la distribuzione del modello Mistral-7B-Instruct-v0.2 di cui è stato eseguito il provisioning utilizzando le funzioni AI Quick Actions in OCI Data Science.
    • Il modello Mistral-7B-Instruct-v0.2 elabora la query e genera una risposta in base al suo addestramento e al contesto recuperato.

  8. Generazione risposta: la risposta ridefinita viene inviata a LangChain, che consolida l'output finale.

  9. Restituzione della risposta all'utente:

    • La risposta finale viene restituita all'assistente digitale.
    • Oracle Digital Assistant fornisce quindi la risposta all'utente.

Obiettivi

Prerequisiti

Prerequisiti chiave che è necessario impostare prima di poter continuare a eseguire il processo di ottimizzazione distribuito su OCI Data Science Service.

Task 1: Distribuisci modelli richiesti

Task 1.1: distribuire il modello Mistral-7B-Instruct-v0.2

Sfrutteremo la funzionalità di distribuzione del modello di azioni rapide AI per distribuire Mistral-7B-Instruct-v0.2 con pochi clic. La distribuzione del modello Azioni rapide AI consente agli utenti di distribuire Mistral-7B-Instruct-v0.2 con pochi clic e fornire agli utenti un endpoint.

immagine

immagine

Task 1.2: Distribuire il modello di incorporamento Jina

  1. Nel blocco note, copiare i file modello di incorporamento Jine da https://huggingface.co/jinaai/jina-embeddings-v2-base-en/tree/main nella directory ads_embedding_model_dir.

  2. Caricare il file score.py nella directory corrente (ad esempio, /home/datascience/).

  3. Eseguire il seguente codice.

    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']);

Task 1.3: Distribuisci modello Bge-Reranker

Eseguire il seguente codice.

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",
)

Task 2: impostare Oracle Database 23ai

Per il nostro caso d'uso utilizzeremo le funzionalità più recenti di Oracle Database 23ai, in particolare Oracle AI Vector Search. In questo scenario, le incorporazioni generate dal data set verranno importate in Oracle Database 23ai. Quando un utente esegue query utilizzando l'AG, la risposta verrà migliorata fornendo agli LLM un contesto aggiuntivo. Il seguente diagramma mostra alcuni dei vantaggi derivanti dall'uso di Oracle Database 23ai.

immagine

Figura: un'illustrazione della funzione di ricerca di Oracle Database 23ai (origine)

Ciò aumenterà le loro conoscenze, portando a risposte più accurate e pertinenti alle richieste del cliente. Per impostare Oracle Database 23ai, segui le opzioni menzionate.

Utilizzeremo un'istanza in hosting di Oracle Database 23ai per dimostrare le potenti funzioni di Oracle AI Vector Search.

Task 3: Analisi, creazione di chunk e integrazione del negozio in Oracle Database 23ai

Il seguente frammento di codice offre una panoramica generale delle modalità di analisi del documento, della conversione del documento in chunk e della memorizzazione dell'incorporamento in Oracle Database 23ai. Per ulteriori informazioni, consulta oda-oci-data-science-oracledb-23ai-llm.

Inizializza 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()

Task 4: Connettersi a Mistral-7B-Instruct-v0.2 AI Azioni rapide LLM

Crea una distribuzione modello con azioni rapide AI e ottieni l'endpoint di distribuzione modello da lì. Eseguire il codice seguente per connettersi a 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"
)

Task 5: Imposta RAG

La seguente architettura RAG sarà costituita dai seguenti passaggi:

Task 5.1: Carica su 23ai Vector Database

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'])

Utilizziamo il modello di prompt e la catena di garanzia della qualità forniti da Langchain per creare il chatbot, questo aiuta a passare il contesto e la domanda direttamente al LLM.

Task 5.2: Distribuire il modello 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?')

Task 6: Creare un assistente digitale utilizzando Oracle Digital Assistant per l'applicazione chatbot per ospitare RAG

Task 6.1: Recupero dell'endpoint di distribuzione del modello e aggiunta del criterio

Aggiungere un servizio REST all'istanza che chiama il provider del modello. La distribuzione del modello Oracle viene utilizzata come esempio, ma è possibile utilizzare un servizio REST per qualsiasi LLM.

immagine

Aggiungere un criterio per consentire a Oracle Digital Assistant di accedere all'endpoint di previsione della distribuzione del modello. Andare a Identità e sicurezza, Criteri e fare clic su Crea criterio.

immagine

Criteri per il gruppo dinamico

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

Una volta creato il criterio, possiamo avviarlo in Oracle Digital Assistant e aprirlo in un browser.

Task 6.2: Creare il servizio REST del provider LLM

  1. Accedere a Oracle Digital Assistant, accedere a Impostazioni, Servizi API, Servizi LLM e fare clic su +Add Servizio LLM.

  2. Nella pagina Crea servizio LLM, immettere le informazioni riportate di seguito per creare un'operazione successiva all'endpoint del provider e fare clic su Crea.

    • Nome: immettere un nome facilmente identificabile per il servizio. In seguito verrà fatto riferimento a questo nome.
    • Endpoint: copiare e incollare l'endpoint di distribuzione del modello.
    • Metodi: selezionare POST.

    immagine

  3. Completare il servizio aggiungendo la chiave API e gli esempi di payload di richiesta e risposta.

    • Tipo di autenticazione: selezionare Principal risorsa OCI.

    • Tipo di contenuto: selezionare applicazione/json.

    • Corpo: aggiungere il payload inviato alla richiesta. Ad esempio:

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

    immagine

  4. Fare clic su Richiesta di test per verificare la presenza di una risposta 200.

    immagine

Task 6.3: Creare una competenza

Con il servizio REST del provider LLM aggiunto all'istanza, ora è necessario creare una competenza in grado di chiamare questo servizio e connettere gli utenti ad esso tramite la relativa definizione del flusso di finestre di dialogo. Per creare questo skill, effettuare le operazioni riportate di seguito.

  1. Vai a Oracle Digital Assistant, vai a Sviluppo e +Skills.

  2. Fare clic su + Nuova capacità.

  3. Nella pagina Crea competenza, immettere le informazioni seguenti e fare clic su Crea.

    • Nome visualizzato: aggiungere un nome.
    • Modalità di dialogo: selezionare Visuale.
    • Per gli altri campi, lasciare i valori predefiniti.

    immagine

Task 6.4: Collegare l'abilità al modello

Ora abiliteremo la competenza per accedere al servizio REST LLM creando un componente personalizzato con un gestore di eventi che trasforma i payload REST in formati accettati sia dal provider LLM che da Oracle Digital Assistant.

  1. Fare clic sull'icona Componenti nella barra di navigazione a sinistra e su Aggiungi servizio.

    Icona Componenti nella barra di navigazione a sinistra

  2. Nella pagina Crea servizio, immettere le informazioni seguenti e fare clic su Crea.

    • Nome: immettere un nome che descriva il servizio.
    • Tipo di servizio: accettare l'impostazione predefinita, selezionare Contenitore incorporato.
    • Tipo di creazione package di servizio componente: selezionare Nuovo componente.
    • Tipo di componente: selezionare Trasformazione LLM.
    • Nome componente: immettere un nome descrittivo.
    • Modello: selezionare Personalizzato (situato in altro).

    immagine

  3. Il componente completato viene visualizzato nella pagina Componenti.

    immagine

  4. Selezionare il componente dalla pagina Componenti per verificarne lo stato di distribuzione. Quando viene visualizzato Pronto, è possibile passare al passo successivo.

    immagine

    Assicurarsi che Service Enabled (impostazione predefinita) sia abilitato.

    immagine

Task 6.5: mappare il provider di servizi LLM e le richieste e le risposte di Oracle Digital Assistant

Le richieste di competenze al fornitore di servizi del modello devono essere trasformate dall'interfaccia utilizzata da Oracle Digital Assistant, nota come Common LLM Interface (CLMI) nel formato accettato dal fornitore di servizi. Allo stesso modo, anche i risultati restituiti dal fornitore di servizi devono essere trasformati in CLMI. Per abilitare questo mapping, i seguenti metodi di handler di eventi del servizio REST devono avere un codice specifico del provider.

Per aprire l'editor di codice del gestore di eventi e aggiornare il codice di trasformazione (in questo caso, per Azure OpenAI), attenersi alla procedura riportata di seguito.

  1. Espandere il servizio e selezionare il gestore di eventi.

    immagine

  2. Fare clic sull'icona Modifica per aprire l'editor.

    immagine

    immagine

  3. Sostituire il codice del metodo evento dell'handler transformRequestPayload (intorno alle righe 24-26) con il codice seguente.

    • transformRequestPayload:

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

      Ogni richiesta deve solo passare l'ultimo input utente al prompt LLM.

  4. Sostituire il codice del metodo evento del gestore transformResponsePayload (intorno alle righe 35-37) con il codice seguente.

    • transformRequestPayload:

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

  5. Sostituire il codice del metodo evento del gestore transformErrorResponsePayload (intorno alle righe 47-49) con il codice seguente.

    • 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. Fare clic su Convalida per controllare la sintassi del codice. Utilizzarlo per sostituire il codice nell'editor se si verificano errori di sintassi che non è possibile correggere.

    immagine

  7. Fare clic su Save e Close. Attendere il completamento della distribuzione. Quando viene visualizzato Pronto, è possibile passare al passo successivo.

Task 6.6: definire il servizio LLM per la competenza

Per abilitare la capacità di connettere gli utenti al modello tramite il flusso della finestra di dialogo, è necessario creare un servizio LLM che combini il servizio LLM a livello di istanza che chiama il modello con l'handler di eventi di trasformazione (che in questo caso è per la distribuzione del modello Oracle).

  1. Fare clic sull'icona Impostazioni nella barra di navigazione a sinistra.

    Barra di navigazione sinistra

  2. Fare clic su Configurazione.

    Scheda Configurazione in Impostazioni

  3. Nella pagina Servizi LLM, fare clic su +New Servizio LLM.

    Sezione Modello di lingua estesa della pagina Configurazione.

  4. Immettere le informazioni riportate di seguito

    • Nome: immettere un nome facilmente identificabile per il servizio LLM. Questo nome verrà utilizzato come riferimento quando si genera il flusso di finestre di dialogo nel passo successivo.

    • Servizio LLM: selezionare il nome del servizio LLM a livello di istanza creato in Task 1: Creare il servizio REST nel modello.

    • Handler trasformazione: selezionare il nome del componente del gestore di eventi creato nell'ambito del servizio REST in Task 3: Connettere lo skill al modello.

    • Lasciare le proprietà rimanenti nelle impostazioni predefinite. Si noti che Predefinito è abilitato, se si tratta dell'unico servizio creato finora per questa esercitazione.

      immagine

  5. Fare clic su Save.

    Icona Salva servizio

  6. Deselezionare Feedback e altri switch predefiniti.

    immagine

Task 6.7: Integrare il servizio

Ora che l'abilità è connessa all'LLM, connettere gli utenti dell'abilità al modello creando un componente di flusso della finestra di dialogo che può chiamare il modello e dirgli cosa fare. Il componente trasmette queste istruzioni utilizzando un prompt, che è un blocco di testo leggibile dall'utente. In questo task, forniremo questo prompt, che indica al modello di valutare il feedback dell'utente come positivo o negativo o neutro.

  1. Fare clic sull'icona Flussi nella barra di navigazione sinistra.

    Icona Flussi nella barra di navigazione a sinistra

  2. Selezionare unresolvedIntent.

    Flusso non risolto

  3. Nello stato unresolvedMessage fare clic sull'icona ellipsis(...) e selezionare Aggiungi stato dal menu.

    Opzione Aggiungi stato

  4. Selezionare Service Integration e Richiama modello di linguaggio di grandi dimensioni.

  5. Immettere una descrizione simile all'analisi del sentiment e fare clic su Inserisci.

    immagine

    Il flusso della finestra di dialogo ora include lo stato unresolvedMessage (Invia messaggio), lo stato invokeLLM e lo stato showLLMError.

    Lo stato invokeLLM con lo stato showError nel flusso della finestra di dialogo

  6. Nello stato unresolvedMessage fare clic sull'icona ellipsis(...) e selezionare Elimina dal menu in quanto non si desidera visualizzare il messaggio di errore per UnresolvedIntent.

    immagine

    Il flusso della finestra di dialogo ora include solo lo stato invokeLLM e lo stato showLLMError.

    immagine

  7. Aprire lo stato invokeLLM. Nella pagina Componente, selezionare il servizio LLM creato nel task 6.6.

    Il settore LLM Service

  8. Aggiungere un prompt che invii istruzioni al servizio LLM incollando quanto riportato di seguito in Prompt. Tutte le conversazioni utente devono essere passate come input prompt.

    immagine

  9. Creare la variabile PROMPT_INPUT. Fare clic su Parametri prompt + per aggiungere un nuovo parametro e il relativo valore.

    immagine

  10. Impostare Usa streaming su False in modo che il messaggio venga consegnato nella sua interezza e non in modo incrementale.

    immagine

  11. Eseguire il test del prompt con Prompt Builder e fare clic su Crea prompt

    immagine

  12. Aggiungere Valore modello parametro prompt e fare clic su Genera output. In questo modo possiamo convalidare l'integrazione LLM.

    immagine

Task 6.8: Testare il prompt con il tester skill

  1. Fare clic su Anteprima per aprire il tester skill.

    Pulsante Anteprima

  2. Immettere la richiesta seguente: È possibile fornire una panoramica su Oracle Database 23.4?.

    L'output dovrebbe essere simile al seguente:

    immagine

  3. Chiedi la query successiva a LLM: l'ultimo database oracle.

    L'output dovrebbe essere simile al seguente:

    immagine

Task 6.9: Impostazione del canale utente Web Oracle

Verrà creato un canale utente Oracle Digital Assistant che consente a un client Web Oracle di accedere alle competenze. Per garantire che solo i nostri clienti Web possano utilizzare questo canale, lo configureremo per richiedere l'autenticazione del client.

  1. Aprire Oracle Digital Assistant, passare a Sviluppo, Canali e fare clic su Canale +Add.

  2. In Crea canale, immettere le informazioni riportate di seguito per creare un'operazione POST nell'endpoint del provider e fare clic su Crea.

    • Nome: nome univoco che inizia con una lettera e contiene solo lettere, numeri, punti e caratteri di sottolineatura. Ad esempio, OCI_MD_LLM.
    • Descrizione (facoltativo): a cosa serve il canale.
    • Tipo di canale: selezionare Web Oracle.
    • Domini consentiti: immettere *.
    • Autenticazione client abilitata: deselezionare.

    immagine

  3. Deselezionare Autenticazione client abilitata se non è già disabilitata.

  4. In Ciclo, selezionare lo skill che si desidera utilizzare. È stata selezionata la competenza corrente LLM-MD-Skill.

  5. Abilita Canale abilitato.

  6. Prendere nota dell'ID canale e dell'URI dominio ODA senza https, visualizzati per questo canale.

Useremo questi valori nella nostra applicazione web e nella configurazione di routing del generatore di token.

Task 6.10: Installare l'SDK

Scaricare il file zip ed estrarlo nel sistema locale. Questo file zip include una guida per l'utente che descrive le classi dell'SDK e un'applicazione di esempio che illustra molte delle sue funzioni.

  1. Vai alla sezione Download di Oracle Digital Assistant (ODA) e Oracle Mobile Cloud (OMC) e SDK Web Oracle Native Client (per ambienti nativi OCI).

  2. Scarica ODA Web SDK 24.06.

  3. In Piattaforme, selezionare GENERIC.

  4. Fare clic per scaricare l'SDK ODA Js più recente, ovvero oda-native-client-sdk-js-24_06 for (GENERIC (All Platforms).

    immagine

  5. Estrarre il file zip scaricato.

Task 6.11: Test dell'applicazione Web Oracle

  1. Andare alla cartella zip estratta del kit Oracle Web SDK scaricato.

  2. Aprire il file samples/web/settings.js e sostituire <URI> e <channelId> con il valore effettivo.

    Ad esempio:

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

  3. Assicurarsi inoltre che isClientAuthEnabled sia falso.

    let isClientAuthEnabled = false;

  4. Eseguire il file samples/web/index.html su qualsiasi browser.

  5. Ignorare il contenuto del file di indice. Fare clic sull'icona della chat per visualizzare lo stato di Oracle Assistant CONNECTED.

    immagine

  6. Ecco come appare il nostro sito web con l'icona della chat nell'angolo in basso a destra. Possiamo iniziare una conversazione, come abbiamo fatto in precedenza con il tester di abilità.

    immagine

    immagine

Task 6.12: rilasciare l'istanza di OCI Compute

  1. Creare l'istanza OCI Compute. Per ulteriori informazioni, vedere Creazione di un'istanza.

  2. Assicurarsi di aver seguito le regole di entrata.

    immagine

  3. Copiare tutte le cartelle Web nell'istanza appena creata.

  4. Installare NGINX. Per ulteriori informazioni, vedere Installa il server Web e il proxy NGINX su Oracle Linux.

  5. Aprire un browser e passare a http://<IP_address>/. Se si dispone di un certificato con firma automatica, è possibile passare a https://<IP_address>/.

Risultati

Confrontiamo gli output direttamente chiedendo al LLM rispetto all'utilizzo di RAG con LLM:

Passi successivi

Creare un chatbot avanzato utilizzando Oracle Database 23ai, RAG, LangChain, Mistral-7B-Instruct-v0.2 e Oracle Digital Assistant mostra la potenza di integrare tecnologie all'avanguardia per creare un agente conversazionale altamente reattivo e intelligente. Il flusso di lavoro dettagliato, dalla gestione delle richieste alla generazione delle risposte, garantisce che il chatbot possa recuperare ed elaborare in modo efficiente grandi quantità di informazioni, fornendo risposte accurate e contestualmente pertinenti agli utenti. Sfruttando le funzionalità di ricerca vettoriale di Oracle Database 23ai e la solida piattaforma fornita da Oracle Digital Assistant, gli sviluppatori possono migliorare in modo significativo le prestazioni e il coinvolgimento degli utenti del chatbot. Questo approccio integrato non solo semplifica il processo di sviluppo, ma si traduce anche in una soluzione AI scalabile, efficiente e altamente efficace che si distingue nel panorama competitivo degli assistenti digitali. Che si tratti di assistenza clienti, recupero delle informazioni o supporto interattivo, questa architettura chatbot avanzata apre la strada alla creazione di sofisticate esperienze di conversazione che soddisfano le esigenze degli utenti moderni.

Per ulteriori informazioni su come utilizzare le azioni rapide di AI, vai alla list di Oracle Cloud Infrastructure Data Science YouTube per vedere un video dimostrativo su AI Quick Actions e trovare la nostra documentazione tecnica e consultare il nostro repository di Github con suggerimenti ed esempi.

Se desideri suggerire modelli specifici da aggiungere alle azioni rapide di AI o hai domande, invia un'e-mail al gruppo OCI Data Science: ask-oci-data-science_grp@oracle.com.

Conferme

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti gratuiti sulla formazione su Oracle Learning YouTube channel. Inoltre, visita education.oracle.com/learning-explorer per diventare un Oracle Learning Explorer.

Per la documentazione del prodotto, visita l'Oracle Help Center.