Observação:

Crie um Chatbot Empresarial com o Oracle Digital Assistant, OCI Data Science, LangChain e Oracle Database 23ai

Introdução

No cenário digital atual, os chatbots estão evoluindo para se tornarem mais inteligentes, responsivos e capazes de lidar com interações complexas. Neste tutorial, aprofundamos a criação de um chatbot de última geração aproveitando o poder dos recursos do Oracle Cloud Infrastructure (OCI) Data Science, como AI Quick Actions e Model Deployment, Mistral-7B-Instruct-v0.2, Oracle Database 23ai, LangChain e Oracle Digital Assistant. Cada uma dessas tecnologias traz pontos fortes únicos para a mesa, permitindo-nos construir um chatbot que não só entende e responde às consultas dos usuários com precisão notável, mas também oferece uma experiência de conversação perfeita e envolvente.

Um dos recursos de destaque do Oracle Database 23ai são seus recursos avançados de pesquisa vetorial. Esta tecnologia permite a recuperação eficiente de informações, convertendo texto em vetores de alta dimensão, que são então comparados por relevância. Quando integrada ao pipeline de geração aumentada de recuperação (RAG), a pesquisa vetorial do Oracle Database 23ai aprimora a capacidade do chatbot de acessar e fornecer as informações mais pertinentes de vastos conjuntos de dados. Isso garante que as respostas geradas não sejam apenas contextualmente precisas, mas também altamente relevantes para a consulta do usuário.

O Oracle Digital Assistant eleva ainda mais a funcionalidade do chatbot, fornecendo uma plataforma robusta para criar, implementar e gerenciar soluções de IA conversacional. Ele oferece conectores pré-construídos, compreensão de linguagem natural (NLU) e gerenciamento de diálogo, que agilizam o processo de desenvolvimento e garantem uma experiência de usuário tranquila. A combinação do Oracle Digital Assistant com o pipeline de RAG permite que o chatbot lide com interações complexas e mantenha um fluxo natural de conversas, melhorando assim o envolvimento e a satisfação do usuário.

Aproveitando a sinergia do Oracle Database 23ai e do Oracle Digital Assistant no pipeline de RAG, os desenvolvedores podem criar um chatbot que se destaca na precisão da recuperação e na fluidez conversacional. Essa abordagem integrada não apenas reduz o tempo e o esforço necessários para criar chatbots sofisticados, mas também resulta em uma solução escalável, eficiente e capaz de oferecer experiências de usuário superiores. Se você é um desenvolvedor, um entusiasta de tecnologia ou um líder de negócios que procura melhorar o envolvimento do cliente, este tutorial irá equipá-lo com o conhecimento e as ferramentas para construir um chatbot avançado que se destaca na arena digital lotada.

Para obter o passo a passo do processo, consulte repositório GitHub de amostras de IA.

Casos de Uso

Aqui estão alguns exemplos de casos de uso em que isso pode ser útil:

Benefícios do Oracle AI Vector Search

O Oracle Database é um repositório líder de dados operacionais e empresariais. Os aplicativos empresariais geralmente precisam pesquisar uma combinação de dados de negócios e dados não estruturados. Por exemplo, um site de varejo pode apresentar pesquisas com base em uma descrição de produto em linguagem natural e uma imagem de produto de destino, juntamente com outros filtros, como preço, localização da loja, fabricante e disponibilidade atual. Essa pesquisa requer a pesquisa simultânea de dados de catálogo não estruturados (descrição e imagem do produto), dados de catálogo estruturados (preço, local da loja e fabricante), bem como dados transacionais em tempo real (como estoque atual).

Visão Geral da Solução de Arquitetura de Alto Nível

image

Figura: Uma arquitetura de alto nível do pipeline RAG

