Update app.py

app.py

@@ -9,12 +9,78 @@ import re
 import gradio as gr
 import groq
 from groq import Groq
+import io
 
+import soundfile as sf
 
 # setup groq 
 
 client = Groq(api_key=os.environ.get("Groq_Api_Key"))
 
+
+
+
+
+
+def transcribe_audio(audio):
+    if audio is None:
+        return ""
+    
+    client = groq.Client(api_key=os.environ.get("Groq_Api_Key"))
+    
+    # Convert audio to the format expected by the model
+    # The model supports mp3, mp4, mpeg, mpga, m4a, wav, and webm file types 
+    audio_data = audio[1]  # Get the numpy array from the tuple
+    buffer = io.BytesIO()
+    sf.write(buffer, audio_data, audio[0], format='wav')
+    buffer.seek(0)
+
+    bytes_audio = io.BytesIO()
+    np.save(bytes_audio, audio_data)
+    bytes_audio.seek(0)
+
+    try:
+        # Use Distil-Whisper English powered by Groq for transcription
+        completion = client.audio.transcriptions.create(
+            model="distil-whisper-large-v3-en",
+            file=("audio.wav", buffer),
+            response_format="text"
+        )
+        return completion
+    except Exception as e:
+        return f"Error in transcription: {str(e)}"
+
+def generate_response(transcription, api_key):
+    if not transcription:
+        return "No transcription available. Please try speaking again."
+    
+    client = groq.Client(api_key=api_key)
+    
+    try:
+        # Use Llama 3 70B powered by Groq for text generation
+        completion = client.chat.completions.create(
+            model="llama3-70b-8192",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": transcription}
+            ],
+        )
+        return completion.choices[0].message.content
+    except Exception as e:
+        return f"Error in response generation: {str(e)}"
+
+def process_audio(audio, api_key):
+    if not api_key:
+        return "Please enter your Groq API key.", "API key is required."
+    transcription = transcribe_audio(audio, api_key)
+    response = generate_response(transcription, api_key)
+    return transcription, response
+
+
+
+
+
+
 def handle_groq_error(e, model_name):
     error_data = e.args[0]
     
@@ -359,7 +425,7 @@ def translate_audio(audio_file_path, model, prompt):
             handle_groq_error(e, model)
             
 
-with gr.Blocks() as interface:
+with gr.Blocks(theme="Hev832/niceandsimple") as interface:
     gr.Markdown(
         """
     # Groq API UI
@@ -430,61 +496,81 @@ with gr.Blocks() as interface:
 
         
         with gr.TabItem("LLMs"):
-            with gr.Row():
-                with gr.Column(scale=1, min_width=250):
-                    model = gr.Dropdown(
-                        choices=[
-                            "llama3-70b-8192",
-                            "llama3-8b-8192",
-                            "mixtral-8x7b-32768",
-                            "gemma-7b-it",
-                            "gemma2-9b-it",
-                        ],
-                        value="llama3-70b-8192",
-                        label="Model",
-                    )
-                    temperature = gr.Slider(
-                        minimum=0.0,
-                        maximum=1.0,
-                        step=0.01,
-                        value=0.5,
-                        label="Temperature",
-                        info="Controls diversity of the generated text. Lower is more deterministic, higher is more creative.",
-                    )
-                    max_tokens = gr.Slider(
-                        minimum=1,
-                        maximum=8192,
-                        step=1,
-                        value=4096,
-                        label="Max Tokens",
-                        info="The maximum number of tokens that the model can process in a single response.<br>Maximums: 8k for gemma 7b it, gemma2 9b it, llama 7b & 70b, 32k for mixtral 8x7b.",
-                    )
-                    top_p = gr.Slider(
-                        minimum=0.0,
-                        maximum=1.0,
-                        step=0.01,
-                        value=0.5,
-                        label="Top P",
-                        info="A method of text generation where a model will only consider the most probable next tokens that make up the probability p.",
-                    )
-                    seed = gr.Number(
-                        precision=0, value=42, label="Seed", info="A starting point to initiate generation, use 0 for random"
-                    )
-                    model.change(update_max_tokens, inputs=[model], outputs=max_tokens)
-                with gr.Column(scale=1, min_width=400):
-                    chatbot = gr.ChatInterface(
-                        fn=generate_response,
-                        chatbot=None,
-                        additional_inputs=[
-                            model,
-                            temperature,
-                            max_tokens,
-                            top_p,
-                            seed,
-                        ],
-                    )
-                    model.change(update_max_tokens, inputs=[model], outputs=max_tokens)
-        
+            with gr.Tab("Chat"):
+                with gr.Row():
+                    with gr.Column(scale=1, min_width=250):
+                        model = gr.Dropdown(
+                            choices=[
+                                "llama3-70b-8192",
+                                "llama3-8b-8192",
+                                "mixtral-8x7b-32768",
+                                "gemma-7b-it",
+                                "gemma2-9b-it",
+                            ],
+                            value="llama3-70b-8192",
+                            label="Model",
+                        )
+                        temperature = gr.Slider(
+                            minimum=0.0,
+                            maximum=1.0,
+                            step=0.01,
+                            value=0.5,
+                            label="Temperature",
+                            info="Controls diversity of the generated text. Lower is more deterministic, higher is more creative.",
+                        )
+                        max_tokens = gr.Slider(
+                            minimum=1,
+                            maximum=8192,
+                            step=1,
+                            value=4096,
+                            label="Max Tokens",
+                            info="The maximum number of tokens that the model can process in a single response.<br>Maximums: 8k for gemma 7b it, gemma2 9b it, llama 7b & 70b, 32k for mixtral 8x7b.",
+                        )
+                        top_p = gr.Slider(
+                            minimum=0.0,
+                            maximum=1.0,
+                            step=0.01,
+                            value=0.5,
+                            label="Top P",
+                            info="A method of text generation where a model will only consider the most probable next tokens that make up the probability p.",
+                        )
+                        seed = gr.Number(
+                            precision=0, value=42, label="Seed", info="A starting point to initiate generation, use 0 for random"
+                        )
+                        model.change(update_max_tokens, inputs=[model], outputs=max_tokens)
+                        with gr.Column(scale=1, min_width=400):
+                            chatbot = gr.ChatInterface(
+                                fn=generate_response,
+                                chatbot=None,
+                                additional_inputs=[
+                                    model,
+                                    temperature,
+                                    max_tokens,
+                                    top_p,
+                                    seed,
+                                ],
+                            )
+                            model.change(
+                                update_max_tokens, 
+                                inputs=[
+                                    model,
+                                ],
+                                outputs=max_tokens,
+                            )
+            with gr.Tab("Voice-Powered AI Assistant"):
+                with gr.Row():
+                    audio_input = gr.Audio(label="Speak!", type="numpy")
+                    
+                with gr.Row():
+                    transcription_output = gr.Textbox(label="Transcription")
+                    response_output = gr.Textbox(label="AI Assistant Response")
+                submit_button = gr.Button("Process", variant="primary")
+
+                submit_button.click(
+                    process_audio,
+                    inputs=[audio_input, api_key_input],
+                    outputs=[transcription_output, response_output]
+                )
                     
                     
 interface.launch(share=True)