Upload 4 files

app.py

@@ -0,0 +1,262 @@
+import json
+import streamlit as st
+from streamlit_modal import Modal
+import streamlit.components.v1 as components
+from clients import OllamaClient, NvidiaClient, GroqClient
+
+st.set_page_config(
+    page_title="Prompts Library",
+    layout="wide",
+)
+
+# Cache the header of the app to prevent re-rendering on each load
+@st.cache_resource
+def display_app_header():
+    """Display the header of the Streamlit app."""
+    st.title("Prompts Library")
+    st.subheader("ChatBot with prompt templates")
+
+# Display the header of the app
+display_app_header()
+
+# Some style
+st.markdown(
+    '<style>div[key^="edit-modal"] {top: 25px;}</style>', unsafe_allow_html=True
+)
+
+
+# UI sidebar ##########################################
+def ui_llm(provider):
+    if api_token := st.sidebar.text_input("Enter your API Key", key=f"API_{provider}"):
+        provider_models = llm_providers[st.session_state["llm_provider"]](
+            api_key=api_token
+        ).list_models_names()
+        if provider_models:
+            llm = st.sidebar.radio(
+                "Select your model", provider_models, key="llm"
+            )
+        else:
+            st.sidebar.error("Ollama is not running, or there is a problem with the selected LLM provider")
+    else:
+        st.sidebar.warning("You must enter your API key")
+
+st.sidebar.subheader("Models")
+
+# LLM
+llm_providers = {
+    "Cloud Groq": GroqClient,
+    "Cloud Nvidia": NvidiaClient,
+    "Local Ollama": OllamaClient,
+}
+if llm_provider := st.sidebar.radio(
+    "Choose your LLM Provider", llm_providers.keys(), key="llm_provider"
+):
+    ui_llm(st.session_state["llm_provider"])
+
+# LLM parameters
+st.sidebar.subheader("Parameters")
+max_tokens = st.sidebar.number_input("Token numbers", value=1024, key="max_tokens")
+temperature = st.sidebar.slider(
+    "Temperature", min_value=0.0, max_value=1.0, value=0.5, step=0.1, key="temperature"
+)
+top_p = st.sidebar.slider(
+    "Top P", min_value=0.0, max_value=1.0, value=0.7, step=0.1, key="top_p"
+)
+
+# helpers functions ########################################
+
+def edit_form(form_name, title=None, source=None, system=None, user=None):
+    """
+    Creates a form for editing a prompt template.
+
+    Args:
+        form_name: The name of the form.
+        title: The title of the prompt template (optional).
+        source: The source of the prompt template (optional).
+        system: The system example instruction (optional).
+        user: The user example instruction (optional).
+
+    Returns:
+        None
+    """
+    with st.form(form_name, clear_on_submit=False, border=True):
+        new_title = st.text_input("Name", value=title)
+        new_source = st.text_input("Source", value=source)
+        new_system = st.text_area("System example instruction", value=system)
+        new_user = st.text_area("User example instruction", value=user)
+        if st.form_submit_button("Submit"):
+            rec = {
+                "title": new_title,
+                "source": new_source,
+                "messages": [
+                    {"role": "system", "content": new_system},
+                    {"role": "user", "content": new_user},
+                ],
+            }
+            if title is not None:
+                delete_prompt(title)
+            add_prompt(rec)
+
+
+def read_prompts_file():
+    """
+    Loads the prompts from the "prompts.json" file.
+
+    Returns:
+        A list of prompt templates.
+    """
+    prompts_file = open("prompts.json", encoding="utf-8")
+    return json.load(prompts_file)
+
+
+def add_prompt(rec):
+    """
+    Adds a new prompt to the "prompts.json" file.
+
+    Args:
+        rec: The new prompt to add.
+
+    Returns:
+        None
+    """
+    with open("prompts.json", "r", encoding="utf-8") as fp:
+        listObj = json.load(fp)
+    listObj.append(rec)
+    print(listObj)
+    with open("prompts.json", "w") as outfile:
+        outfile.write(json.dumps(listObj, indent=4, sort_keys=True))
+    st.rerun()
+
+
+def edit_prompt(title):
+    """
+    Edits a prompt template.
+
+    Args:
+        title: The title of the prompt to edit.
+
+    Returns:
+        A dictionary containing the edited prompt information.
+    """
+    with open("prompts.json", "r", encoding="utf-8") as fp:
+        listObj = json.load(fp)
+    rec = [i for i in listObj if i["title"].strip() == title.strip()]
+    rec_messages = rec[0]["messages"]
+    return edit_form(
+        "prompt_edit",
+        title=title,
+        source=[x["source"] for x in rec][0],
+        system=[x["content"] for x in rec_messages if x["role"] == "system"][0],
+        user=[x["content"] for x in rec_messages if x["role"] == "user"][0],
+    )
+
+
+def delete_prompt(title):
+    """
+    Removes a prompt template from the "prompts.json" file.
+
+    Args:
+        title: The title of the prompt to delete.
+    """
+    with open("prompts.json", "r", encoding="utf-8") as fp:
+        listObj = json.load(fp)
+    recs = [i for i in listObj if not (i["title"].strip() == title.strip())]
+    with open("prompts.json", "w") as outfile:
+        outfile.write(json.dumps(recs, indent=4, sort_keys=True))
+
+
+def get_llm_response(system, prompt):
+    """
+    Generates a response from the selected LLM.
+
+    Args:
+        system: The system input from the user.
+        prompt: The user prompt.
+
+    Returns:
+        The response from the LLM.
+    """
+    options = dict(
+        max_tokens=st.session_state["max_tokens"],
+        top_p=st.session_state["top_p"],
+        temperature=st.session_state["temperature"],
+    )
+    return llm_providers[st.session_state["llm_provider"]](
+        api_key=st.session_state[f"API_{st.session_state['llm_provider']}"],
+        model=st.session_state["llm"],
+    ).api_chat_completion(system, prompt, **options)
+
+
+def generate(system, prompt):
+    st.session_state.messages.append({"role": "system", "content": system})
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("assistant"):
+        response = get_llm_response(
+            llm_providers[st.session_state["llm_provider"]], system, prompt
+        )
+        st.markdown(response)
+        # Add assistant response to chat history
+        st.session_state.messages.append({"role": "assistant", "content": response})
+
+
+# UI main #####################################################
+
+tab1, tab2 = st.tabs(["Prompts Library", "Chatbot"])
+with tab1:
+    new_modal = Modal(
+        "Add prompt",
+        key="edit-modal",
+    )
+    if new_prompt_modal := st.button("➕ Add a prompt template"):
+        new_modal.open()
+    if new_modal.is_open():
+        with new_modal.container():
+            edit_form("prompt_add")
+    prompts = read_prompts_file()
+    grids = range(1, len(prompts) + 1)
+    cols = st.columns([1, 1])
+    wcol = 2
+    for f, b in zip(prompts, grids):
+        col = cols[b % wcol]
+        with col:
+            with st.expander(f["title"].upper()):
+                if st.button(f"✔️ Select prompt {f['title'].upper()} and go to Chatbot tab", type="secondary"):
+                        # can do better here
+                        st.session_state["init_messages"] = f["messages"]
+                        st.session_state.init_system = f["messages"][0]["content"]
+                        st.session_state.init_user = f["messages"][1]["content"]
+                edit_modal = Modal(
+                    f"Edit prompt {f['title'].upper()}",
+                    key=f"edit-modal_{f['title']}",
+                )
+                if edit_prompt_modal := st.button(
+                    f"✏️ Edit {f['title'].upper()}", type="secondary"
+                ):
+                    edit_modal.open()
+                if edit_modal.is_open():
+                    with edit_modal.container():
+                        edit_prompt(f["title"])
+                st.write(f"Source : {f['source']}")
+                st.markdown(f"- System : {f['messages'][0]['content']}")
+                st.markdown(f"- User: {f['messages'][1]['content']}")
+                st.divider()
+                if st.button(f"❌ Delete prompt {f['title'].upper()}", type="primary"):
+                    delete_prompt(f["title"])
+                    st.rerun()
+with tab2:
+    # Initialize chat history
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    # Display chat messages from history on app rerun
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+    # React to user input
+    if "init_messages" in st.session_state:
+        system = st.text_area(":blue[System]", key="init_system")
+        prompt = st.text_area(":blue[User]", key="init_user")
+    else:
+        system = st.text_area(":blue[System]")
+        prompt = st.text_area(":blue[User]")
+    if st.button("Generate", type="primary"):
+        generate(system, prompt)