O diagrama a seguir ilustra a arquitetura e o workflow da criação de um chatbot avançado usando Mistral-7B-Instruct-v0.2, Oracle Database 23ai, RAG, LangChain e Oracle Digital Assistant. Aqui estão as etapas detalhadas envolvidas na arquitetura a seguir.

  1. Interação do Usuário: O usuário envia uma solicitação ao chatbot por meio da interface do Oracle Digital Assistant.

  2. Tratamento de Solicitações: O Oracle Digital Assistant recebe a solicitação e a encaminha para a infraestrutura do OCI Data Science.

  3. Processamento de Consultas: Há 2 etapas envolvidas.

    • No OCI Data Science, a solicitação é roteada para LangChain, que atua como o orquestrador para gerenciar a interação entre várias implantações de modelo.
    • O LangChain processa a solicitação e identifica a necessidade de recuperação de informações de documentos externos e dados empresariais.

  4. Vetorização: Esta etapa envolve os seguintes subprocessos:

    • A solicitação é enviada para uma implantação de modelo de incorporação, que transforma a consulta em uma representação vetorial de alta dimensão.
    • Essa consulta vetorizada é enviada ao Oracle Database 23ai para pesquisa de vetores.

  5. Recuperação de Dados: Esta etapa envolve os seguintes subprocessos:

    • O Oracle Database 23ai executa uma pesquisa de similaridade em dados não estruturados na forma de documentos em formato PDF e HTML e combina essa pesquisa com pesquisa regular em outros dados de negócios no banco de dados.
    • Documentos ou partes relevantes são recuperados e serão enviados para a próxima etapa para processamento posterior.

  6. Reclassificação:

    • A resposta gerada pode ser refinada ainda mais por uma implantação de modelo de nova classificação.
    • O modelo de reclassificação avalia e classifica as respostas para garantir que a resposta mais relevante e precisa seja selecionada.

  7. Consultando os Modelos Externos: Nesta etapa, os dados são recuperados e geram uma resposta.

    • As informações recuperadas são usadas para gerar uma consulta para a implantação de modelo Mistral-7B-Instruct-v0.2 provisionada usando os recursos AI Quick Actions no OCI Data Science.
    • O modelo Mistral-7B-Instruct-v0.2 processa a consulta e gera uma resposta com base em seu treinamento e no contexto recuperado.

  8. Geração de Resposta: A resposta refinada é enviada de volta para LangChain, que consolida a saída final.

  9. Retornar a Resposta ao usuário:

    • A resposta final é retornada ao Assistente Digital.
    • Em seguida, o Oracle Digital Assistant entrega a resposta ao usuário.

Objetivos

Pré-requisitos

Os principais pré-requisitos que você precisaria configurar para poder continuar a executar o processo de ajuste fino distribuído no OCI Data Science Service.

Tarefa 1: Implantar Modelos Necessários

Tarefa 1.1: Implantar o Modelo Mistral-7B-Instruct-v0.2

Aproveitaremos o recurso de implantação do Modelo de Ações Rápidas de IA para implantar o Mistral-7B-Instruct-v0.2 com alguns cliques. A implantação do modelo AI Quick Actions ajuda os usuários a implantar o Mistral-7B-Instruct-v0.2 com alguns cliques e fornecer aos usuários um ponto final.

image

image

Tarefa 1.2: Implantar Modelo de Incorporação Jina

  1. No Notebook, copie os arquivos de modelo Jine Embedding de https://huggingface.co/jinaai/jina-embeddings-v2-base-en/tree/main para o diretório ads_embedding_model_dir.

  2. Faça upload do arquivo score.py para o diretório atual (por exemplo, /home/datascience/).

  3. Execute o código a seguir.

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

Tarefa 1.3: Implantar Modelo Bge-Reranker

Execute o código a seguir.

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

Tarefa 2: Configurar o Oracle Database 23ai

Usaremos os recursos mais recentes do Oracle Database 23ai, especificamente o Oracle AI Vector Search, para nosso caso de uso. Nesse cenário, importaremos as incorporações geradas do conjunto de dados no Oracle Database 23ai. Quando um usuário consulta usando a RAG, a resposta será aprimorada fornecendo aos LLMs contexto adicional. O diagrama a seguir mostra alguns dos benefícios de usar o Oracle Database 23ai.

image

Figura: Uma ilustração do Recurso de Pesquisa do Oracle Database 23ai (fonte)

