Note:

Crea un chatbot empresarial con Oracle Digital Assistant, OCI Data Science, LangChain y Oracle Database 23ai

Introducción

En el panorama digital actual, los chatbots están evolucionando para ser más inteligentes, receptivos y capaces de manejar interacciones complejas. En este tutorial, profundizamos en la creación de un chatbot de última generación aprovechando el poder de las capacidades de Oracle Cloud Infrastructure (OCI) Data Science como AI Quick Actions y Model Deployment, Mistral-7B-Instruct-v0.2, Oracle Database 23ai, LangChain y Oracle Digital Assistant. Cada una de estas tecnologías aporta puntos fuertes únicos a la mesa, lo que nos permite crear un chatbot que no solo entienda y responda a las consultas de los usuarios con una precisión notable, sino que también ofrezca una experiencia conversacional fluida y atractiva.

Una de las características destacadas de Oracle Database 23ai son sus capacidades avanzadas de búsqueda vectorial. Esta tecnología permite una recuperación eficiente de la información mediante la conversión de texto en vectores de alta dimensión, que luego se comparan por relevancia. Cuando se integra en el pipeline de generación aumentada de recuperación (RAG), la búsqueda vectorial de Oracle Database 23ai mejora la capacidad del chatbot para acceder y entregar la información más pertinente de vastos conjuntos de datos. Esto garantiza que las respuestas generadas no solo sean contextualmente precisas, sino que también sean altamente relevantes para la consulta del usuario.

Oracle Digital Assistant mejora aún más la funcionalidad del chatbot al proporcionar una plataforma sólida para crear, desplegar y gestionar soluciones de IA conversacional. Ofrece conectores incorporados, comprensión del lenguaje natural (NLU) y gestión del diálogo, que optimizan el proceso de desarrollo y garantizan una experiencia de usuario fluida. La combinación de Oracle Digital Assistant con el pipeline RAG permite al chatbot gestionar interacciones complejas y mantener un flujo natural de conversaciones, lo que mejora la interacción y la satisfacción del usuario.

Al aprovechar la sinergia de Oracle Database 23ai y Oracle Digital Assistant en el pipeline de RAG, los desarrolladores pueden crear un chatbot que destaca tanto por la precisión de la recuperación como por la fluidez conversacional. Este enfoque integrado no solo reduce el tiempo y el esfuerzo necesarios para crear bots conversacionales sofisticados, sino que también da como resultado una solución escalable, eficiente y capaz de ofrecer experiencias de usuario superiores. Ya sea que sea un desarrollador, un entusiasta de la tecnología o un líder de negocios que busca mejorar la interacción con el cliente, este tutorial lo equipará con el conocimiento y las herramientas para construir un chatbot avanzado que se destaca en el abarrotado escenario digital.

Para obtener una guía detallada sobre el proceso, consulte Repositorio GitHub de ejemplos de IA.

Casos de uso

A continuación se muestran algunos casos de uso de ejemplo en los que puede resultar útil:

Ventajas de Oracle AI Vector Search

Oracle Database es un repositorio líder de datos operativos y empresariales. Las aplicaciones empresariales suelen necesitar buscar una combinación de datos de negocio y datos no estructurados. Por ejemplo, un sitio web minorista podría incluir búsquedas basadas en una descripción del producto en lenguaje natural y una imagen de producto objetivo, junto con otros filtros, como el precio, la ubicación de la tienda, el fabricante y la disponibilidad actual. Esta búsqueda requiere la búsqueda simultánea de datos de catálogo no estructurados (descripción e imagen del producto), datos de catálogo estructurado (precio, ubicación de la tienda y fabricante), así como datos transaccionales en tiempo real (como el inventario actual).

Descripción general de la solución de arquitectura de alto nivel

image

Figura: Una arquitectura de alto nivel del pipeline de RAG

