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 aimakerspace.text_utils import PDFFileLoader, CharacterTextSplitter
from aimakerspace.vectordatabase import VectorDatabase

load_dotenv()

# ChatOpenAI Templates
system_template = """You are a Wizzard and everything you say is a spell!
"""

user_template = """{input}
Wizzard, think through your response step by step.
"""

assistant_template = """Use the following context, if any, to help you
answer the user's input, if the answer is not in the context say you don't
know the answer.
CONTEXT:
===============
{context}
===============

Spell away Wizzard!
"""



@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,
    }

    cl.user_session.set("settings", settings)

    files = None
    while files is None:
        files = await cl.AskFileMessage(
            content="Please upload a PDF file to begin",
            accept=["application/pdf"],
            max_files=10,
            max_size_mb=10,
            timeout=60
        ).send()

    # let the user know you are processing the file(s)
    await cl.Message(
        content="Loading your files..."
    ).send()

    # decode the file
    documents = PDFFileLoader(path="", files=files).load_documents()

    # split the text into chunks
    chunks = CharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200
    ).split_texts(documents)

    print(chunks[0])

    # create a vector store
    # let the user know you are processing the document(s)
    await cl.Message(
        content="Creating vector store"
    ).send()

    vector_db = VectorDatabase()
    vector_db = await vector_db.abuild_from_list(chunks)

    await cl.Message(
        content="Done. Ask away!"
    ).send()
    
    cl.user_session.set("vector_db", vector_db)


@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):
    vector_db = cl.user_session.get("vector_db")
    settings = cl.user_session.get("settings")

    client = AsyncOpenAI()

    print(message.content)

    results_list = vector_db.search_by_text(query_text=message.content, k=3, return_as_text=True)
    if results_list:
        results_string = "\n\n".join(results_list)
    else:
        results_string = ""

    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),
            ),
            PromptMessage(
                role="assistant",
                template=assistant_template,
                formatted=assistant_template.format(context=results_string)
            )
        ],
        inputs={
            "input": message.content,
            "context": results_string
            },
        settings=settings,
    )

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

    msg = cl.Message(content="")

    # Call OpenAI
    async for stream_resp in await client.chat.completions.create(
        messages=[m.to_openai() for m in prompt.messages], stream=True, **settings
    ):
        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()