Isso aumentará seu conhecimento, levando a respostas mais precisas e pertinentes às consultas do cliente. Para configurar o Oracle Database 23ai, siga as opções mencionadas.

Usaremos uma instância hospedada do Oracle Database 23ai para demonstrar os recursos avançados do Oracle AI Vector Search.

Tarefa 3: Análise, Divisão em Blocos e Incorporação de Armazenamento no Oracle Database 23ai

O trecho de código a seguir fornece uma visão geral de alto nível de como o documento é analisado, como o documento é convertido em blocos e, em seguida, como a incorporação será armazenada no Oracle Database 23ai. Para obter mais informações, consulte oda-oci-data-science-oracledb-23ai-llm.

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

Tarefa 4: Conectar-se ao LLM de Ações Rápidas do AI Mistral-7B-Instruct-v0.2

Crie uma implantação de modelo com o AI Quick Actions e obtenha o ponto final de implantação de modelo a partir daí. Execute o código a seguir para estabelecer conexão com o 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"
)

Tarefa 5: Configurar RAG

A seguinte arquitetura RAG consistirá nas seguintes etapas:

Tarefa 5.1: Fazer Upload para o Banco de Dados de Vetores 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'])

Usamos o modelo de prompt e a cadeia de garantia de qualidade fornecidos pela Langchain para criar o chatbot, o que ajuda a transmitir o contexto e a pergunta diretamente para o LLM.

Tarefa 5.2: Implantar 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?')

Tarefa 6: Criar um Assistente Digital usando o Oracle Digital Assistant para Aplicativo de Chatbot para Hospedar RAG

Tarefa 6.1: Obter Ponto Final de Implantação do Modelo e Adicionar Política

Adicione um serviço REST à instância que chame o provedor do modelo. Estamos usando a implantação do modelo Oracle como exemplo, mas podemos usar um serviço REST para qualquer LLM.

image

Adicione política para que o Oracle Digital Assistant possa acessar o ponto final de previsão de implantação de modelo. Vá para Identidade e Segurança, Políticas e clique em Criar 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>'

Depois que a política for criada, poderemos iniciar o Oracle Digital Assistant e abri-la em um navegador.

Tarefa 6.2: Criar o Serviço REST do Provedor de LLM

  1. Vá para o Oracle Digital Assistant, navegue até Definições, Serviços de API, Serviços LLM e clique em +Add Serviço LLM.

  2. Na página Criar Serviço LLM, digite as informações a seguir para criar uma Pós-operação no ponto final do provedor e clique em Criar.

    • Nome: Informe um nome facilmente identificável para o serviço. Você fará referência a esse nome mais tarde.
    • Ponto Final: Copie e cole o ponto final de implantação do modelo.
    • Métodos: Selecione POST.

    image

  3. Conclua o serviço adicionando a chave de API e as amostras de payload de solicitação e resposta.

    • Tipo de Autenticação: Selecione Controlador de Recursos do OCI.

    • Tipo de Conteúdo: Selecione application/json.

    • Corpo: Adicione o payload enviado à solicitação. Por exemplo:

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

    image

  4. Clique em Testar Solicitação para verificar uma resposta 200.

    image

Tarefa 6.3: Criar uma Habilidade

Com o serviço REST do provedor de LLM adicionado à instância, agora precisamos criar uma habilidade que possa chamar esse serviço e conectar usuários a ele por meio de sua definição de fluxo de caixas de diálogo. Para criar essa habilidade, siga as etapas:

  1. Vá para o Oracle Digital Assistant, acesse Desenvolvimento e +Skills.

  2. Clique em + Nova Habilidade.

  3. Na página Criar Habilidade, digite as seguintes informações e clique em Criar.

    • Nome para Exibição: Adicione um nome.
    • Modo de Caixa de Diálogo: Selecione Visual.
    • Para os outros campos, deixe os valores padrão.

    image

Tarefa 6.4: Conectar a Habilidade ao Modelo