clients.py

@@ -0,0 +1,143 @@
+import requests
+import json
+
+
+class OllamaClient:
+    def __init__(
+        self,
+        api_key=None,
+        model=None,
+    ):
+        self.base_url = "http://localhost:11434"
+        self.headers = {"Content-Type": "application/json"}
+        self.api_key = api_key
+        self.model = model
+
+    def list_models(self):
+        url = f"{self.base_url}/api/tags"
+        try:
+            response = requests.get(url)
+            response.raise_for_status()  # Raise an exception for HTTP errors (status codes 4xx and 5xx)
+            return response.json()  # returns the response is in JSON format
+        except requests.exceptions.HTTPError as http_err:
+            print(f"HTTP error occurred: {http_err}")
+        except Exception as err:
+            print(f"Other error occurred: {err}")
+
+    def list_models_names(self):
+        models = self.list_models()
+        return [x["name"] for x in models["models"]]
+
+    def api_chat_completion(self, system, prompt, **options):
+        url = f"{self.base_url}/api/chat"
+        options = (
+            options
+            if options is not None
+            else {"max_tokens": 1024, "top_p": 0.7, "temperature": 0.7}
+        )
+        payload = json.dumps(
+            {
+                "model": self.model,
+                "messages": [
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": prompt},
+                ],
+                "option": {
+                    "num_ctx": self.options["max_tokens"],
+                    "top_p": self.options["top_p"],
+                    "temperature": self.options["temperature"],
+                    # stop_sequences=["<|prompter|>","<|assistant|>","</s>"]
+                },
+                "stream": False,
+            }
+        )
+        response = requests.request("POST", url, headers=self.headers, data=payload)
+        return response.json()["message"]["content"]
+
+
+class NvidiaClient:
+    def __init__(self, api_key=None, model=None):
+        self.base_url = "https://integrate.api.nvidia.com/v1"
+        self.api_key = api_key
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        self.model = model
+
+    def list_models(self):
+        url = f"{self.base_url}/models"
+        response = requests.request(
+            "GET", url
+        )  # api_key is not needed to list the available models
+        return response.json()
+
+    def list_models_names(self):
+        models = self.list_models()
+        return [x["id"] for x in models["data"]]
+
+    def api_chat_completion(self, system, prompt, **options):
+        url = f"{self.base_url}/chat/completions"
+        options = (
+            options
+            if options is not None
+            else {"max_tokens": 1024, "top_p": 0.7, "temperature": 0.7}
+        )
+        payload = json.dumps(
+            {
+                "model": self.model,
+                "messages": [
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": prompt},
+                ],
+                "temperature": options["temperature"],
+                "top_p": options["top_p"],
+                "max_tokens": options["max_tokens"],
+                "stream": False,
+            }
+        )
+        response = requests.request("POST", url, headers=self.headers, data=payload)
+        return response.json()["choices"][0]["message"]["content"]
+
+
+class GroqClient:
+    def __init__(self, api_key=None, model=None):
+        self.base_url = "https://api.groq.com/openai/v1"
+        self.api_key = api_key
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        self.model = model
+
+    def list_models(self):
+        url = f"{self.base_url}/models"
+        response = requests.request("GET", url, headers=self.headers)
+        return response.json()
+
+    def list_models_names(self):
+        models = self.list_models()
+        return [x["id"] for x in models["data"]]
+
+    def api_chat_completion(self, system, prompt, **options):
+        url = f"{self.base_url}/chat/completions"
+        options = (
+            options
+            if options is not None
+            else {"max_tokens": 1024, "top_p": 0.7, "temperature": 0.7}
+        )
+        payload = json.dumps(
+            {
+                "model": self.model,
+                "messages": [
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": prompt},
+                ],
+                "temperature": options["temperature"],
+                "top_p": options["top_p"],
+                "max_tokens": options["max_tokens"],
+                "stream": False,
+            }
+        )
+        response = requests.request("POST", url, headers=self.headers, data=payload)
+        return response.json()["choices"][0]["message"]["content"]

