All.chatgpt api.how to guide

Chatgpt Api#

OpenAI Assistant Runner & Manager#

What is OpenAI Assistant#

An assistant is similar to a modified GPT that has mastered some knowledge and is able to use that knowledge for future tasks
The official OpenAI documentation is at https://platform.openai.com/docs/assistants/overview
Normally you "chat" with ChatGPT, that means anything you send to it is treated as input
GPT will forget what you previously said or files uploaded as the total length of the conversation grows
By creating an Assistant, you build a new "instance" of ChatGPT and can give it some knowledge to learn
This knowledge can be in many formats and up to 20 files (512MB each) at a time
With an instruction string, you define its behavior about how it should make use of those knowledge
When talking to an assistant, you can still add files in the message
These files does not count towards its 20 files' knowledge limit, as they are considered as input and will be forgotten eventually

General pattern#

Creation:
- Send some guideline or example files for one type of task to the Assistant itself as knowledge
- Send an instruction about how it should deal with tasks using those knowledge
Running:
- Whenever a specific task comes, send the task and its data files in the message as input
- Let the assistant solve the task based on the knowledge it learned
- It will forget everything in this task, and be ready for the next task like this one never happens
Chatting:
- You can continue the conversation if you are not satisfied with its reply
- Chatting is not yet implemented in our code, since command line scripts cannot save conversations.

Code organization#

Libraries are under helpers, e.g.,
- helpers/hchatgpt.py
- helpers/hchatgpt_instructions.py
Scripts are under dev_scripts/chatgpt, e.g.,
- dev_scripts/chatgpt/manage_chatgpt_assistant.py
- dev_scripts/chatgpt/run_chatgpt.py

How to use#

Add the API KEY

> export OPENAI_API_KEY=<your secret key>

Each API key can be bound to an OpenAI Organization
Assistants are organization-wide, an assistant created under our Org can be accessed by any API key that belongs to our Org

Assistant Manager#

The interface is like:

> manage_chatgpt_assistant.py -h
Manage the ChatGPT Assistants in our OpenAI Organization

optional arguments:
    -h, --help            show this help message and exit
    --create CREATE_NAME  Name of the assistant to be created
    --edit EDIT_NAME      Name of the assistant to be edited
    --delete DELETE_NAME  Name of the assistant to be deleted, will ignore all other arguments
    --new_name NEW_NAME   New name for the assistant, only used in -e
    --model MODEL         Model used by the assistant
    --instruction_name INSTRUCTION_NAME
                                                Name of the instruction for the assistant, as shown in helpers.hchatgpt_instructions
    --input_files [INPUT_FILE_PATHS ...]
                                                Files needed for the assistant, use relative path from project root
    --retrieval_tool, --no-retrieval_tool
                                                Enable the retrieval tool. Use --no-r to disable
    --code_tool, --no-code_tool
                                                Enable the code_interpreter tool. Use --no-c to disable
    --function FUNCTION   Apply certain function tool to the assistant, not implemented yet
    -v {TRACE,DEBUG,INFO,WARNING,ERROR,CRITICAL}
                                                Set the logging level

Use this script to create, modify, or delete an assistant in our Org
A set of instructions are in helpers/hchatgpt_instructions.py
Feel free to add more instructions for different tasks here
For better understanding, the name of an assistant created should be related to its instruction name

E.g., create a doc writer assistant with name DocWriter-1 and use instruction=DocWriter from helpers/hchatgpt_instructions.py

> manage_chatgpt_assistant.py \
        --create DocWriter-1 \
        --model "gpt-4-1106-preview" \
        --instruction_name DocWriter \
        --input_files docs/work_tools/all.bfg_repo_cleaner.how_to_guide.md docs/marketing/dropcontact.how_to_guide.md docs/coding/all.hplayback.how_to_guide.md \
        --retrieval_tool --code_tool

Running Assistant#

The script dev_scripts/chatgpt/run_chatgpt.py runs an assistant

The interface is like:

> run_chatgpt.py -h
Use ChatGPT Assistant to process a file or certain text.

optional arguments:
    -h, --help            show this help message and exit
    --list                Show all currently available assistants and exit
    --assistant_name ASSISTANT_NAME
                                                Name of the assistant to be used
    --input_files [INPUT_FILE_PATHS ...]
                                                Files needed in this run, use relative path from project root
    --model MODEL         Use specific model for this run, overriding existing assistant config
    --output_file OUTPUT_FILE
                                                Redirect the output to the given file
    --input_text INPUT_TEXT
                                                Take a text input from command line as detailed instruction
    --vim                 Disable -i (but not -o), take input from stdin and output to stdout forcely
    -v {TRACE,DEBUG,INFO,WARNING,ERROR,CRITICAL}
                                                Set the logging level

dev_scripts/run_chatgpt.py -l will show all the available assistants in our Org.

Refer to helpers/hchatgpt_instructions.py to see how they are instructed

> python dev_scripts/chatgpt/run_chatgpt.py \
    -n MarkdownLinter \ # Use the assistant "MarkdownLinter"
    -f dev_scripts/chatgpt/example_data/corrupted_dropcontact.how_to_guide.md \ # Give this corrupted markdown file
    -o dev_scripts/chatgpt/example_data/gpt_linted_dropcontact.how_to_guide.md # Redirect its output to this file

API library#

helpers/hchatgpt.py provides methods that wrap and interact with OpenAI API
By using these methods, you can easily build an assistant and chat to it with our files
Key functionalities include:
- Uploading and removing files from OpenAI
- Adding and removing files for an assistant
- Creating threads and messages for user input
- Running threads with certain assistants
- End-to-end communication method between users and the assistant

Usage#

The following snippets provide a basic overview of the code usage.

File structure#

Since OpenAI File manager does not hold folder structure, you use a cache dictionary to save the relation between our file (with folder) and OpenAI File IDs
This dictionary will be constantly accessed and saved back to project_root/gpt_id.json
If you find anything buggy, try deleting this cache file and rerun the code so that it can be regenerated from scratch

Uploading and retrieving Files#

To upload a file to OpenAI, which you can later attach to messages/assistants:

python file_id = upload_to_gpt('path_to_your_file')
If you want to retrieve a file that has been uploaded to OpenAI by its path or ID: python file_object = get_gpt_file_from_path('path_to_your_file') or python file_object = get_gpt_file_from_id(file_id)

Managing Assistants#

You can specify files an assistant should constantly use (like guidelines):

set_assistant_files_by_name('assistant_name', ['file_path_1', 'file_path_2'])

Add or remove specific files to/from an existing assistant by file paths or IDs:

add_files_to_assistant_by_name('assistant_name', ['new_file_path'])
delete_file_from_assistant_by_name('assistant_name', 'file_path_to_remove')

ChatGPT communication#

Create a thread and send a message, with or without attaching files:

python thread_id = create_thread() message_id = create_message_on_thread_with_file_names(thread_id, 'Your message content', ['file_name_1'])
Run a thread on an assistant to get the Assistant's response: python run_id = run_thread_on_assistant_by_name('assistant_name', thread_id) response_messages = wait_for_run_result(thread_id, run_id)

E2E assistant runner#

Interact with an assistant conveniently with the e2e_assistant_runner function
This function can take user input, send it to the assistant, and manage file attachments in one call: ```python response = e2e_assistant_runner( 'assistant_name', 'Your question or statement here', input_file_names=['file_name_1'])

Outputs the assistant's response.#

print(response) ```