Crie um chatbot que consulta documentos usando Langchain e Azure OpenAI (2023)

Neste artigo, apresentaremos o LangChain e exploraremos seus recursos criando um aplicativo simples de resposta a perguntas que consulta PDFs que fazem parte dos documentos do Azure Functions.

Cadeia Lang

de Harrison ChaseCadeia Langé uma poderosa biblioteca Python que simplifica o processo de construção de aplicativos NLP usando grandes modelos de linguagem. Seu principal objetivo é criar agentes inteligentes que possam entender e executar comandos de linguagem humana. O LangChain permite que você crie aplicativos que se conectam a uma variedade de fontes de dados e computação, execute tarefas NLP em fontes de dados específicas do domínio, repositórios privados e muito mais.

Em maio de 2023, o repositório LangChain GitHub tinha mais de 42.000 estrelas, com contribuições de mais de 270 desenvolvedores em todo o mundo.

A biblioteca langchain consiste em vários módulos.

• LLM e Prompt

Isso inclui gerenciamento de prompts, otimização de prompts, uma interface genérica para todos os LLMs e utilitários comuns para trabalhar com LLMs, como o Azure OpenAI. Ele suporta vários LLMs, como OpenAI, LLama e GPT4All.

• corrente

Uma cadeia LangChain contém uma série de chamadas que podem ser encadeadas para executar uma tarefa específica. Por exemplo, você pode precisar recuperar dados de uma URL específica, resumir o texto retornado e usar o resumo gerado para responder à sua pergunta. As cadeias podem ser tão simples quanto ler a entrada do usuário, construir prompts e gerar respostas.

• geração de aumento de dados

Uma geração de aumento de dados envolve um tipo específico de cadeia que primeiro interage com uma fonte de dados externa para buscar dados para uso na etapa de geração. Os exemplos incluem resumos de texto longo ou perguntas/respostas para uma fonte de dados específica. Cadeia Langcarregador de documentoseUtilitárioOs módulos facilitam a conexão com fontes de dados e cálculos. Se você tiver uma mistura de arquivos de texto, documentos PDF, páginas da Web em HTML, etc., poderá usar o carregador de documentos do Langchain.

• Agente

Um agente envolve um LLM que decide qual ação tomar, executa essa ação, confirma as observações e repete até a conclusão.

Conforme explicado anteriormente, as cadeias são úteis para encadear uma série de chamadas LLM. No entanto, para algumas tarefas, a sequência de chamadas geralmente não é determinística, com a próxima etapa dependendo da entrada do usuário e das respostas das etapas anteriores.

「Agente' pode executar ações com base na entrada intermediária, em vez de uma sequência determinística codificada permanentemente.

• memória

A memória refere-se ao uso de um VectorStore para manter o estado. Os bancos de dados vetoriais são otimizados para pesquisas rápidas em espaços de alta dimensão. LangChain torna isso fácil.

integrado

A incorporação é o mapeamento de uma variável categórica discreta para um vetor de valores contínuos.No contexto das redes neurais, incorporarUma representação vetorial contínua aprendida de baixa dimensão de uma variável discreta. A incorporação de redes neurais é útil porque reduz a dimensionalidade das variáveis ​​categóricas e permite que as categorias sejam representadas de forma significativa no espaço transformado.

Incorporar uma rede neural tem três propósitos principais.

• Encontre os vizinhos mais próximos no espaço de incorporação. Eles podem ser usados ​​para fazer recomendações com base nos interesses do usuário e nas categorias do cluster.
• Como uma entrada para um modelo de aprendizado de máquina para tarefas supervisionadas.
• Visualize as relações entre conceitos e categorias.

Exemplo de agrupamento com valor de vetor de sentença

Armazenamento de vetores ou banco de dados de vetores

Um banco de dados vetorial é um tipo especial de banco de dados que armazena dados como vetores de alta dimensão. Esses vetores são representações matemáticas de recursos ou atributos dos dados armazenados. A dimensionalidade de cada vetor varia amplamente, de dezenas a milhares, dependendo da complexidade e granularidade dos dados. Este artigo descreve conceitos de banco de dados vetoriais e suas aplicações em vários campos.

Crie seu aplicativo

Crie ferramentas que podem ler a documentação do desenvolvedor– Neste caso, a documentação do Azure Functions em formato PDF.

TConsulte o texto do documento e responda a quaisquer perguntas.

Siga esses passos:

Procedimento único:

