s

app.py

@@ -1,101 +1,107 @@
 import gradio as gr
+from huggingface_hub import InferenceClient
+
+client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+
+
+def respond(
+    message: str,
+    history: list[tuple[str, str]],
+    system_message: str,
+    max_tokens: int,
+    temperature: float,
+    top_p: float,
+):
+    """
+    Generates a response using the Hugging Face Inference API.
+
+    Args:
+        message (str): User's current input.
+        history (list[tuple[str, str]]): Previous conversation history.
+        system_message (str): Instructions for the model (e.g., persona details).
+        max_tokens (int): Maximum tokens allowed for the response.
+        temperature (float): Sampling temperature for randomness in the output.
+        top_p (float): Top-p (nucleus) sampling parameter.
+
+    Yields:
+        str: The generated chatbot response.
+    """
+    messages = [{"role": "system", "content": system_message}]
+
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
+
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+
+    try:
+        for message in client.chat_completion(
+            messages,
+            max_tokens=max_tokens,
+            stream=True,
+            temperature=temperature,
+            top_p=top_p,
+        ):
+            token = message.choices[0].delta.content
+            response += token
+            yield response
+    except Exception as e:
+        yield f"Error: {str(e)}"
+
+
+def system_message_selector(choice):
+    if choice == "Friendly Chatbot":
+        return "You are a friendly and helpful chatbot."
+    elif choice == "Professional Assistant":
+        return "You are a highly knowledgeable and professional assistant."
+    elif choice == "Curious Researcher":
+        return "You are a curious researcher who loves to explore new ideas."
+    else:
+        return "You are a helpful assistant."
+
+
+def custom_system_message(file):
+    if file:
+        return file.read().decode("utf-8")
+    return "You are a helpful assistant."
+
+
+# Create the UI components
+system_message_radio = gr.Radio(
+    choices=["Friendly Chatbot", "Professional Assistant", "Curious Researcher"],
+    value="Friendly Chatbot",
+    label="Choose a Persona",
+)
+
+file_upload = gr.File(label="Upload Custom System Message (Optional)")
 
-# Dictionary to store characters and their attributes
-characters = {}
-
-# Function to create a character
-def create_character(name, age, gender, personality, backstory):
-    characters[name] = {
-        "age": age,
-        "gender": gender,
-        "personality": personality,
-        "backstory": backstory,
-    }
-    return f"Character {name} created successfully!", list(characters.keys())
-
-# Function to handle personality-based responses
-def respond_with_personality(character_name, message, history):
-    if character_name not in characters:
-        return f"Character {character_name} not found!", history
-    
-    character = characters[character_name]
-    personality = character['personality']
-    
-    if personality == "Heroic":
-        response = f"{character_name}: Fear not! With bravery, you can overcome any challenge!"
-    elif personality == "Sarcastic":
-        response = f"{character_name}: Oh really? Facing a tough day? Why not just take a nap? That usually works."
-    elif personality == "Optimistic":
-        response = f"{character_name}: Don't worry, things will turn out great! Keep your chin up!"
-    elif personality == "Empathetic":
-        response = f"{character_name}: I totally understand what you're going through. That must be really tough."
+def combined_system_message(choice, file):
+    if file:
+        return custom_system_message(file)
     else:
-        response = f"{character_name}: {message}? I think you got this!"
-
-    # Add user message and character response to history
-    history.append((message, response))
-    return history, response
-
-# Main chat function that handles conversation with multiple characters
-def chat(character_name, message, history):
-    if character_name not in characters:
-        return history, f"Character {character_name} doesn't exist!"
-    
-    # Generate a response from the selected character
-    history, response = respond_with_personality(character_name, message, history)
-    return history, response
-
-# Main interface with character creation and chat functionality
-def build_interface():
-    with gr.Blocks() as demo:
-        gr.Markdown("# AI Roleplay with Customizable Characters")
-
-        # Character creation UI
-        with gr.Tab("Create Character"):
-            name_input = gr.Textbox(label="Character Name", placeholder="Enter character name")
-            age_input = gr.Number(label="Character Age", value=25, step=1)
-            gender_input = gr.Dropdown(choices=["Male", "Female", "Other"], label="Character Gender")
-            personality_input = gr.Dropdown(
-                choices=["Heroic", "Sarcastic", "Optimistic", "Empathetic"],
-                label="Character Personality"
-            )
-            backstory_input = gr.Textbox(label="Character Backstory", placeholder="Enter backstory")
-
-            create_button = gr.Button("Create Character")
-            create_output = gr.Textbox(label="Output", interactive=False)
-            character_selector = gr.Dropdown(choices=[], label="Select Character")
-
-            # Update the dropdown after character creation
-            def create_and_update(name, age, gender, personality, backstory):
-                output_message, updated_character_list = create_character(name, age, gender, personality, backstory)
-                return output_message, gr.update(choices=updated_character_list)
-
-            create_button.click(
-                create_and_update, 
-                inputs=[name_input, age_input, gender_input, personality_input, backstory_input], 
-                outputs=[create_output, character_selector]
-            )
-
-        # Chat UI
-        with gr.Tab("Chat"):
-            chat_box = gr.Chatbot(label="Chat History")
-            message_input = gr.Textbox(label="Your Message", placeholder="Type a message...")
-
-            send_button = gr.Button("Send Message")
-
-            # Define the chat interaction
-            def chat_and_clear(character_name, message, history):
-                history, response = chat(character_name, message, history)
-                return history, ""
-
-            send_button.click(chat_and_clear, 
-                              inputs=[character_selector, message_input, chat_box], 
-                              outputs=[chat_box, message_input])
-
-    return demo
-
-# Run the application
-demo = build_interface()
+        return system_message_selector(choice)
+
+# ChatInterface with dynamic system message and file input
+demo = gr.ChatInterface(
+    respond,
+    additional_inputs=[
+        system_message_radio,
+        file_upload,
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (nucleus sampling)",
+        ),
+    ],
+)
 
 if __name__ == "__main__":
     demo.launch()