app.py

# You can find this code for Chainlit python streaming here (https://docs.chainlit.io/concepts/streaming/python)

# OpenAI Chat completion
import os
from openai import AsyncOpenAI  # importing openai for API usage
import chainlit as cl  # importing chainlit for our app
from chainlit.prompt import Prompt, PromptMessage  # importing prompt tools
from chainlit.playground.providers import ChatOpenAI  # importing ChatOpenAI tools
from dotenv import load_dotenv
from langchain.document_loaders import CSVLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain.embeddings import CacheBackedEmbeddings
from langchain.storage import LocalFileStore
from langchain_community.vectorstores import FAISS
from datasets import load_dataset
from langchain_core.runnables.base import RunnableSequence
from langchain_core.runnables.passthrough import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
import asyncio



load_dotenv()

# ChatOpenAI Templates
system_template = """You are a helpful assistant who always speaks in a pleasant tone!
"""

user_template = """{input}




Think through your response step by step.
"""

# used for imdb chat 
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""

def setup():
    dataset = load_dataset("ShubhamChoksi/IMDB_Movies")
    print(dataset['train'][0])
    print("data from huggingface dataset\n")
    
    dataset_dict = dataset
    dataset_dict["train"] # TODO - what method do we have to use to store imdb.csv from ShubhamChoksi/IMDB_Movies?

    dataset_dict["train"].to_csv("imdb.csv")
    loader = CSVLoader(file_path='imdb.csv')
    data = loader.load()
    len(data)
    print(data[0])
    print("loaded data from csv\n")
    
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size = 1000,
        chunk_overlap = 100,
    )

    chunked_documents = text_splitter.split_documents(data)


    len(chunked_documents) # ensure we have actually split the data into chunks
    print(chunked_documents[0])
    
    openai_api_key =  os.getenv("OPENAI_API_KEY")

    embedding_model = OpenAIEmbeddings(openai_api_key=openai_api_key)
    
    
    store = LocalFileStore("./cache/")
    embedder = CacheBackedEmbeddings.from_bytes_store(
        embedding_model, store, namespace=embedding_model.model
    )
    
    vector_store = FAISS.from_documents(chunked_documents, embedder)

    vector_store.save_local("./vector_store")
    
def input_query(query):
    openai_api_key =  os.getenv("OPENAI_API_KEY")
    embedding_model = OpenAIEmbeddings(openai_api_key=openai_api_key)

    store = LocalFileStore("./cache/")
    embedder = CacheBackedEmbeddings.from_bytes_store(
        embedding_model, store, namespace=embedding_model.model
    )
    vector_store = FAISS.load_local("./vector_store", embedder, allow_dangerous_deserialization=True)

    retriever = vector_store.as_retriever()
    
    # query = "What are some good westerns movies?"
    # embedded_query = embedding_model.embed_query(query)
    # similar_documents = vector_store.similarity_search_by_vector(embedded_query)
    # for page in similar_documents:
    #     # TODO: Print the similar documents that the similarity search returns?
    #     print(page)
    #     print("00-----0000")
    #     print(page)
    #     print("-------------")
    embedded_query = embedding_model.embed_query(query)
    similar_documents = vector_store.similarity_search_by_vector(embedded_query)
    similar_documents_for_prompt = list(map(lambda page: ("assistant", page.page_content), similar_documents))
    # print(similar_documents_for_prompt)

    similar_documents_for_prompt.append(("human", query))
    # print(similar_documents_for_prompt)

    # Create the components (chefs)
    # prompt_template = # TODO: How do we create a prompt template to send to our LLM that will incorporate the documents from our retriever with the question we ask the chat model?
    alternative_prompt = ChatPromptTemplate.from_messages(
        similar_documents_for_prompt
    )
    print("alternative prompt")
    print(alternative_prompt.messages)


    prompt = ChatPromptTemplate.from_template(template)


    #retriever = # TODO: How to we create a retriever for our documents?
    retriever = vector_store.as_retriever()


    #chat_model = # TODO: How do we create a chat model / LLM?
    chat_model = ChatOpenAI(openai_api_key=openai_api_key, temperature=0)



    #parser = # TODO: How do we create a parser to parse the output of our LLM?
    parser = StrOutputParser()
    runnable_chain = alternative_prompt | chat_model | parser
    return alternative_prompt, chat_model, parser


@cl.on_chat_start  # marks a function that will be executed at the start of a user session
async def start_chat():
    settings = {
        "model": "gpt-3.5-turbo",
        "temperature": 0,
        "max_tokens": 500,
        "top_p": 1,
        "frequency_penalty": 0,
        "presence_penalty": 0,
    }
    setup()
    cl.user_session.set("settings", settings)

# need to pass the query to the input_query function
@cl.on_message  # marks a function that should be run each time the chatbot receives a message from a user
async def main(message: cl.Message):
    settings = cl.user_session.get("settings")

    client = AsyncOpenAI()

    print(message.content)
    # message.content is the input query from the user
    prompt, model, parser = input_query(message.content)

    # prompt = Prompt(
    #     provider=ChatOpenAI.id,
    #     messages=[
    #         PromptMessage(
    #             role="system",
    #             template=system_template,
    #             formatted=system_template,
    #         ),
    #         PromptMessage(
    #             role="user",
    #             template=user_template,
    #             formatted=user_template.format(input=message.content),
    #         ),
    #     ],
    #     inputs={"input": message.content},
    #     settings=settings,
    # )
    
    runnable_chain = prompt | model | parser
    # output_chunks = runnable_chain.invoke({})
    # print(''.join(output_chunks))
    # print("output chunks")


    # print([m.to_openai() for m in prompt.messages])

    msg = cl.Message(content="")

    output_stream = runnable_chain.astream({})

    # async for chunk in output_stream:
    #     print(chunk, sep='', flush=True)

    # Call OpenAI
    # async for stream_resp in await client.chat.completions.create(
    #     messages=[m.to_openai() for m in prompt.messages], stream=True, **settings
    # ):
    async for stream_resp in output_stream:
        await msg.stream_token(stream_resp)

        # token = stream_resp.choices[0].delta.content
        # if not token:
        #     token = ""
        # await msg.stream_token(token)

    # Update the prompt object with the completion
    # prompt.completion = msg.content
    # msg.prompt = prompt

    # Send and close the message stream
    await msg.send()