prompts.json

@@ -0,0 +1,86 @@
+[
+    {
+        "messages": [
+            {
+                "content": "Your task is to take the code snippet provided and explain it in simple, easy-to-understand language. Break down the code's functionality, purpose, and key components. Use analogies, examples, and plain terms to make the explanation accessible to someone with minimal coding knowledge. Avoid using technical jargon unless absolutely necessary, and provide clear explanations for any jargon used. The goal is to help the reader understand what the code does and how it works at a high level.",
+                "role": "system"
+            },
+            {
+                "content": "import random def bubble*sort(arr): n = len(arr) for i in range(n-1): for j in range(n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] return arr numbers = [random.randint(1, 100) for * in range(10)] print(\u201cUnsorted array:\u201d, numbers) sorted_numbers = bubble_sort(numbers) print(\u201cSorted array:\u201d, sorted_numbers)",
+                "role": "user"
+            }
+        ],
+        "source": "Anthropic https://docs.anthropic.com/en/prompt-library",
+        "title": "code-clarifier"
+    },
+    {
+        "messages": [
+            {
+                "content": "Your task is to take the unstructured text provided and convert it into a well-organized table format using JSON. Identify the main entities, attributes, or categories mentioned in the text and use them as keys in the JSON object. Then, extract the relevant information from the text and populate the corresponding values in the JSON object. Ensure that the data is accurately represented and properly formatted within the JSON structure. The resulting JSON table should provide a clear, structured overview of the information presented in the original text.",
+                "role": "system"
+            },
+            {
+                "content": "Silvermist Hollow, a charming village, was home to an extraordinary group of individuals. Among them was Dr. Liam Patel, a 45-year-old Yale-taught neurosurgeon who revolutionized surgical techniques at the regional medical center. Olivia Chen, at 28, was an innovative architect from UC Berkeley who transformed the village's landscape with her sustainable and breathtaking designs. The local theater was graced by the enchanting symphonies of Ethan Kovacs, a 72-year-old Juilliard-trained musician and composer. Isabella Torres, a self-taught chef with a passion for locally sourced ingredients, created a culinary sensation with her farm-to-table restaurant, which became a must-visit destination for food lovers. These remarkable individuals, each with their distinct talents, contributed to the vibrant tapestry of life in Silvermist Hollow.",
+                "role": "user"
+            }
+        ],
+        "source": "Anthropic https://docs.anthropic.com/en/prompt-library",
+        "title": "data extractor"
+    },
+    {
+        "messages": [
+            {
+                "content": "You are an AI assistant with expertise in LaTeX, a document preparation system widely used for academic and technical writing. Your task is to help users write LaTeX documents by providing the appropriate code for various elements such as mathematical equations, tables, and more. Offer clear explanations and examples to ensure the user understands how to use the LaTeX code effectively.",
+                "role": "system"
+            },
+            {
+                "content": "I need to create a simple table with three columns and two rows. The header row should contain the titles \u201cName,\u201d \u201cAge,\u201d and \u201cCity.\u201d The data row should have the values \u201cJohn,\u201d \u201c25,\u201d and \u201cNew York.\u201d",
+                "role": "user"
+            }
+        ],
+        "source": "Anthropic https://docs.anthropic.com/en/prompt-library/latex-legend",
+        "title": "LaTeX Expert"
+    },
+    {
+        "messages": [
+            {
+                "content": "Your task is to review the provided meeting notes and create a concise summary that captures the essential information, focusing on key takeaways and action items assigned to specific individuals or departments during the meeting. Use clear and professional language, and organize the summary in a logical manner using appropriate formatting such as headings, subheadings, and bullet points. Ensure that the summary is easy to understand and provides a comprehensive but succinct overview of the meeting\u2019s content, with a particular focus on clearly indicating who is responsible for each action item.",
+                "role": "system"
+            },
+            {
+                "content": "Meeting notes:\n\nDate: Verona, Italy - Late 16th century\n\nAttendees:\n- Lord Capulet (Head of the Capulet family)\n- Lord Montague (Head of the Montague family)\n- Prince Escalus (Ruler of Verona)\n- Friar Laurence (Religious advisor)\n\nAgenda:\n1. Address the ongoing feud between the Capulet and Montague families\n2. Discuss the secret marriage of Romeo Montague and Juliet Capulet\n3. Develop a plan to bring peace to Verona\n4. Address the tragic deaths of Romeo and Juliet\n\nDiscussion:\n- Prince Escalus opened the meeting by expressing his grave concern over the long-standing feud between the Capulet and Montague families. He admonished both Lord Capulet and Lord Montague for the recent violent clashes that have disturbed the peace in Verona\u2019s streets. The Prince warned that further violence would result in severe consequences, including heavy fines and potential exile for the perpetrators.\n- Friar Laurence then broached the topic of the between Romeo Montague and Juliet Capulet, which had taken place under his guidance. Lord Capulet and Lord Montague evidently had not known about it, and reacted with anger and disbelief. However, Friar Laurence urged them to consider the profound and tragic love shared by their children and the potential for this love to heal the rift between the families going forward.\n- Prince Escalus proposed a formal truce between the Capulet and Montague families. He demanded that both sides lay down their arms and cease all hostile actions against one another. The Prince declared that any violation of the truce would result in severe punishments, including the possibility of exile or even execution. Lord Capulet and Lord Montague, recognizing the wisdom in the Prince\u2019s words and the necessity of peace for the well-being of their families and the city, grudgingly agreed to the terms of the truce.\n- The meeting took a somber turn as the tragic deaths of Romeo and Juliet were addressed. Friar Laurence recounted the unfortunate series of events that led to the young lovers taking their own lives, emphasizing the devastating impact of the families\u2019 hatred on their innocent children. Lord Capulet and Lord Montague, overcome with grief and remorse, acknowledged that their blind hatred had ultimately caused the loss of their beloved children.\n- Prince Escalus called upon the families to learn from this heartbreaking tragedy and to embrace forgiveness and unity in honor of Romeo and Juliet\u2019s memory. He urged them to work together to create a lasting peace in Verona, setting aside their long-standing animosity. Friar Laurence offered his support in mediating any future disputes and providing spiritual guidance to help the families heal and move forward.\n- As the meeting drew to a close, Lord Capulet and Lord Montague pledged to put an end to their feud and work towards reconciliation. Prince Escalus reaffirmed his commitment to ensuring that the truce would be upheld, promising swift justice for any who dared to break it.\n- The attendees agreed to meet regularly to discuss the progress of their reconciliation efforts and to address any challenges that may arise.",
+                "role": "user"
+            }
+        ],
+        "source": "Anthropic https://docs.anthropic.com/en/prompt-library/meeting-scribe",
+        "title": "Meeting notes rewriter"
+    },
+    {
+        "messages": [
+            {
+                "content": "Your task is to analyze the provided Python code snippet and suggest improvements to optimize its performance. Identify areas where the code can be made more efficient, faster, or less resource-intensive. Provide specific suggestions for optimization, along with explanations of how these changes can enhance the code\u2019s performance. The optimized code should maintain the same functionality as the original code while demonstrating improved efficiency.",
+                "role": "system"
+            },
+            {
+                "content": "def fibonacci(n):\nif n <= 0:\nreturn []\nelif n == 1:\nreturn [0]\nelif n == 2:\nreturn [0, 1]\nelse:\nfib = [0, 1]\nfor i in range(2, n):\nfib.append(fib[i-1] + fib[i-2])\nreturn fib",
+                "role": "user"
+            }
+        ],
+        "source": "Anthropic https://docs.anthropic.com/en/prompt-library/code-consultant",
+        "title": "Code consultant"
+    },
+    {
+        "messages": [
+            {
+                "content": "test",
+                "role": "system"
+            },
+            {
+                "content": "test",
+                "role": "user"
+            }
+        ],
+        "source": "ys",
+        "title": "test"
+    }
+]

requirements.txt

@@ -0,0 +1,3 @@
+requests
+streamlit
+streamlit-modal