Converse com seus arquivos CSV com um chatbot de memória | Feito com Langchain e OpenAI

Neste artigo, veremos como construir um chatbot simples com memória que pode responder às suas perguntas sobre seus próprios dados CSV.

Oi pessoal! Nas últimas semanas, tenho experimentado o potencial fascinante de grandes modelos de linguagem para criar todo tipo de coisa, e é hora de compartilhar o que aprendi!

Usaremos LangChain para vincular gpt-3.5nossos dados e Streamlit para criar uma interface de usuário para nosso chatbot.

Ao contrário do ChatGPT, que oferece contexto limitado em nossos dados (só podemos fornecer no máximo 4.096 tokens), nosso chatbot será capaz de processar dados CSV e gerenciar um grande banco de dados graças ao uso de embeddings e um vectorstore.

O código

Agora vamos ser práticos! Desenvolveremos nosso chatbot em dados CSV com muito pouca sintaxe Python.

Isenção de responsabilidade : Este código é uma versão simplificada do chatbot que criei, não é otimizado para reduzir os custos da API OpenAI, para um chatbot mais eficiente e otimizado, sinta-se à vontade para conferir meu projeto GitHub: yvann-hub/Robby-chatbot ou apenas teste o aplicativo em Robby-chatbot.com .

• Primeiro, instalaremos as bibliotecas necessárias:

pip install streamlit streamlit_chat langchain openai faiss-cpu tiktoken

import streamlit as st
from streamlit_chat import message
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationalRetrievalChain
from langchain.document_loaders.csv_loader import CSVLoader
from langchain.vectorstores import FAISS
import tempfile

• Para testar o chatbot a um custo menor, você pode usar este arquivo CSV leve:fishfry-locations.csv

user_api_key = st.sidebar.text_input(
    label="#### Your OpenAI API key ",
    placeholder="Paste your openAI API key, sk-",
    type="password")

uploaded_file = st.sidebar.file_uploader("upload", type="csv")

if uploaded_file :
   #use tempfile because CSVLoader only accepts a file_path
    with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
        tmp_file.write(uploaded_file.getvalue())
        tmp_file_path = tmp_file.name

    loader = CSVLoader(file_path=tmp_file_path, encoding="utf-8", csv_args={
                'delimiter': ','})
    data = loader.load()

st.write(data)
0:"Document(page_content='venue_name: McGinnis Sisters\nvenue_type: Market\nvenue_address: 4311 Northern Pike, Monroeville, PA\nwebsite: http://www.mcginnis-sisters.com/\nmenu_url: \nmenu_text: \nphone: 412-858-7000\nemail: \nalcohol: \nlunch: True', metadata={'source': 'C:\\Users\\UTILIS~1\\AppData\\Local\\Temp\\tmp6_24nxby', 'row': 0})"
1:"Document(page_content='venue_name: Holy Cross (Reilly Center)\nvenue_type: Church\nvenue_address: 7100 West Ridge Road, Fairview PA\nwebsite: \nmenu_url: \nmenu_text: Fried pollack, fried shrimp, or combo. Adult $10, Child $5. Includes baked potato, homemade coleslaw, roll, butter, dessert, and beverage. Mac and cheese $5.\nphone: 814-474-2605\nemail: \nalcohol: \nlunch: ', metadata={'source': 'C:\\Users\\UTILIS~1\\AppData\\Local\\Temp\\tmp6_24nxby', 'row': 1})"

• Os embeddings permitem transformar as partes cortadas pelo CSVLoader em vetores, que então representam um índice baseado no conteúdo de cada linha do arquivo fornecido.
• Na prática, quando o usuário fizer uma consulta, será realizada uma busca no vectorstore e o(s) índice(s) que melhor(es) for(em) retornado(s) ao LLM, que reformulará o conteúdo do índice encontrado para fornecer uma resposta formatada ao do utilizador.
• Recomendo aprofundar sua compreensão dos conceitos de vectorstore e embeddings para melhor compreensão.

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(data, embeddings)

• Essa cadeia nos permite ter um chatbot com memória enquanto contamos com um vectorstorepara encontrar informações relevantes do nosso documento.

chain = ConversationalRetrievalChain.from_llm(
llm = ChatOpenAI(temperature=0.0,model_name='gpt-3.5-turbo'),
retriever=vectorstore.as_retriever())

• st.session_state[‘history’]armazena o histórico de conversas do usuário quando ele está no site Streamlit.

def conversational_chat(query):
        
        result = chain({"question": query, 
        "chat_history": st.session_state['history']})
        st.session_state['history'].append((query, result["answer"]))
        
        return result["answer"]

• [‘generated’]corresponde às respostas do chatbot.
• [‘past’]corresponde às mensagens fornecidas pelo usuário.
• Os contêineres não são essenciais, mas ajudam a melhorar a interface do usuário, colocando a área de perguntas do usuário abaixo das mensagens de bate-papo.

if 'history' not in st.session_state:
        st.session_state['history'] = []

    if 'generated' not in st.session_state:
        st.session_state['generated'] = ["Hello ! Ask me anything about " + uploaded_file.name + " "]

    if 'past' not in st.session_state:
        st.session_state['past'] = ["Hey ! "]
        
    #container for the chat history
    response_container = st.container()
    #container for the user's text input
    container = st.container()

• Podemos configurar a parte da interface do usuário que permite ao usuário inserir e enviar sua pergunta para nossa conversational_chatfunção com a pergunta do usuário como argumento.

with container:
        with st.form(key='my_form', clear_on_submit=True):
            
            user_input = st.text_input("Query:", placeholder="Talk about your csv data here (:", key='input')
            submit_button = st.form_submit_button(label='Send')
            
        if submit_button and user_input:
            output = conversational_chat(user_input)
            
            st.session_state['past'].append(user_input)
            st.session_state['generated'].append(output)

if st.session_state['generated']:
        with response_container:
            for i in range(len(st.session_state['generated'])):
                message(st.session_state["past"][i], is_user=True, key=str(i) + '_user', avatar_style="big-smile")
                message(st.session_state["generated"][i], key=str(i), avatar_style="thumbs")

streamlit run name_of_your_chatbot.py #run with the name of your file

       
                

                    
                    
                
            

Você também pode encontrar o projeto completo no meu GitHub .