En el siguiente diagrama se ilustra la arquitectura y el flujo de trabajo de la creación de un chatbot avanzado con Mistral-7B-Instruct-v0.2, Oracle Database 23ai, RAG, LangChain y Oracle Digital Assistant. Estos son los pasos detallados involucrados en la siguiente arquitectura.

  1. Interacción con el usuario: el usuario envía una solicitud al chatbot a través de la interfaz de Oracle Digital Assistant.

  2. Gestión de solicitudes: Oracle Digital Assistant recibe la solicitud y la reenvía a la infraestructura de OCI Data Science.

  3. Procesamiento de consultas: hay 2 pasos implicados.

    • En OCI Data Science, la solicitud se enruta a LangChain, que actúa como orquestador para gestionar la interacción entre varios despliegues de modelo.
    • LangChain procesa la solicitud e identifica la necesidad de recuperación de información de documentos externos y datos empresariales.

  4. Vectorización: este paso implica los siguientes subprocesos:

    • La solicitud se envía a un despliegue de modelo embebido, que transforma la consulta en una representación vectorial de alta dimensión.
    • Esta consulta vectorizada se envía a Oracle Database 23ai para la búsqueda vectorial.

  5. Recuperación de datos: este paso implica los siguientes subprocesos:

    • Oracle Database 23ai realiza una búsqueda de similitud en datos no estructurados en forma de documentos en formato PDF y HTML y combina esa búsqueda con una búsqueda regular en otros datos de negocio de la base de datos.
    • Los documentos o fragmentos relevantes se recuperan y se enviarán al siguiente paso para su procesamiento posterior.

  6. Reordenación:

    • La respuesta generada puede ser refinada por un despliegue de modelo de rerank.
    • El modelo de rerank evalúa y clasifica las respuestas para garantizar que se seleccione la respuesta más relevante y precisa.

  7. Consulta de modelos externos: en este paso, los datos se recuperan y generan una respuesta.

    • La información recuperada se utiliza para generar una consulta para el despliegue del modelo Mistral-7B-Instruct-v0.2 aprovisionado mediante las funciones de acciones rápidas de IA en OCI Data Science.
    • El modelo Mistral-7B-Instruct-v0.2 procesa la consulta y genera una respuesta basada en su entrenamiento y el contexto recuperado.

  8. Generación de respuesta: la respuesta refinada se devuelve a LangChain, que consolida la salida final.

  9. Devolviendo la respuesta al usuario:

    • La respuesta final se devuelve al asistente digital.
    • A continuación, Oracle Digital Assistant ofrece la respuesta al usuario.

Objetivos

Requisitos

Requisitos clave que tendría que configurar para poder continuar con la ejecución del proceso de ajuste distribuido en OCI Data Science Service.

Tarea 1: Despliegue de los modelos necesarios

Tarea 1.1: Despliegue del modelo Mistral-7B-Instruct-v0.2

Aprovecharemos la función de despliegue del modelo de acciones rápidas de IA para desplegar Mistral-7B-Instruct-v0.2 con unos pocos clics. El despliegue del modelo de acciones rápidas de IA ayuda a los usuarios a desplegar Mistral-7B-Instruct-v0.2 con unos pocos clics y proporcionar a los usuarios un punto final.

image

image

Tarea 1.2: Despliegue del Modelo de Embebido de Jina

  1. En Notebook, copie los archivos de modelo Jine Embedding de https://huggingface.co/jinaai/jina-embeddings-v2-base-en/tree/main en el directorio ads_embedding_model_dir.

  2. Cargue el archivo score.py en el directorio actual (por ejemplo, /home/datascience/).

  3. Ejecute el siguiente comando:

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

Tarea 1.3: Desplegar el modelo de Bge-Reranker

Ejecute el siguiente comando:

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

Tarea 2: Configuración de Oracle Database 23ai

Utilizaremos las últimas funciones de Oracle Database 23ai, específicamente Oracle AI Vector Search, para nuestro caso de uso. En este escenario, importaremos los embebidos generados a partir del juego de datos en Oracle Database 23ai. Cuando un usuario consulta mediante la RAG, la respuesta se mejorará proporcionando a los LLM contexto adicional. En el siguiente diagrama se muestran algunas de las ventajas de utilizar Oracle Database 23ai.

image

Figura: ilustración de la función de búsqueda de Oracle Database 23ai (fuente)

Esto aumentará su conocimiento, lo que dará lugar a respuestas más precisas y pertinentes para las consultas del cliente. Para configurar Oracle Database 23ai, siga las opciones mencionadas.