Agora, vamos permitir que a habilidade acesse o serviço REST do LLM criando um componente personalizado com um handler de eventos que transforma os payloads REST em formatos aceitos pelo provedor LLM e pelo Oracle Digital Assistant.

  1. Clique no ícone Componentes na barra de navegação esquerda e em Adicionar Serviço.

    O ícone Componentes na barra de navegação esquerda

  2. Na página Criar Serviço, digite as seguintes informações e clique em Criar.

    • Nome: Informe um nome que descreva o serviço.
    • Tipo de Serviço: Aceite a configuração padrão, selecione Contêiner Incorporado.
    • Tipo de Criação do Pacote de Serviço do Componente: Selecione Novo Componente.
    • Tipo de Componente: Selecione Transformação de LLM.
    • Nome do Componente: informe um nome descritivo.
    • Modelo: Selecione Personalizado (localizado em other).

    image

  3. O componente concluído é exibido na página Componentes.

    image

  4. Selecione o componente na página Componentes para verificar seu status de implantação. Quando Pronto for exibido, você poderá passar para a próxima etapa.

    image

    Certifique-se de que o Serviço Ativado (a configuração padrão) esteja ativado.

    image

Tarefa 6.5: Mapear o Provedor de Serviços LLM e as Solicitações e Respostas do Oracle Digital Assistant

As solicitações da habilidade para o provedor de serviços do modelo precisam ser transformadas da interface usada pelo Oracle Digital Assistant, que é conhecida como Interface LLM Comum (CLMI) no formato aceito pelo provedor de serviços. Da mesma forma, os resultados retornados pelo provedor de serviços também precisam ser transformados em CLMI. Para ativar esse mapeamento, os métodos do processador de eventos de serviço REST a seguir devem ter um código específico do provedor.

Para abrir o editor de código do processador de eventos e atualizar o código de transformação (neste caso, para o Azure OpenAI), siga as etapas:

  1. Expanda o serviço e selecione o processador de eventos.

    image

  2. Clique no ícone Editar para abrir o editor.

    image

    image

  3. Substitua o código do método de evento do handler transformRequestPayload (em torno das linhas 24 a 26) pelo código a seguir.

    • transformRequestPayload:

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

      Cada solicitação só precisa passar a última entrada do usuário para o prompt do LLM.

  4. Substitua o código do método de evento do handler transformResponsePayload (em torno das linhas 35 a 37) pelo código a seguir.

    • transformRequestPayload:

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

  5. Substitua o código do método de evento do handler transformErrorResponsePayload (em torno das linhas 47 a 49) pelo código a seguir.

    • 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. Clique em Validar para verificar a sintaxe do código. Use-o para substituir o código no editor se estiver encontrando erros de sintaxe que não possa corrigir.

    image

  7. Clique em Salvar e Fechar. Aguarde a conclusão da implantação. Quando Pronto for exibido, você poderá passar para a próxima etapa.

Tarefa 6.6: Definir o Serviço LLM para a Habilidade

Para permitir que a habilidade conecte usuários ao modelo por meio do fluxo de caixas de diálogo, você precisa criar um serviço LLM que combine o serviço LLM em toda a instância que chame o modelo com o handler de eventos de transformação (que, neste caso, é para implantação de modelo da Oracle).

  1. Clique no ícone Definições na barra de navegação esquerda.

    Barra de navegação esquerda

  2. Clique em Configuração.

    A guia Configuração em Definições

  3. Na página Serviços de Modelos de Idioma Grande, clique em +New Serviço LLM.

    A Seção Modelo de Linguagem Grande da página Configuração.

  4. Insira as seguintes informações

    • Nome: Informe um nome facilmente identificável para o serviço LLM. Você fará referência a esse nome quando criar o fluxo de caixas de diálogo na próxima etapa.

    • Serviço LLM: Selecione o nome do serviço LLM de toda a instância que você criou na Tarefa 1: Criar o Serviço REST para o Modelo.

    • Manipulador de Transformação: Selecione o nome do componente do processador de eventos que você criou como parte do serviço REST na Tarefa 3: Conectar a Habilidade ao Modelo.

    • Deixe as propriedades restantes em suas definições padrão. Observe que Padrão está ativado, se este for o único serviço que você criou até agora para este tutorial.

      image

  5. Clique em Salvar.

    O ícone Salvar serviço

  6. Desmarque Feedback e outro padrão nos switches.

    image

