Como analisar documentos com LangChain e a API OpenAI

Extrair insights de documentos e dados é crucial para a tomada de decisões informadas. No entanto, surgem preocupações com a privacidade ao lidar com informações confidenciais. LangChain, em combinação com a API OpenAI, permite analisar seus documentos locais sem a necessidade de carregá-los online.

Eles conseguem isso mantendo seus dados localmente, usando incorporações e vetorização para análise e executando processos em seu ambiente. A OpenAI não usa dados enviados por clientes por meio de sua API para treinar seus modelos ou melhorar seus serviços.

Configurando seu ambiente

Crie um novo ambiente virtual Python. Isso garantirá que não haja conflitos de versão da biblioteca. Em seguida, execute o seguinte comando de terminal para instalar as bibliotecas necessárias.

pip install langchain openai tiktoken faiss-cpu pypdf

Aqui está um detalhamento de como você usará cada biblioteca:

• LangChain: você o usará para criar e gerenciar cadeias linguísticas para processamento e análise de texto. Ele fornecerá módulos para carregamento de documentos, divisão de texto, incorporações e armazenamento de vetores.
• OpenAI: você o usará para executar consultas e obter resultados de um modelo de linguagem.
• tiktok: você o usará para contar o número de tokens (unidades de texto) em um determinado texto. Isso serve para acompanhar a contagem de tokens ao interagir com a API OpenAI, que cobra com base no número de tokens que você usa.
• FAISS: você o usará para criar e gerenciar um armazenamento de vetores, permitindo a recuperação rápida de vetores semelhantes com base em suas incorporações.
• PyPDF: esta biblioteca extrai texto de PDFs. Ajuda a carregar arquivos PDF e extrai seu texto para processamento posterior.

Depois que todas as bibliotecas estiverem instaladas, seu ambiente estará pronto.

Obtendo uma chave de API OpenAI

Ao fazer solicitações à API OpenAI, você precisa incluir uma chave de API como parte da solicitação. Essa chave permite que o provedor da API verifique se as solicitações vêm de uma fonte legítima e se você tem as permissões necessárias para acessar seus recursos.

Para obter uma chave de API OpenAI, prossiga para o Plataforma OpenAI.

Em seguida, no perfil da sua conta no canto superior direito, clique em Ver chaves de API. O Chaves de API a página aparecerá.

Clique no Criar novo segredochave botão. Nomeie sua chave e clique em Crie uma nova chave secreta. OpenAI irá gerar sua chave API que você deve copiar e manter em algum lugar seguro. Por motivos de segurança, você não poderá visualizá-lo novamente por meio de sua conta OpenAI. Se você perder esta chave secreta, precisará gerar uma nova.

O código-fonte completo está disponível em um Repositório GitHub.

Importando as bibliotecas necessárias

Para poder utilizar as bibliotecas instaladas em seu ambiente virtual, é necessário importá-las.

from langchain.document_loaders import PyPDFLoader, TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

Observe que você importa as bibliotecas de dependência do LangChain. Isso permite que você use recursos específicos da estrutura LangChain.

Carregando o Documento para Análise

Comece criando uma variável que contém sua chave de API. Você usará essa variável posteriormente no código para autenticação.

# Hardcoded API key
openai_api_key = "Your API key"

Não é recomendado codificar sua chave de API se você planeja compartilhar seu código com terceiros. Para código de produção que você pretende distribuir, use uma variável de ambiente em vez disso.

A seguir, crie uma função que carregue um documento. A função deve carregar um PDF ou arquivo de texto. Se o documento não for nenhum dos dois, a função deverá gerar um Erro de valor.

defload_document(filename):
if filename.endswith(".pdf"):
 loader = PyPDFLoader(filename)
 documents = loader.load()
elif filename.endswith(".txt"):
 loader = TextLoader(filename)
 documents = loader.load()
else:
raise ValueError("Invalid file type")

