Note-AI

This is kind of Notepad editor with AI functions.

Useful Links

Name

URL

LM Arena

https://lmarena.ai/leaderboard

OpenAI Models

https://platform.openai.com/docs/models

GPT-4.1 Prompting Guide

https://cookbook.openai.com/examples/gpt4-1_prompting_guide

OpenAI Cookbook

https://cookbook.openai.com/

OpenAI Resources and guides

https://openai.com/business/guides-and-resources/

The provided Python code is a Streamlit application designed to interact with OpenAI’s language models, allowing users to generate and save notes based on prompts.

User Input:
  • A text area is provided for users to input their notes.

  • A sidebar allows users to select a prompt from the loaded prompts.

import streamlit as st
from openai import OpenAI
import yaml
import tiktoken
import textwrap
import platform
import time
import os
import ollama
import pyperclip

Prints a stylized banner to the console when the application starts.

st.set_page_config(
    page_title="Note-AI",
)

@st.cache_data
def print_banner():
    print("""
        _   __      __             ___    ____
       / | / /___  / /____        /   |  /  _/
      /  |/ / __ \/ __/ _ \______/ /| |  / /
     / /|  / /_/ / /_/  __/_____/ ___ |_/ /
    /_/ |_/\____/\__/\___/     /_/  |_/___/
    """)
    return 1

print_banner()
st.logo("https://ea-books.netlify.app/lit/ai_note.svg")

An instance of the OpenAI client is created to facilitate communication with the OpenAI API.

client = OpenAI()

Load LLM prompts

The application reads prompts from a YAML file (openai_helper.yml). Each prompt has a name and a corresponding note that describes what the prompt should do.

Useful Links

Name

URL

Prompt engineering

https://platform.openai.com/docs/guides/prompt-engineering

prompts_file = "openai_helper.yml"
with open(prompts_file, 'r') as file:
    prompts = yaml.safe_load(file)

text = st.text_area(f"Note", height=300)

Prompt Tags

Read a list of strings from a file

def read_list_from_file(filename):
    try:
        with open(filename, 'r') as file:
            # Read all lines and remove leading/trailing whitespace
            lines = [line.strip() for line in file.readlines()]
        return lines
    except FileNotFoundError:
        return []
    except Exception as e:
        print(f"Error reading {filename}: {e}")
        return []

Write a list of strings to a text file

def write_list_to_file(filename, list_of_strings):
    try:
        with open(filename, 'w') as file:
            for string in list_of_strings:
                file.write(string + '\n')
    except Exception as e:
        print(f"Error writing {filename}: {e}")

Removes specified strings from a list of strings.

def remove_strings_from_list(string_list, strings_to_remove):
  return [s for s in string_list if s not in strings_to_remove]

Collect all tags into a single set

tags_file = "openai_tags.txt"

def sort_by_pattern(all_tags):
    tags_order = read_list_from_file(tags_file)

    # Create a mapping from tag to priority index for known tags.
    tag_priority = { tag: index for index, tag in enumerate(tags_order) }

    # Sort the all_tags list.
    # For tags in tags_order, the key is (0, priority) and for others (1, tag)
    sorted_tags = sorted(all_tags,
                         key=lambda tag: (0, tag_priority[tag]) if tag in tag_priority
                                           else (1, tag))
    return sorted_tags

all_tags_set = {tag for item in prompts for tag in item.get('tags', [])}
all_tags = sort_by_pattern(list(all_tags_set))
all_tags.insert(0, "all")

tag_name = st.sidebar.selectbox(
   "Tag",
   all_tags,
)

Select the Prompt

def get_prompt(name):
    for entry in prompts:
        if entry['name'] == name:
            return entry.get('note')
    return None

if tag_name == "all":
    prompt_names = [item['name'] for item in prompts]
else:
    prompt_names = [item['name'] for item in prompts if tag_name in item.get('tags', [])]

prompt_name = st.sidebar.selectbox(
   "Prompt",
   prompt_names,
)
prompt = get_prompt(prompt_name)
st.write(prompt)

Select OpenAI LLM

model_type = st.sidebar.radio("Model Type", ["Gemini", "OpenAI", "Ollama"])

if model_type=="Gemini":
    llm_models = [
        "gemini-2.5-flash-preview-05-20",
        "gemini-2.0-flash",
        "gemma-3-27b-it",
    ]

elif model_type=="OpenAI":
    openai_prices = {
        "gpt-4.1-mini": 0.4,
        "gpt-4.1-nano": 0.1,
        "gpt-4.1": 2.0,
        "gpt-4o-mini": 0.15,
        "o4-mini": 1.10,
        "o3-mini": 1.10,
        "gpt-4o": 2.5,
        "o3": 2.0,
        "o3-pro": 20.0,
    }

    llm_models = list(openai_prices.keys())