Tarefa 6.7: Integrar o Serviço

Agora que a habilidade está conectada ao LLM, conecte os usuários da habilidade ao modelo criando um componente de fluxo de caixas de diálogo que pode chamar o modelo e dizer o que fazer. O componente transmite essas instruções usando um prompt, que é um bloco de texto legível por humanos. Nesta tarefa, forneceremos esse prompt, que instrui o modelo a avaliar o feedback do usuário como positivo ou negativo ou neutro.

  1. Clique no ícone Fluxos na barra de navegação esquerda.

    O ícone Fluxos na barra de navegação esquerda

  2. Selecione unresolvedIntent.

    Fluxo não resolvido

  3. No estado unresolvedMessage, clique no ícone reticências(...) e selecione Adicionar Estado no menu.

    A opção Adicionar Estado

  4. Selecione Integração de Serviço e Chamar Modelo de Linguagem Grande.

  5. Informe uma Descrição como análise de sentimento e clique em Inserir.

    image

    O fluxo de caixas de diálogo agora inclui o estado unresolvedMessage (Enviar Mensagem), o estado invokeLLM e o estado showLLMError.

    O estado invokeLLM com o estado showError no fluxo de caixas de diálogo

  6. No estado unresolvedMessage, clique no ícone reticências(...) e selecione Excluir no menu, pois não queremos mostrar a mensagem de erro para UnresolvedIntent.

    image

    O fluxo de caixas de diálogo agora inclui apenas o estado invokeLLM e o estado showLLMError.

    image

  7. Abra o estado invokeLLM. Na página Componente, selecione o serviço LLM que criamos na Tarefa 6.6.

    O campo Serviço LLM

  8. Adicione um prompt que envie instruções ao serviço LLM colando o seguinte no Prompt. Toda conversa do usuário deve ser transmitida como Entrada de prompt.

    image

  9. Crie a variável PROMPT_INPUT. Clique em Parâmetros de Prompt + para adicionar um novo parâmetro e seu valor.

    image

  10. Defina Usar Streaming como Falso para que a mensagem seja entregue integralmente, não de forma incremental.

    image

  11. Teste o prompt com o Construtor de Prompt e clique em Criar Prompt

    image

  12. Adicione Valor de Simulação do Parâmetro de Prompt e clique em Gerar Saída. Dessa forma, podemos validar a integração do LLM.

    image

Tarefa 6.8: Testar o Prompt com o Testador de Habilidades

  1. Clique em Visualizar para abrir o testador de habilidades.

    O botão Visualizar

  2. Informe a seguinte solicitação: Você pode fornecer uma visão geral do Oracle Database 23.4?.

    A saída deve ter a seguinte aparência:

    image

  3. Fazer a próxima consulta ao LLM: o mais recente oracle database.

    A saída deve ter a seguinte aparência:

    image

Tarefa 6.9: Configurar o Canal do Usuário do Oracle Web

Criaremos um canal de usuário do Oracle Digital Assistant que permita que um cliente Web da Oracle acesse a habilidade. Para garantir que apenas nossos clientes da Web possam usar esse canal, vamos configurá-lo para exigir autenticação do cliente.

  1. Abra o Oracle Digital Assistant, acesse Desenvolvimento, Canais e clique em +Add Canal.

  2. Em Criar Canal, digite as informações a seguir para criar uma operação POST no ponto final do provedor e clique em Criar.

    • Nome: Um nome exclusivo que começa com uma letra e contém apenas letras, números, pontos e sublinhados. Por exemplo, OCI_MD_LLM.
    • Descrição (Opcional): Para que o canal é usado.
    • Tipo de Canal: Selecione Oracle Web.
    • D domínios permitidos: Digite *.
    • Autenticação do Cliente Ativada: Desmarque.

    image

  3. Desmarque Autenticação do Cliente Ativada, se ainda não estiver desativado.

  4. Em Rota, selecione a habilidade que queremos usar. Selecionamos a habilidade atual que é LLM-MD-Skill.

  5. Ative Canal Ativado.

  6. Observe o ID do Canal e o URI do Domínio do ODA sem https, que são mostrados para esse canal.