Após carregar os documentos, crie um CharacterTextSplitter. Este divisor dividirá os documentos carregados em pedaços menores com base nos caracteres.

 text_splitter = CharacterTextSplitter(chunk_size=1000, 
 chunk_overlap=30, separator="\n")
return text_splitter.split_documents(documents=documents)

A divisão do documento garante que os pedaços tenham um tamanho gerenciável e ainda estejam conectados a algum contexto sobreposto. Isso é útil para tarefas como análise de texto e recuperação de informações.

Consultando o documento

Você precisa consultar o documento carregado para obter insights dele. Para fazer isso, crie uma função que receba um consulta corda e um recuperador como entrada. Cria então um RecuperaçãoQA instância usando o recuperador e uma instância do modelo de linguagem OpenAI.

defquery_pdf(query, retriever):
 qa = RetrievalQA.from_chain_type(llm=OpenAI(openai_api_key=openai_api_key),
 chain_type="stuff", retriever=retriever)
 result = qa.run(query)
 print(result)

Esta função usa a instância de controle de qualidade criada para executar a consulta e imprimir o resultado.

Criando a Função Principal

A função principal controlará o fluxo geral do programa. Será necessária a entrada do usuário para um nome de arquivo de documento e carregará esse documento. Então crie um OpenAIEbeddings instância para incorporações e construir um loja de vetores com base nos documentos carregados e incorporações. Salve este armazenamento de vetores em um arquivo local.

Em seguida, carregue o armazenamento de vetores persistente do arquivo local. Em seguida, insira um loop onde o usuário pode inserir consultas. O principal função passa essas consultas para o consulta_pdf função junto com o recuperador do armazenamento de vetores persistente. O loop continuará até que o usuário digite “exit”.

defmain():
 filename = input("Enter the name of the document (.pdf or .txt):\n")
 docs = load_document(filename)
 embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)
 vectorstore = FAISS.from_documents(docs, embeddings)
 vectorstore.save_local("faiss_index_constitution")
 persisted_vectorstore = FAISS.load_local("faiss_index_constitution", embeddings)
 query = input("Type in your query (type 'exit' to quit):\n")
while query != "exit":
 query_pdf(query, persisted_vectorstore.as_retriever())
 query = input("Type in your query (type 'exit' to quit):\n")

Os embeddings capturam relações semânticas entre palavras. Vetores são uma forma na qual você pode representar pedaços de texto.

Este código converte os dados de texto do documento em vetores usando os embeddings gerados por OpenAIEbeddings. Em seguida, ele indexa esses vetores usando FAISS, para recuperação e comparação eficiente de vetores semelhantes. É isso que permite a análise do documento carregado.

Finalmente, use a construção __name__ == "__main__" para chamar a função principal se um usuário executar o programa de forma independente:

if __name__ == "__main__":
 main()

Este aplicativo é um aplicativo de linha de comando. Como extensão, você pode use Streamlit para adicionar uma interface web ao aplicativo.

Executando análise de documentos

Para realizar a análise do documento, armazene o documento que deseja analisar na mesma pasta do seu projeto e execute o programa. Ele solicitará o nome do documento que você deseja analisar. Insira seu nome completo e, em seguida, insira as consultas para o programa analisar.

A captura de tela abaixo mostra os resultados da análise de um PDF.

A saída a seguir mostra os resultados da análise de um arquivo de texto contendo código-fonte.

Certifique-se de que os arquivos que você deseja analisar estejam em formato PDF ou texto. Se seus documentos estiverem em outros formatos, você pode converta-os para o formato PDF usando ferramentas online.

Compreendendo a tecnologia por trás dos grandes modelos de linguagem

LangChain simplifica a criação de aplicativos usando grandes modelos de linguagem. Isso também significa que abstrai o que está acontecendo nos bastidores. Para entender exatamente como funciona o aplicativo que você está criando, você deve se familiarizar com a tecnologia por trás dos grandes modelos de linguagem.