else:
    llm_models = [
        "ollama llama3.2",
    ]

llm_temperatures = [0, 0.1, 0.7, 1]

openai_model = st.sidebar.selectbox(
   "LLM Model",
   llm_models,
   index = 0
)

llm_temperature = st.sidebar.select_slider(
   "LLM Temperature",
   options = llm_temperatures,
   value = 0.1
)

Tokens & Price

If a button in the sidebar is clicked, the application counts the number of tokens in the user’s input using the tiktoken library and displays the count.

Useful Links

Name

URL

Model Pricing

https://platform.openai.com/docs/pricing#latest-models

if model_type=="OpenAI":

    encoding = tiktoken.encoding_for_model("gpt-4o-mini")
    tokens = encoding.encode(text)

    cents = round(len(tokens) * openai_prices[openai_model]/10000, 5)

    st.sidebar.write(f'''
        | Characters | Tokens | Cents |
        |---|---|---|
        | {len(text)} | {len(tokens)} | {cents} |
        ''')

Call o model

Useful Links

Name

URL

Reasoning with o1

https://learn.deeplearning.ai/courses/reasoning-with-o1/lesson/1/introduction

def call_o_model(prompt, text):
    messages = [
        #{"role": "user", "content": f"<instructions>{prompt}</instructions>\n<user_input>{text}</user_input>"},
        {"role": "developer", "content": prompt},
        {"role": "user", "content": text},
    ]
    response = client.chat.completions.create(
        model=openai_model,
        messages=messages,
    )
    return response.choices[0]

Call gpt model

def call_gpt_model(prompt, text):
    messages = [
        {"role": "developer", "content": prompt},
        {"role": "user", "content": text},
    ]
    response = client.chat.completions.create(
            model=openai_model,
            messages=messages,
            temperature=llm_temperature,
        )
    return response.choices[0]

Call Ollama

Useful Links

Name

URL

Ollama

https://github.com/ollama/ollama?tab=readme-ov-file

Ollama Python

https://github.com/ollama/ollama-python

def call_ollama(prompt, text):
    model = openai_model[len("ollama "):]
    messages = [
        {"role": "system", "content": prompt},
        {"role": "user", "content": text},
    ]
    return ollama.chat(
            model=model,
            messages=messages,
        )

Call Gemini

Useful Links

Name

URL

Text generation

https://ai.google.dev/gemini-api/docs/text-generation?lang=python

OpenAI compatibility

https://ai.google.dev/gemini-api/docs/openai

Example applications

https://ai.google.dev/gemini-api/docs/models/generative-models#example-applications

Model variants

https://ai.google.dev/gemini-api/docs/models/gemini#model-variations

Google Gen AI SDKs

https://ai.google.dev/gemini-api/docs/sdks

def call_gemini(prompt, text):
    g_key = os.getenv("GEMINI_API_KEY")
    g_client = OpenAI(
        api_key=g_key,
        base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
    )
    messages = [
        {"role": "developer", "content": prompt},
        {"role": "user", "content": text},
    ]
    response = g_client.chat.completions.create(
            model=openai_model,
            messages=messages,
            temperature=llm_temperature,
        )
    return response.choices[0]

def call_gemma(prompt, text):
    g_key = os.getenv("GEMINI_API_KEY")
    g_client = OpenAI(
        api_key=g_key,
        base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
    )
    messages = [
        {"role": "user", "content": f"<instructions>{prompt}</instructions>\n<user_input>{text}</user_input>"},
        #{"role": "developer", "content": prompt},
        {"role": "user", "content": text},
    ]
    response = g_client.chat.completions.create(
            model=openai_model,
            messages=messages,
            temperature=llm_temperature,
        )
    return response.choices[0]

When the user clicks a button to call OpenAI:

  • The application sends the selected prompt and user input to the OpenAI API.

  • The response is stored in the session state and displayed to the user.

  • The execution time for the API call is calculated and can be used for monitoring performance.

By the way, we can use emojis in buttons.

Useful Links

Name

URL

OpenAI Chat API

https://platform.openai.com/docs/api-reference/chat

Streamlit emoji shortcodes

https://streamlit-emoji-shortcodes-streamlit-app-gwckff.streamlit.app/

Emoji Cheat Sheet

https://www.webfx.com/tools/emoji-cheat-sheet/

# Concatenate request
def concat_request(prompt, text):
    return prompt + "\n\n```\n" + text + "\n```\n"

