Update app.py

app.py

@@ -13,6 +13,7 @@ client = OpenAI(
 )
 print("OpenAI client initialized.")
 
+
 def respond(
     message,
     history: list[tuple[str, str]],
@@ -25,18 +26,8 @@ def respond(
     custom_model
 ):
     """
-    This function handles the chatbot response. It takes in:
-    - message: the user's new message
-    - history: the list of previous messages, each as a tuple (user_msg, assistant_msg)
-    - system_message: the system prompt
-    - max_tokens: the maximum number of tokens to generate in the response
-    - temperature: sampling temperature
-    - top_p: top-p (nucleus) sampling
-    - frequency_penalty: penalize repeated tokens in the output
-    - seed: a fixed seed for reproducibility; -1 will mean 'random'
-    - custom_model: the final model name in use, which may be set by selecting from the Featured Models radio or by typing a custom model
+    Respond function for ChatInterface.
     """
-
     print(f"Received message: {message}")
     print(f"History: {history}")
     print(f"System message: {system_message}")
@@ -44,159 +35,107 @@ def respond(
     print(f"Frequency Penalty: {frequency_penalty}, Seed: {seed}")
     print(f"Selected model (custom_model): {custom_model}")
 
-    # Convert seed to None if -1 (meaning random)
     if seed == -1:
         seed = None
 
-    # Construct the messages array required by the API
+    # Construct the messages array
     messages = [{"role": "system", "content": system_message}]
-    print("Initial messages array constructed.")
-
-    # Add conversation history to the context
     for val in history:
-        user_part = val[0]  # Extract user message from the tuple
-        assistant_part = val[1]  # Extract assistant message from the tuple
+        user_part = val[0]
+        assistant_part = val[1]
         if user_part:
-            messages.append({"role": "user", "content": user_part})  # Append user message
-            print(f"Added user message to context: {user_part}")
+            messages.append({"role": "user", "content": user_part})
         if assistant_part:
-            messages.append({"role": "assistant", "content": assistant_part})  # Append assistant message
-            print(f"Added assistant message to context: {assistant_part}")
+            messages.append({"role": "assistant", "content": assistant_part})
 
-    # Append the latest user message
     messages.append({"role": "user", "content": message})
-    print("Latest user message appended.")
 
-    # If user provided a model, use that; otherwise, fall back to a default model
+    # If user provided a model, use it; else use default
     model_to_use = custom_model.strip() if custom_model.strip() != "" else "meta-llama/Llama-3.3-70B-Instruct"
-    print(f"Model selected for inference: {model_to_use}")
-
-    # Start with an empty string to build the response as tokens stream in
     response = ""
-    print("Sending request to OpenAI API.")
 
-    # Make the streaming request to the HF Inference API via openai-like client
     for message_chunk in client.chat.completions.create(
-        model=model_to_use,              # Use either the user-provided or default model
-        max_tokens=max_tokens,           # Maximum tokens for the response
-        stream=True,                     # Enable streaming responses
-        temperature=temperature,         # Adjust randomness in response
-        top_p=top_p,                     # Control diversity in response generation
-        frequency_penalty=frequency_penalty,  # Penalize repeated phrases
-        seed=seed,                       # Set random seed for reproducibility
-        messages=messages,               # Contextual conversation messages
+        model=model_to_use,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+        frequency_penalty=frequency_penalty,
+        seed=seed,
+        messages=messages,
     ):
-        # Extract the token text from the response chunk
         token_text = message_chunk.choices[0].delta.content
-        print(f"Received token: {token_text}")
         response += token_text
-        # Yield the partial response to Gradio so it can display in real-time
         yield response
 
-    print("Completed response generation.")
 
 # -------------------------
 # GRADIO UI CONFIGURATION
 # -------------------------
 
-# Create a Chatbot component with a specified height
-chatbot = gr.Chatbot(height=600, show_copy_button=True, placeholder="Select a model and begin chatting", show_copy_all_button=True, likeable=True, layout="panel")  # Define the height of the chatbot interface
-print("Chatbot interface created.")
-
-# Create textboxes and sliders for system prompt, tokens, and other parameters
-system_message_box = gr.Textbox(value="", label="System message")  # Input box for system message
-
-max_tokens_slider = gr.Slider(
-    minimum=1,   # Minimum allowable tokens
-    maximum=4096,  # Maximum allowable tokens
-    value=512,   # Default value
-    step=1,      # Increment step size
-    label="Max new tokens"  # Slider label
-)
-temperature_slider = gr.Slider(
-    minimum=0.1,  # Minimum temperature
-    maximum=4.0,  # Maximum temperature
-    value=0.7,    # Default value
-    step=0.1,     # Increment step size
-    label="Temperature"  # Slider label
-)
-top_p_slider = gr.Slider(
-    minimum=0.1,  # Minimum top-p value
-    maximum=1.0,  # Maximum top-p value
-    value=0.95,   # Default value
-    step=0.05,    # Increment step size
-    label="Top-P"  # Slider label
-)
-frequency_penalty_slider = gr.Slider(
-    minimum=-2.0,  # Minimum penalty
-    maximum=2.0,   # Maximum penalty
-    value=0.0,     # Default value
-    step=0.1,      # Increment step size
-    label="Frequency Penalty"  # Slider label
-)
-seed_slider = gr.Slider(
-    minimum=-1,    # -1 for random seed
-    maximum=65535, # Maximum seed value
-    value=-1,      # Default value
-    step=1,        # Increment step size
-    label="Seed (-1 for random)"  # Slider label
+# Create a Chatbot component
+chatbot = gr.Chatbot(
+    height=600, 
+    show_copy_button=True,
+    placeholder="Select a model and begin chatting",
+    likeable=True,
+    layout="panel"
 )
 
-# The custom_model_box is what the respond function sees as "custom_model"
-custom_model_box = gr.Textbox(
-    value="",  # Default value
-    label="Custom Model",  # Label for the textbox
-    info="(Optional) Provide a custom Hugging Face model path. Overrides any selected featured model."  # Additional info
-)
+# Create textboxes/sliders for system prompt, tokens, etc.
+system_message_box = gr.Textbox(value="", label="System message")
+max_tokens_slider = gr.Slider(1, 4096, value=512, step=1, label="Max new tokens")
+temperature_slider = gr.Slider(0.1, 4.0, value=0.7, step=0.1, label="Temperature")
+top_p_slider = gr.Slider(0.1, 1.0, value=0.95, step=0.05, label="Top-P")
+frequency_penalty_slider = gr.Slider(-2.0, 2.0, value=0.0, step=0.1, label="Frequency Penalty")
+seed_slider = gr.Slider(-1, 65535, value=-1, step=1, label="Seed (-1 for random)")
+custom_model_box = gr.Textbox(value="", label="Custom Model",
+                              info="(Optional) Provide a custom Hugging Face model path. Overrides any selected featured model.")
 
-# Define a function that updates the custom model box when a featured model is selected
 def set_custom_model_from_radio(selected):
     """
-    This function will get triggered whenever someone picks a model from the 'Featured Models' radio.
-    We will update the Custom Model text box with that selection automatically.
+    Update the Custom Model textbox when a featured model is selected.
     """
-    print(f"Featured model selected: {selected}")  # Log selected model
+    print(f"Featured model selected: {selected}")
     return selected
 
-# Create the main ChatInterface object
+
+# Create a user textbox that we can reference
+# This will become our "Message" input inside the ChatInterface
+user_textbox = gr.MultimodalTextbox()
+
+# No 'examples' here—because we want to keep the user's parameters unchanged
 demo = gr.ChatInterface(
-    fn=respond,  # The function to handle responses
+    fn=respond,
     additional_inputs=[
-        system_message_box,          # System message input
-        max_tokens_slider,           # Max tokens slider
-        temperature_slider,          # Temperature slider
-        top_p_slider,                # Top-P slider
-        frequency_penalty_slider,    # Frequency penalty slider
-        seed_slider,                 # Seed slider
-        custom_model_box             # Custom model input
+        system_message_box,
+        max_tokens_slider,
+        temperature_slider,
+        top_p_slider,
+        frequency_penalty_slider,
+        seed_slider,
+        custom_model_box
     ],
-    fill_height=True,  # Allow the chatbot to fill the container height
-    chatbot=chatbot,   # Chatbot UI component
-    textbox=gr.MultimodalTextbox(),
+    fill_height=True,
+    chatbot=chatbot,
+    textbox=user_textbox,
     multimodal=True,
     concurrency_limit=20,
-    theme="Nymbo/Nymbo_Theme",  # Theme for the interface
-    examples=[{"text": "Howdy, partner!",},
-              {"text": "What's your model name and who trained you?",},
-              {"text": "How many R's are there in the word Strawberry?"},],
+    theme="Nymbo/Nymbo_Theme",
+    # No examples parameter used
     cache_examples=False
 )
-
 print("ChatInterface object created.")
 
-# -----------
-# ADDING THE "FEATURED MODELS" ACCORDION
-# -----------
 with demo:
-    with gr.Accordion("Featured Models", open=False):  # Collapsible section for featured models
+    # Featured models accordion
+    with gr.Accordion("Featured Models", open=False):
         model_search_box = gr.Textbox(
-            label="Filter Models",  # Label for the search box
-            placeholder="Search for a featured model...",  # Placeholder text
-            lines=1  # Single-line input
+            label="Filter Models",
+            placeholder="Search for a featured model...",
+            lines=1
         )
-        print("Model search box created.")
 
-        # Sample list of popular text models
         models_list = [
             "meta-llama/Llama-3.3-70B-Instruct",
             "meta-llama/Llama-3.2-3B-Instruct",
@@ -216,38 +155,51 @@ with demo:
             "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
             "microsoft/Phi-3.5-mini-instruct",
         ]
-        print("Models list initialized.")
 
         featured_model_radio = gr.Radio(
-            label="Select a model below",  # Label for the radio buttons
-            choices=models_list,  # List of available models
-            value="meta-llama/Llama-3.3-70B-Instruct",  # Default selection
-            interactive=True  # Allow user interaction
+            label="Select a model below",
+            choices=models_list,
+            value="meta-llama/Llama-3.3-70B-Instruct",
+            interactive=True
         )
-        print("Featured models radio button created.")
 
-        # Filter function for the radio button list
         def filter_models(search_term):
-            print(f"Filtering models with search term: {search_term}")  # Log the search term
-            filtered = [m for m in models_list if search_term.lower() in m.lower()]  # Filter models by search term
-            print(f"Filtered models: {filtered}")  # Log filtered models
+            filtered = [m for m in models_list if search_term.lower() in m.lower()]
             return gr.update(choices=filtered)
 
-        # Update the radio list when the search box value changes
         model_search_box.change(
-            fn=filter_models,  # Function to filter models
-            inputs=model_search_box,  # Input: search box value
-            outputs=featured_model_radio  # Output: update radio button list
+            fn=filter_models,
+            inputs=model_search_box,
+            outputs=featured_model_radio
         )
-        print("Model search box change event linked.")
 
-        # Update the custom model textbox when a featured model is selected
         featured_model_radio.change(
-            fn=set_custom_model_from_radio,  # Function to set custom model
-            inputs=featured_model_radio,  # Input: selected model
-            outputs=custom_model_box  # Output: update custom model textbox
+            fn=set_custom_model_from_radio,
+            inputs=featured_model_radio,
+            outputs=custom_model_box
         )
-        print("Featured model radio button change event linked.")
+
+    # Example Prompts accordion
+    with gr.Accordion("Example Prompts", open=False):
+        ex1_btn = gr.Button("Example 1: 'Howdy, partner!'")
+        ex2_btn = gr.Button("Example 2: 'What's your model name and who trained you?'")
+        ex3_btn = gr.Button("Example 3: 'How many R's in Strawberry?'")
+
+        # Helper function that returns an update for user_textbox
+        def load_example(example_text):
+            return gr.update(value=example_text)
+
+        ex1_btn.click(fn=lambda: load_example("Howdy, partner!"), 
+                      inputs=[],
+                      outputs=user_textbox)
+
+        ex2_btn.click(fn=lambda: load_example("What's your model name and who trained you?"), 
+                      inputs=[],
+                      outputs=user_textbox)
+
+        ex3_btn.click(fn=lambda: load_example("How many R's are there in the word Strawberry?"), 
+                      inputs=[],
+                      outputs=user_textbox)
 
 print("Gradio interface initialized.")