Utilizaremos una instancia alojada de Oracle Database 23ai para demostrar las potentes funciones de Oracle AI Vector Search.

Tarea 3: Análisis, Fragmentación y Almacenamiento Embebido en Oracle Database 23ai

El siguiente fragmento de código proporciona una visión general de alto nivel de cómo se analiza el documento, cómo se convierte el documento en fragmentos y, a continuación, cómo se almacenará la embebido en Oracle Database 23ai. Para obtener más información, consulte oda-oci-data-science-oracledb-23ai-llm.

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

Tarea 4: Conexión al LLM de acciones rápidas de IA de Mistral-7B-Instruct-v0.2

Cree un despliegue de modelo con AI Quick Actions y obtenga el punto final de despliegue de modelo desde allí. Ejecute el siguiente código para conectarse al 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"
)

Tarea 5: Configurar RAG

La siguiente arquitectura de RAG constará de los siguientes pasos:

Tarea 5.1: Cargar en base de datos vectorial de 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'])

Utilizamos la plantilla de petición de datos y la cadena de control de calidad proporcionada por Langchain para hacer el chatbot, esto ayuda a pasar el contexto y la pregunta directamente al LLM.

Tarea 5.2: Despliegue del modelo 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?')

Tarea 6: Creación de un asistente digital mediante Oracle Digital Assistant para que la aplicación de chatbot aloje RAG

Tarea 6.1: Obtener punto final de despliegue de modelo y agregar política

Agregue un servicio REST a una instancia que llame al proveedor del modelo. Utilizamos el despliegue del modelo de Oracle como ejemplo, pero podemos utilizar un servicio REST para cualquier LLM.

image

Agregue una política para que Oracle Digital Assistant pueda acceder al punto final de predicción de despliegue de modelo. Vaya a Identidad y seguridad, Políticas y haga clic en Crear política.

image

Políticas para grupo dinámico

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

Una vez creada la política, podemos iniciar Oracle Digital Assistant y abrirla en un explorador.

Tarea 6.2: Creación del servicio REST del proveedor de LLM

  1. Vaya a Oracle Digital Assistant, vaya a Configuración, Servicios de API, Servicios LLM y haga clic en +Add Servicio LLM.

  2. En la página Crear servicio de LLM, introduzca la siguiente información para crear una operación de contabilización en el punto final del proveedor y haga clic en Crear.

    • Nombre: introduzca un nombre fácilmente identificable para el servicio. Más adelante hará referencia a este nombre.
    • Punto final: copie y pegue el punto final de despliegue del modelo.
    • Métodos: seleccione POST.

    image

  3. Complete el servicio agregando la clave de API y los ejemplos de carga útil de solicitud y respuesta.

    • Tipo de autenticación: seleccione Entidad de recurso de OCI.

    • Tipo de contenido: seleccione application/json.

    • Cuerpo: agregue la carga útil enviada a la solicitud. Por ejemplo:

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

    image

  4. Haga clic en Solicitud de prueba para comprobar si hay una respuesta 200.

    image

Tarea 6.3: Creación de una aptitud

Con el servicio REST de proveedor de LLM agregado a la instancia, ahora necesitamos crear una aptitud que pueda llamar a este servicio y conectar a los usuarios a través de su definición de flujo de diálogo. Para crear esta aptitud, realice los siguientes pasos:

  1. Vaya a Oracle Digital Assistant, vaya a Development y +Skills.

  2. Haga clic en + Nueva aptitud.

  3. En la página Crear aptitud, introduzca la siguiente información y haga clic en Crear.

    • Nombre mostrado: agregue un nombre.
    • Modo de diálogo: seleccione Visual.
    • En los demás campos, deje los valores por defecto.

    image

Tarea 6.4: Conexión de la aptitud al modelo