if st.button(':thinking_face: &nbsp; Query', type="primary", use_container_width=True):

    start_time = time.time()

    if openai_model.startswith("ollama "):
        response = call_ollama(prompt, text)

    elif openai_model.startswith("o"):
        response = call_o_model(prompt, text)

    elif openai_model.startswith("gemini"):
        response = call_gemini(prompt, text)

    elif openai_model.startswith("gemma"):
        response = call_gemma(prompt, text)

    else:
        response = call_gpt_model(prompt, text)

    st.session_state.openai_result = response.message.content
    st.write(st.session_state.openai_result)

    # Calculate and print execution time
    end_time = time.time()
    execution_time = end_time - start_time
    # print(f'Execution time: `{execution_time:.1f}` seconds')

    # Move selected tag to the beginning of the list
    all_tags = remove_strings_from_list(all_tags, ["all", tag_name])
    all_tags.insert(0, tag_name)
    write_list_to_file(tags_file, all_tags)

    if platform.system() == 'Darwin':
        os.system("afplay /System/Library/Sounds/Glass.aiff")
    st.rerun()

openai_result is cached in a session_state.

if "openai_result" not in st.session_state:
    st.session_state.openai_result = ''
else:
    st.write('---')
    st.write(st.session_state.openai_result)

Save note

Notes will be saved to ai_note folder which is expected to exist.

Output format can be XML with request, response and prompt name, or just response markdown.

note_name = st.text_input("Note Name:")

save_formats = ["Markdown", "XML"]
out_format = st.radio(openai_model + ":", ["Clipboard", "Request"] + save_formats, horizontal=True)

button_name = "Save" if out_format in save_formats else "Copy"

def save_note_disabled():
    return len(note_name.strip())==0 and out_format in save_formats

if st.button(':spiral_note_pad: ' + button_name, disabled=save_note_disabled()):
    if out_format == "Clipboard":
        pyperclip.copy(st.session_state.openai_result)
        st.write(f'Copied to clipboard')
    if out_format == "Request":
        pyperclip.copy(concat_request(prompt, text))
        st.write(f'Request copied to clipboard')
    elif out_format == "XML":
        xml = textwrap.dedent(f"""
            <note>
              <question><![CDATA[{text}]]></question>
              <prompt>{prompt_name}</prompt>
              <answer><![CDATA[{st.session_state.openai_result}]]></answer>
            </note>
        """).strip()
        out_file = f"ai_note/{note_name}.xml"
        with open(out_file, 'w') as file:
            file.write(xml)
        st.write(f'Note saved: `{out_file}`')
    else:
        out_file = f"ai_note/{note_name}.md"
        with open(out_file, 'w') as file:
            file.write(st.session_state.openai_result)
        st.write(f'Note saved: `{out_file}`')

Environment Setup

To set up your environment using Miniconda, follow the steps below. These instructions will guide you through installing Miniconda, configuring your environment, and running a Streamlit application tailored for AI tasks.

Step 1: Install Miniconda

First, you need to install Miniconda. Visit the Miniconda website and follow the installation instructions for your operating system.

Step 2: Configure Your Environment

  1. Create the Environment File

    Create a file named environment.yml in your project directory. Paste the following contents into this file:

    name: ai_note
    channels:
      - conda-forge
      - defaults
    dependencies:
      - python=3.11.0
      - openai
      - tiktoken
      - streamlit
      - pyperclip
      - pip:
        - ollama
    
  2. Select conda-forge Channel

    Open your terminal or command prompt and execute the following commands to prioritize the conda-forge channel:

    conda config --add channels conda-forge
    conda config --set channel_priority strict
    
  3. Create the Environment

    Still in your terminal, navigate to the directory containing your environment.yml file. Create the Conda environment by running:

    conda env create -f environment.yml
    

Step 3: Activate the Environment

Activate your newly created environment by executing:

conda activate ai_note

Step 4: Prepare Prompt File

Create a file named openai_helper.yml in your project directory. This file should contain various prompts for the tasks you want to accomplish. You can include tags in your prompts to categorize them. Here’s an example of how to structure the contents:

- name: grammar
  note: You will be provided with statements in markdown, and your task is to convert them to standard English.
  tags:
    - text

- name: improve_style
  note: Improve style of the content you are provided.
  tags:
    - text

- name: summarize_md
  note: You will be provided with statements in markdown, and your task is to summarize the content.
  tags:
    - text

- name: explain_python
  note: Explain Python code you are provided.
  tags:
    - python

- name: write_python
  note: Write Python code to satisfy the description you are provided.
  tags:
    - python
Useful Links

Name

URL

Examples of OpenAI prompts

https://platform.openai.com/examples

Step 5: Run Streamlit Script

With your environment set up and activated, and your openai_helper.yml file ready, you’re now set to run your Streamlit application. Execute the following command in your terminal:

streamlit run ai_note.py

And that’s it! Your Streamlit application should now be running, and you can interact with it through your web browser.