• Indexe um documento PDF (um documento de função do Azure), divida o documento em partes e indexe todo o texto para criar incorporações.
• Armazene todos os embeddings em um armazenamento de vetores (Faiss neste caso) para que possam ser pesquisados ​​dentro do aplicativo.

aplicativo:

• Quando um usuário faz uma pergunta, ele usa o índice vetorial FAISS para encontrar o melhor texto correspondente.
• Alimente-o para GPT-3.5 como o contexto do prompt.
• O GPT-3.5 produz respostas que respondem exatamente à pergunta.

etapa

• Baixe o documento que deseja pesquisar. No nosso caso, a documentação do Azure Function pode ser baixada em:aquie salve-o na pasta dados/documentação.
• Implantar com Azure OpenAI
  • Ada
  • GPT35

Obtenha o endpoint e a chave do Azure OpenAI e adicione-os a um arquivo chamado .env da seguinte maneira:

OPENAI_DEPLOYMENT_ENDPOINT = "https://.openai.azure.com/"OPENAI_API_KEY = ""OPENAI_DEPLOYMENT_NAME = ""OPENAI_DEPLOYMENT_VERSION = "2023-03-15-preview" OPENAI_MODEL_NAME="gpt-35-turbo"OPENAI_EMBEDDING_DEPLOYMENT_NAME = ""OPENAI_EMBEDDING_MODEL_NAME = "text-embedding-ada-002"

Criar uma incorporação

Fluxo deIndexer.pydentes:

• carregar o pdf
• Divida todo o texto em pedaços.
• O envio desses blocos para a API OpenAI Embeddings retorna um vetor de 1536 dimensões para cada bloco.
• Indexe todos os vetores no índice FAISS.
• Armazene o índice FAISS em a.facee.pklArquivo.

Nota: Como você provavelmente sabe, o LLM não pode aceitar instruções longas devido ao seu limite de token, então ele divide o documento em vários pedaços (veja abaixo).

A execução desse código é demorada porque ele precisa ler o documento inteiro, dividi-lo e enviar os pedaços para o modelo Ada para obter os embeddings.

Aqui está o códigoIndexer.py

from langchain.document_loaders import PyPDFLoaderfrom langchain.embeddings.openai import OpenAIEmbeddingsfrom langchain.vectorstores import FAISSfrom dotenv import load_dotenvimport openaiimport os#load 小时发性load_dotenv()OPENAI_API_KEY = os.getenv("OPENAI_DEPLOYMENT_ENDPOINT") OPENAI_DE PLOYMENT_NAME = os.getenv("OPENAI_DEPLOYMENT_NAME" )OPENAI_MODEL_NAME = os.getenv("OPENAI_MODEL_NAME")OPENAI_EMBEDDING_DEPLOYMENT_NAME = os.getenv("OPENAI_EMBEDDING_DEPLOYMENT_NAME")OPENAI_DEPLOYMENT_VERSION = os.getenv("OPENAI_DEPLOYMENT_NAME") os.getenv("OPENAI_DEPLOYMENT_VERSION") # em it Azure OpenAIopenai.api_type = "azure"openai .api_version = OPENAI_DEPLOYMENT_VERSIONopenai.api_base = OPENAI_DEPLOYMENT_ENDPOINTopenai.api_key = OPENAI_API_KEYif __name__ == "__main__": embeddings = OpenAIEmbeddings(model=OPENAI_EMBEDDING_MODEL_NAME, chunk_size=1) datapath = "/data/documentation/" fileName = dataPath + "funções-azure-azure .pdf" #use langchain PDF ローダーloader = PyPDFLoader(fileName) # フキロサをチャンク ページに制件した =loader.load_and_split() #Use Langchainて text-embedding- will create没込内 ada-002 db = FAISS.from_documents (documents=pages, embedding=embeddings) # 没込たを FAISS vector store します db.save_local("./dbs/documentation/faiss_index")

Criação de aplicativo

Fluxo deapp.pyFunciona assim:

• O índice FAISS é carregado na RAM
• usuário pergunta
• As perguntas do usuário são enviadas para a API OpenAI Embeddings, que retorna um vetor de 1536 dimensões.
• O índice FAISS é consultado para o vetor correspondente mais próximo.
• O melhor vetor correspondente é retornado junto com o texto do qual se originou.
• O texto retornado é enviado para GPT-35 como contexto para o prompt GPT-35.
• GPT-35 gera uma resposta e a retorna ao usuário.

Nota: O importante a observar aqui é que o Langchain faz a maior parte do trabalho pesado e isso acontece nos bastidores.