Ahora vamos a permitir que la aptitud acceda al servicio REST de LLM mediante la creación de un componente personalizado con un manejador de eventos que transforme las cargas útiles de REST en formatos aceptados tanto por el proveedor de LLM como por Oracle Digital Assistant.

  1. Haga clic en el ícono Components (Componentes) en la barra de navegación izquierda y en Add Service (Agregar servicio).

    Icono Componentes de la barra de navegación izquierda

  2. En la página Crear servicio, introduzca la siguiente información y haga clic en Crear.

    • Nombre: Introduzca un nombre que describa el servicio.
    • Tipo de servicio: acepte la configuración por defecto y seleccione Contenedor embebido.
    • Tipo de Creación de Paquete de Servicios de Componente: Seleccione Nuevo Componente.
    • Tipo de componente: seleccione Transformación de LLM.
    • Nombre de componente: introduzca un nombre descriptivo.
    • Plantilla: seleccione Personalizada (ubicada en other).

    image

  3. El componente completado se muestra en la página Componentes.

    image

  4. Seleccione el componente en la página Componentes para comprobar su estado de despliegue. Cuando se muestra Listo, puede pasar al siguiente paso.

    image

    Asegúrese de que la opción Servicio activado (valor por defecto) esté activada.

    image

Tarea 6.5: Asignación de solicitudes y respuestas del proveedor de servicios de LLM y Oracle Digital Assistant

Las solicitudes de la aptitud al proveedor de servicios del modelo deben transformarse de la interfaz utilizada por Oracle Digital Assistant, que se conoce como interfaz LLM común (CLMI) al formato aceptado por el proveedor de servicios. Asimismo, los resultados devueltos por el proveedor de servicios también deben transformarse en CLMI. Para activar esta asignación, los siguientes métodos de manejador de eventos de servicio REST deben tener un código específico de proveedor.

Para abrir el editor de código de manejador de eventos y actualizar el código de transformación (en este caso, para Azure OpenAI), siga los pasos:

  1. Amplíe el servicio y seleccione el manejador de eventos.

    image

  2. Haga clic en el icono Editar para abrir el editor.

    image

    image

  3. Sustituya el código de método de evento de manejador transformRequestPayload (alrededor de las líneas 24 a 26) por el siguiente código.

    • transformRequestPayload:

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

      Cada solicitud solo tiene que pasar la última entrada de usuario al indicador de LLM.

  4. Sustituya el código de método de evento de manejador transformResponsePayload (alrededor de las líneas 35 a 37) por el siguiente código.

    • transformRequestPayload:

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

  5. Sustituya el código de método de evento de manejador transformErrorResponsePayload (alrededor de las líneas 47-49) por el siguiente código.

    • 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. Haga clic en Validar para comprobar la sintaxis del código. Utilícelo para sustituir el código en el editor si encuentra errores de sintaxis que no puede corregir.

    image

  7. Haga clic en Guardar y en Cerrar. Espere a que termine el despliegue. Cuando se muestra Listo, puede pasar al siguiente paso.

Tarea 6.6: Definición del servicio de LLM para la aptitud

Para permitir que la aptitud conecte usuarios al modelo a través del flujo de diálogo, debe crear un servicio de LLM que combine el servicio de LLM de toda la instancia que llama al modelo con el manejador de eventos de transformación (que en este caso es para el despliegue de modelos Oracle).

  1. Haga clic en el icono Configuración de la barra de navegación izquierda.

    Barra de navegación izquierda

  2. Haga clic en Configuración.

    El separador Configuration de Settings

  3. En la página Servicios de modelos de lenguaje grandes, haga clic en +New LLM Service.

    Sección Large Language Model de la página Configuration.

  4. Introduzca la siguiente información

    • Nombre: introduzca un nombre fácilmente identificable para el servicio LLM. Al crear el flujo de diálogo en el siguiente paso, hará referencia a este nombre.

    • Servicio LLM: seleccione el nombre del servicio LLM de toda la instancia que ha creado en la Tarea 1: crear el servicio REST en el modelo.

    • Manejador de transformación: seleccione el nombre del componente de manejador de eventos que ha creado como parte del servicio REST en la Tarea 3: Conexión de la aptitud al modelo.

    • Deje las propiedades restantes en su configuración por defecto. Tenga en cuenta que Valor por Defecto está activado, si este es el único servicio que ha creado hasta ahora para este tutorial.

      image

  5. Haga clic en Guardar.

    Icono Guardar Servicio

  6. Anule la selección de Feedback y otros valores predeterminados en los conmutadores.

    image

Tarea 6.7: Integración del Servicio

