import gradio as gr import os import re from groq import Groq def validate_api_key(api_key): """Validate if the API key has the correct format.""" # Basic format check for Groq API keys (they typically start with 'gsk_') if not api_key.strip(): return False, "API key cannot be empty" if not api_key.startswith("gsk_"): return False, "Invalid API key format. Groq API keys typically start with 'gsk_'" return True, "API key looks valid" def test_api_connection(api_key): """Test the API connection with a minimal request.""" try: client = Groq(api_key=api_key) # Making a minimal API call to test the connection client.chat.completions.create( model="llama3-70b-8192", messages=[{"role": "user", "content": "test"}], max_tokens=5 ) return True, "API connection successful" except Exception as e: # Handle all exceptions since Groq might not expose specific error types if "authentication" in str(e).lower() or "api key" in str(e).lower(): return False, "Authentication failed: Invalid API key" else: return False, f"Error connecting to Groq API: {str(e)}" def chat_with_groq(api_key, model, user_message, temperature, max_tokens, top_p, chat_history): """ Interact with the Groq API to get a response. """ # Validate API key is_valid, message = validate_api_key(api_key) if not is_valid: return chat_history + [[user_message, f"Error: {message}"]] # Test API connection connection_valid, connection_message = test_api_connection(api_key) if not connection_valid: return chat_history + [[user_message, f"Error: {connection_message}"]] try: # Format history for the API messages = [] for human, assistant in chat_history: messages.append({"role": "user", "content": human}) messages.append({"role": "assistant", "content": assistant}) # Add the current message messages.append({"role": "user", "content": user_message}) # Create the client and make the API call client = Groq(api_key=api_key) response = client.chat.completions.create( model=model, messages=messages, temperature=temperature, max_tokens=max_tokens, top_p=top_p ) # Extract the response text assistant_response = response.choices[0].message.content # Return updated chat history return chat_history + [[user_message, assistant_response]] except Exception as e: error_message = f"Error: {str(e)}" return chat_history + [[user_message, error_message]] def clear_conversation(): """Clear the conversation history.""" return [] # Define available models models = [ "llama3-70b-8192", "llama3-8b-8192", "mistral-saba-24b", "gemma2-9b-it", "allam-2-7b" ] # Create the Gradio interface with gr.Blocks(title="Groq AI Chat Interface") as app: gr.Markdown("# Groq AI Chat Interface") # New model information accordion with gr.Accordion("ℹ️ Model Information - Learn about available models", open=False): gr.Markdown(""" ### Available Models and Use Cases **llama3-70b-8192** - Meta's most powerful language model - 70 billion parameters with 8192 token context window - Best for: Complex reasoning, sophisticated content generation, creative writing, and detailed analysis - Optimal for users needing the highest quality AI responses **llama3-8b-8192** - Lighter version of Llama 3 - 8 billion parameters with 8192 token context window - Best for: Faster responses, everyday tasks, simpler queries - Good balance between performance and speed **mistral-saba-24b** - Mistral AI's advanced model - 24 billion parameters - Best for: High-quality reasoning, code generation, and structured outputs - Excellent for technical and professional use cases **gemma2-9b-it** - Google's instruction-tuned model - 9 billion parameters - Best for: Following specific instructions, educational content, and general knowledge queries - Well-rounded performance for various tasks **allam-2-7b** - Specialized model from Aleph Alpha - 7 billion parameters - Best for: Multilingual support, concise responses, and straightforward Q&A - Good for international users and simpler applications *Note: Larger models generally provide higher quality responses but may take slightly longer to generate.* """) gr.Markdown("Enter your Groq API key to start chatting with AI models.") with gr.Row(): with gr.Column(scale=2): api_key_input = gr.Textbox( label="Groq API Key", placeholder="Enter your Groq API key (starts with gsk_)", type="password" ) with gr.Column(scale=1): test_button = gr.Button("Test API Connection") api_status = gr.Textbox(label="API Status", interactive=False) with gr.Row(): with gr.Column(): model_dropdown = gr.Dropdown( choices=models, label="Select Model", value="llama3-70b-8192" ) with gr.Row(): with gr.Column(): with gr.Accordion("Advanced Settings", open=False): temperature_slider = gr.Slider( minimum=0.0, maximum=1.0, value=0.7, step=0.01, label="Temperature (higher = more creative, lower = more focused)" ) max_tokens_slider = gr.Slider( minimum=256, maximum=8192, value=4096, step=256, label="Max Tokens (maximum length of response)" ) top_p_slider = gr.Slider( minimum=0.0, maximum=1.0, value=0.95, step=0.01, label="Top P (nucleus sampling probability threshold)" ) chatbot = gr.Chatbot(label="Conversation", height=500) with gr.Row(): message_input = gr.Textbox( label="Your Message", placeholder="Type your message here...", lines=3 ) with gr.Row(): submit_button = gr.Button("Send", variant="primary") clear_button = gr.Button("Clear Conversation") # Connect components with functions submit_button.click( fn=chat_with_groq, inputs=[ api_key_input, model_dropdown, message_input, temperature_slider, max_tokens_slider, top_p_slider, chatbot ], outputs=chatbot ).then( fn=lambda: "", inputs=None, outputs=message_input ) message_input.submit( fn=chat_with_groq, inputs=[ api_key_input, model_dropdown, message_input, temperature_slider, max_tokens_slider, top_p_slider, chatbot ], outputs=chatbot ).then( fn=lambda: "", inputs=None, outputs=message_input ) clear_button.click( fn=clear_conversation, inputs=None, outputs=chatbot ) test_button.click( fn=test_api_connection, inputs=[api_key_input], outputs=[api_status] ) # Launch the app if __name__ == "__main__": app.launch(share=False)