Chatea con tus archivos CSV con un chatbot de memoria | Hecho con Langchain y OpenAI

En este artículo, veremos cómo crear un chatbot simple con memoria que pueda responder a sus preguntas sobre sus propios datos CSV.

¡Hola a todos! En las últimas semanas, he estado experimentando con el fascinante potencial de los grandes modelos de lenguaje para crear todo tipo de cosas, ¡y es hora de compartir lo que he aprendido!

Usaremos LangChain para vincular gpt-3.5nuestros datos y Streamlit para crear una interfaz de usuario para nuestro chatbot.

A diferencia de ChatGPT, que ofrece un contexto limitado sobre nuestros datos (solo podemos proporcionar un máximo de 4096 tokens), nuestro chatbot podrá procesar datos CSV y administrar una gran base de datos gracias al uso de incrustaciones y una tienda de vectores.

El código

¡Ahora seamos prácticos! Desarrollaremos nuestro chatbot en datos CSV con muy poca sintaxis de Python.

Descargo de responsabilidad : este código es una versión simplificada del chatbot que creé, no está optimizado para reducir los costos de la API de OpenAI, para un chatbot optimizado y de mayor rendimiento, no dude en consultar mi proyecto de GitHub: yvann-hub/Robby-chatbot o simplemente prueba la aplicación en Robby-chatbot.com .

• Primero, instalaremos las bibliotecas necesarias:

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 probar el chatbot a un costo menor, puede usar este archivo CSV liviano: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})"

• Las incrustaciones permiten transformar las partes cortadas por CSVLoader en vectores, que luego representan un índice basado en el contenido de cada fila del archivo dado.
• En la práctica, cuando el usuario realiza una consulta, se realizará una búsqueda en la tienda de vectores y los índices que mejor coincidan se devolverán al LLM, que reformulará el contenido del índice encontrado para proporcionar una respuesta formateada a la usuario.
• Recomiendo profundizar su comprensión de los conceptos de vectorstore e incrustaciones para una mejor comprensión.

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

• Esta cadena nos permite tener un chatbot con memoria mientras nos apoyamos en un vectorstorepara encontrar información relevante de nuestro documento.

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

• st.session_state[‘history’]almacena el historial de conversaciones del usuario cuando está en el sitio de 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 a las respuestas del chatbot.
• [‘past’]corresponde a los mensajes proporcionados por el usuario.
• Los contenedores no son esenciales, pero ayudan a mejorar la interfaz de usuario al colocar el área de preguntas del usuario debajo de los mensajes de chat.

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 la parte de la interfaz de usuario que permite al usuario ingresar y enviar su pregunta a nuestra conversational_chatfunción con la pregunta del usuario 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

       
                

                    
                    
                
            

También puede encontrar el proyecto completo en mi GitHub .