Ahora que la aptitud está conectada al LLM, conecte los usuarios de la aptitud al modelo mediante la creación de un componente de flujo de diálogo que pueda llamar al modelo y decirle qué hacer. El componente transmite estas instrucciones mediante una petición de datos, que es un bloque de texto legible por el usuario. En esta tarea, proporcionaremos esta petición de datos, que instruye al modelo sobre la evaluación de los comentarios de los usuarios como positivos, negativos o neutrales.

  1. Haga clic en el icono Flujos de la barra de navegación izquierda.

    Icono Flujos de la barra de navegación izquierda

  2. Seleccione unresolvedIntent.

    Flujo sin resolver

  3. En el estado unresolvedMessage, haga clic en el icono ellipsis(...) y seleccione Agregar estado en el menú.

    La opción Add State

  4. Seleccione Service Integration y Llamar a modelo de lenguaje grande.

  5. Introduzca una descripción como análisis de sentimiento y haga clic en Insertar.

    image

    El flujo de diálogo incluye ahora el estado unresolvedMessage (Enviar mensaje), el estado invokeLLM y el estado showLLMError.

    Estado invokeLLM con el estado showError en el flujo de diálogo

  6. En el estado unresolvedMessage, haga clic en el icono ellipsis(...) y seleccione Suprimir en el menú, ya que no queremos mostrar el mensaje de error de UnresolvedIntent.

    image

    El flujo de diálogo ahora incluye el estado invokeLLM y el estado showLLMError únicamente.

    image

  7. Abra el estado invokeLLM. En la página Componente, seleccione el servicio de LLM que hemos creado en la tarea 6.6.

    El campo LLM Service

  8. Agregue una petición de datos que envíe instrucciones al servicio de LLM pegando lo siguiente en la Petición de datos. Todas las conversaciones de usuario deben pasar como entrada de mensaje.

    image

  9. Cree la variable PROMPT_INPUT. Haga clic en Parámetros de Petición de Datos + para agregar un nuevo parámetro y su valor.

    image

  10. Defina Usar Streaming en Falso para que el mensaje se entregue en su totalidad, no de forma incremental.

    image

  11. Pruebe la petición de datos con el Creador de Peticiones de Datos y haga clic en Crear Petición de Datos

    image

  12. Agregue Valor ficticio de parámetro de petición de datos y haga clic en Generar salida. De esta manera podemos validar la integración de LLM.

    image

Tarea 6.8: Prueba de la petición de datos con el comprobador de aptitudes

  1. Haga clic en Vista previa para abrir el comprobador de aptitudes.

    El botón Preview

  2. Introduzca la siguiente solicitud: ¿Puede proporcionar una visión general de Oracle Database 23.4?.

    La salida debe tener este aspecto:

    image

  3. Consulte la siguiente consulta al LLM: última base de datos oracle.

    La salida debe tener este aspecto:

    image

Tarea 6.9: Configuración del canal de usuario web de Oracle

Crearemos un canal de usuario de Oracle Digital Assistant que permita a un cliente web de Oracle acceder a la aptitud. Para garantizar que solo nuestros clientes web puedan utilizar este canal, lo configuraremos para requerir autenticación de cliente.

  1. Abra Oracle Digital Assistant, vaya a Desarrollo, Canales y haga clic en Canal +Add.

  2. En Crear canal, introduzca la siguiente información para crear una operación POST en el punto final del proveedor y haga clic en Crear.

    • Nombre: nombre único que comienza con una letra y contiene solo letras, números, puntos y guiones bajos. Por ejemplo, OCI_MD_LLM.
    • Descripción (opcional): para qué se utiliza el canal.
    • Channel Type: seleccione Oracle Web.
    • Dominios permitidos: introduzca *.
    • Autenticación de Cliente Activada: Anule la selección.

    image

  3. Anule la selección de Autenticación de cliente activada si aún no está desactivada.

  4. En Ruta, seleccione la aptitud que desea utilizar. Hemos seleccionado la aptitud actual que es LLM-MD-Skill.

  5. Active Canal activado.

  6. Observe el ID de canal y el URI de dominio de ODA sin https que se muestran para este canal.

Utilizaremos estos valores en nuestra aplicación web y en la configuración de enrutamiento del generador de tokens.

Tarea 6.10: Instalación del SDK