Aqui está o códigoapp.py

langchain.vectorstores から FAISS を import dotenv から import load_dotenvimport openaiimport osfrom langchain.chains から import RetrievalQA langchain.vectorstores から FAISS を import langchain.chains.question_answering から import load_qa_chainfrom dotenvから import load_dotenvfrom langchain.chat_models import AzureChatOpenAIfrom langchain.embeddings.openai import OpenAIEmbeddings #環境 変数 を を ロード ロード ロード ロード............................ ................... Getenv ("Openai_Deployment_name") Openai_Model_Name = OS.GETENV ("Openai_Model_name") Openai_Mbedding_Deployment_name = OS .getenv("OPENAI_EMBEDDING_DEPLOYMENT_NAME") OPENAI_EMBEDDING_MODEL_NAME = os.getenv ("OPENAI_EMBEDDING_MODEL_NAME")OPENAI_DEPLOYMENT_VERSION = os.getenv("OPENAI_DEPLOYMENT_VERSION")#init Azure OpenAIopenai.api_type = "azure" openai.api_base = OPENAI_DEPLOYMENT_VERSION _ENDPOINTopenai.api_key = OPENAI_API_KEYdef ask_question(qa, question): resultado= qa({ "Consulta" : 电影}) print("电影:", 电影) print("电影:", result["电影"])if __name__ == "__main__": #init openai llm = AzureChatOpenAI(deployment_name) =OPENAI_DEPLOYMENT_NAME, model_name=OPENAI_MODEL_NAME , openai_api_base=OPENAI_DEPLOYMENT_ENDPOINT, openai_api_version=OPENAI_DEPLOYMENT_VERSION, openai_api_key=OPENAI_API_KEY)embeddings = OpenAIEmbeddings(model=OPENAI_EMBEDDING_MODEL_NAME, chunk_size=1) #fais s を Carregar o vetor na memória e armazená-lo VectorStore = FAISS.load_local( "./dbs/documentação/ faiss_index",embeddings) # Use o armazenamento de vetor salvo para pesquisar o documento local faiss = VectorStore.as_retriever(search_type="similarity", search_kwargs={" k":2}) # Use o armazenamento de vetor como segue: qa = RetrievalQA. from_chain_type(llm=llm,chain_type="stuff",retriever=retriever,return_source_documents=False) while True: query = input( 'you: ') if query == 'q': Break ask_question(qa) 、Query）

eu posso correr agoraaplicativoComece a pergunta com y.

Você: O que são Azure Functions? Pergunta: O que são Azure Functions? Um serviço de nuvem disponível sob demanda. Concentre-se no código que mais importa para você no idioma em que é mais produtivo e o Functions cuidará do resto. O Functions traz a computação sem servidor para o Azure. As funções podem ser usadas para criar APIs da Web, responder a alterações no banco de dados, processar fluxos de IoT, gerenciar filas de mensagens e muito mais.

Você: Posso usar os Hubs de Eventos como gatilhos para o Azure Functions? Pergunta: Posso usar os Hubs de Eventos como gatilhos para o Azure Functions? Resposta: Sim, você pode usar os Hubs de Eventos como gatilhos para o Azure Functions. Oferece suporte a gatilhos de hubs de eventos e associações de saída. Use gatilhos de função para responder a eventos enviados ao fluxo de eventos do hub de eventos. A configuração de um gatilho requer acesso de leitura ao hub de eventos subjacente. Quando a função é acionada, a mensagem passada para a função é inserida como uma string. `<|im_end|>

Você: Quais idiomas podem ser usados ​​para criar Azure Functions Pergunta: Quais idiomas podem ser usados ​​para criar Azure Functions?

Você: Posso implantar o Azure Functions em várias regiões? Pergunta: Posso implantar o Azure Functions em várias regiões? Resposta: Sim, posso implantar o Azure Functions em várias regiões. Há dois padrões a serem considerados. Ativo/Ativo usado para funções de gatilho HTTP e Ativo/Passivo usado para funções de gatilho não HTTP orientadas a eventos. Se você usar o padrão ativo-ativo de funções acionadas por HTTP, deverá usar o Azure Front Door para coordenar as solicitações entre as duas regiões. Ao usar um padrão ativo-passivo, uma segunda região é ativada e assume quando o failover é necessário. Para obter mais informações sobre implantações multirregionais, consulte a orientação em Aplicativos Web multiregionais altamente disponíveis. <|im_end|>

Obrigado por ler. Espero que você goste.

Denis