Usaremos esses valores em nosso aplicativo web e na configuração de roteamento do gerador de token.

Tarefa 6.10: Instalar o SDK

Faça download do zip e extraia-o no sistema local. Este zip inclui um guia do usuário que descreve as classes do SDK e um aplicativo de amostra que demonstra muitas de suas funcionalidades.

  1. Vá para a seção Web SDKs do Oracle Digital Assistant (ODA) e do Oracle Mobile Cloud (OMC) e Oracle Native Client SDKs (para ambientes Nativos do OCI).

  2. Faça download do ODA Web SDK 24.06.

  3. Em Plataformas, selecione GERIC.

  4. Clique para fazer download do SDK Js do ODA mais recente que é oda-native-client-sdk-js-24_06 for (GENERIC (All Platforms).

    image

  5. Extraia o arquivo zip baixado.

Tarefa 6.11: Testar o Aplicativo Oracle Web

  1. Vá para a pasta zip extraída do Oracle Web SDK baixado.

  2. Abra o arquivo samples/web/settings.js e substitua <URI> e <channelId> pelo valor real.

    Por exemplo:

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

  3. Além disso, certifique-se de que isClientAuthEnabled seja falso.

    let isClientAuthEnabled = false;

  4. Execute o arquivo samples/web/index.html em qualquer browser.

  5. Ignore o conteúdo do arquivo de índice. Clique no ícone de chat, ele mostrará o status do Oracle Assistant CONNECTED.

    image

  6. É assim que nosso site fica com o ícone de bate-papo no canto inferior direito. Podemos iniciar uma conversa, como fizemos anteriormente com o testador de habilidades.

    image

    image

Tarefa 6.12: Release na Instância do OCI Compute

  1. Crie a instância do OCI Compute. Para obter mais informações, consulte Criando uma Instância

  2. Certifique-se de ter seguido as regras de entrada.

    image

  3. Copie todas as pastas da Web para a instância recém-criada.

  4. Instale o NGINX. Para obter mais informações, consulte Instalar o NGINX Web Server e o Proxy no Oracle Linux.

  5. Abra um navegador e acesse http://<IP_address>/. Se você tiver um certificado autoassinado, poderá navegar até https://<IP_address>/.

Resultados

Vamos comparar as saídas de perguntar diretamente ao LLM versus usar RAG com LLM:

Próximas Etapas

A criação de um chatbot avançado usando o Oracle Database 23ai, RAG, LangChain, Mistral-7B-Instruct-v0.2 e o Oracle Digital Assistant mostra o poder de integrar tecnologias de ponta para criar um agente conversacional altamente responsivo e inteligente. O fluxo de trabalho detalhado, desde o tratamento de solicitações até a geração de respostas, garante que o chatbot possa recuperar e processar com eficiência grandes quantidades de informações, fornecendo respostas precisas e contextualmente relevantes aos usuários. Ao aproveitar os recursos de pesquisa de vetores do Oracle Database 23ai e a plataforma robusta fornecida pelo Oracle Digital Assistant, os desenvolvedores podem melhorar significativamente o desempenho e o envolvimento do usuário do chatbot. Essa abordagem integrada não apenas simplifica o processo de desenvolvimento, mas também resulta em uma solução de IA escalável, eficiente e altamente eficaz que se destaca no cenário competitivo dos assistentes digitais. Seja para atendimento ao cliente, recuperação de informações ou suporte interativo, essa arquitetura avançada de chatbot abre caminho para criar experiências de conversação sofisticadas que atendam às demandas dos usuários modernos.

Para obter mais informações sobre como usar o AI Quick Actions, acesse a playlist YouTube do Oracle Cloud Infrastructure Data Science para ver um vídeo de demonstração do AI Quick Actions e encontrar nossa documentação técnica e consulte nosso repositório Github com dicas e exemplos.

Se você quiser sugerir modelos específicos para adicionar às Ações Rápidas de IA ou tiver dúvidas, envie um e-mail para o grupo do OCI Data Science: ask-oci-data-science_grp@oracle.com.

Confirmações

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.