Descargar el zip y extraerlo en su sistema local. Este zip incluye una guía de usuario que describe las clases de SDK y una aplicación de ejemplo que demuestra muchas de sus funciones.

  1. Vaya a la sección Descargas de Oracle Digital Assistant (ODA) y Oracle Mobile Cloud (OMC) y SDK de cliente nativo de Oracle (para entornos nativos de OCI) SDK web.

  2. Descargue ODA Web SDK 24.06.

  3. En Plataformas, seleccione GENÉRICA.

  4. Haga clic para descargar el SDK de ODA Js más reciente que es oda-native-client-sdk-js-24_06 for (GENERIC (All Platforms).

    image

  5. Extraiga el archivo zip descargado.

Tarea 6.11: Prueba de la aplicación web de Oracle

  1. Vaya a la carpeta zip extraída del SDK web de Oracle descargado.

  2. Abra el archivo samples/web/settings.js y sustituya <URI> y <channelId> por un valor real.

    Por ejemplo:

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

  3. Además, asegúrese de que isClientAuthEnabled es falso.

    let isClientAuthEnabled = false;

  4. Ejecute el archivo samples/web/index.html en cualquier explorador.

  5. Ignore el contenido del archivo de índice. Haga clic en el icono de chat y mostrará el estado Oracle Assistant CONNECTED.

    image

  6. Así es como se ve nuestro sitio web con el icono de chat en la esquina inferior derecha. Podemos iniciar una conversación, como lo hicimos anteriormente con el comprobador de habilidades.

    image

    image

Tarea 6.12: Versión en instancia informática de OCI

  1. Cree una instancia informática de OCI. Para obtener más información, consulte Creación de una instancia

  2. Asegúrese de seguir las reglas de entrada.

    image

  3. Copie todas las carpetas web en la instancia recién creada.

  4. Instale NGINX. Para obtener más información, consulte Install the NGINX Web Server and Proxy on Oracle Linux.

  5. Abra un explorador y vaya a http://<IP_address>/. Si tiene un certificado autofirmado, puede navegar a https://<IP_address>/.

Resultado

Comparemos los resultados de preguntar directamente al LLM frente al uso de RAG con LLM:

Pasos Siguientes

La creación de un chatbot avanzado con Oracle Database 23ai, RAG, LangChain, Mistral-7B-Instruct-v0.2 y Oracle Digital Assistant muestra el poder de integrar tecnologías de vanguardia para crear un agente conversacional inteligente y con alta capacidad de respuesta. El flujo de trabajo detallado, desde el manejo de solicitudes hasta la generación de respuestas, garantiza que el chatbot pueda recuperar y procesar de manera eficiente grandes cantidades de información, brindando respuestas precisas y contextualmente relevantes a los usuarios. Al aprovechar las capacidades de búsqueda vectorial de Oracle Database 23ai y la sólida plataforma proporcionada por Oracle Digital Assistant, los desarrolladores pueden mejorar significativamente el rendimiento del chatbot y la interacción del usuario. Este enfoque integrado no solo agiliza el proceso de desarrollo, sino que también da como resultado una solución de IA escalable, eficiente y altamente efectiva que se destaca en el panorama competitivo de los asistentes digitales. Ya sea para el servicio al cliente, la recuperación de información o el soporte interactivo, esta arquitectura avanzada de chatbots allana el camino para crear experiencias conversacionales sofisticadas que satisfagan las demandas de los usuarios modernos.

Para obtener más información sobre cómo utilizar las acciones rápidas de IA, vaya a la lista de reproducción YouTube de Oracle Cloud Infrastructure Data Science para ver un vídeo de demostración de las acciones rápidas de IA, busque nuestra documentación técnica y consulte nuestro repositorio de Github con consejos y ejemplos.

Si desea sugerir modelos específicos para agregarlos a las acciones rápidas de IA o tiene preguntas, envíe un correo electrónico al grupo de OCI Data Science: ask-oci-data-science_grp@oracle.com.

Agradecimientos

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de formación gratuita en el canal YouTube de Oracle Learning. Además, visita education.oracle.com/learning-explorer para convertirte en un Oracle Learning Explorer.

Para obtener documentación sobre el producto, visite Oracle Help Center.