feat: Add OpenAI API key input option in UI

- Add API key configuration section in Settings accordion
- Implement password-protected OpenAI API key input field
- Add real-time API status display and connection testing
- Enable users to use personal OpenAI quota instead of shared limits
- Add dynamic API key validation and error handling
- Implement custom autocomplete instance creation for user keys
- Update AutoCompleteApp class with API key management methods
- Modify main function to allow startup without pre-configured keys
- Add comprehensive user documentation for API key feature
- Enhance user experience with real-time status updates

This allows users to enter their own OpenAI API key directly in the interface,
avoiding rate limits and using their personal quota while maintaining security
by not storing keys permanently.

app.py

@@ -24,6 +24,8 @@ class AutoCompleteApp:
     def __init__(self):
         self.last_request_time = 0
         self.current_suggestions = []
+        self.user_api_key = None
+        self.custom_autocomplete = None
 
     def get_suggestions(
         self, text: str, context: str, output_tokens: int = 150, user_context: str = ""
@@ -87,8 +89,13 @@ class AutoCompleteApp:
                     f"⚠️ Text too long (max {settings.MAX_INPUT_LENGTH} characters)",
                 )
 
+            # Use the active autocomplete instance (user's custom or default)
+            active_autocomplete = self.get_active_autocomplete()
+
             # Create a temporary autocomplete instance with custom prompts
-            temp_autocomplete = SmartAutoComplete(settings)
+            temp_autocomplete = SmartAutoComplete(
+                active_autocomplete.settings if active_autocomplete else settings
+            )
             if custom_prompts:
                 temp_autocomplete.CONTEXT_PROMPTS = custom_prompts
 
@@ -134,6 +141,68 @@ class AutoCompleteApp:
             logger.error(f"Error inserting suggestion: {str(e)}")
             return current_text
 
+    def update_api_key(self, api_key: str) -> str:
+        """Update the OpenAI API key and reinitialize the autocomplete engine"""
+        try:
+            if not api_key or not api_key.strip():
+                self.user_api_key = None
+                self.custom_autocomplete = None
+                return "🔄 Reverted to default configuration"
+
+            # Validate the API key format
+            if not api_key.startswith("sk-"):
+                return "❌ Invalid API key format. OpenAI keys start with 'sk-'"
+
+            # Create a custom settings object with the user's API key
+            from config.settings import AppSettings
+
+            custom_settings = AppSettings()
+            custom_settings.OPENAI_API_KEY = api_key.strip()
+
+            # Create a new autocomplete instance with the custom settings
+            self.custom_autocomplete = SmartAutoComplete(custom_settings)
+            self.user_api_key = api_key.strip()
+
+            return "✅ API key updated successfully! Using your personal quota."
+
+        except Exception as e:
+            logger.error(f"Error updating API key: {str(e)}")
+            return f"❌ Error updating API key: {str(e)}"
+
+    def test_api_connection(self, api_key: str = None) -> str:
+        """Test the API connection with the current or provided key"""
+        try:
+            # Use custom autocomplete if user has provided a key, otherwise use default
+            test_autocomplete = (
+                self.custom_autocomplete if self.user_api_key else autocomplete
+            )
+
+            if api_key and api_key.strip():
+                # Test with the provided key
+                from config.settings import AppSettings
+
+                test_settings = AppSettings()
+                test_settings.OPENAI_API_KEY = api_key.strip()
+                test_autocomplete = SmartAutoComplete(test_settings)
+
+            # Test with a simple completion
+            test_result = test_autocomplete.get_suggestions(
+                text="Hello, this is a test", context="linkedin", max_tokens=10
+            )
+
+            if test_result and len(test_result) > 0:
+                return "✅ API connection successful!"
+            else:
+                return "❌ API connection failed - no response received"
+
+        except Exception as e:
+            logger.error(f"API connection test failed: {str(e)}")
+            return f"❌ API connection test failed: {str(e)}"
+
+    def get_active_autocomplete(self):
+        """Get the currently active autocomplete instance"""
+        return self.custom_autocomplete if self.user_api_key else autocomplete
+
 
 def create_interface():
     """Create and configure the Gradio interface"""
@@ -175,6 +244,8 @@ def create_interface():
         **Intelligent text completion powered by AI**
 
         Choose your context, enter your text, and click submit to get AI-powered completions! ✨
+
+        💡 **Tip**: Add your own OpenAI API key in Settings to use your personal quota and avoid rate limits.
         """)
 
         with gr.Row():
@@ -214,6 +285,31 @@ def create_interface():
 
                 # Settings
                 with gr.Accordion("⚙️ Settings", open=False):
+                    # API Key Configuration
+                    with gr.Group():
+                        gr.Markdown("### 🔑 API Configuration")
+                        openai_key_input = gr.Textbox(
+                            label="OpenAI API Key (Optional)",
+                            placeholder="sk-... (Enter your OpenAI API key to use your own quota)",
+                            type="password",
+                            value="",
+                            info="Your API key is only used for this session and not stored permanently.",
+                        )
+
+                        api_status = gr.Textbox(
+                            label="API Status",
+                            value="Using default configuration"
+                            if settings.OPENAI_API_KEY
+                            else "No API key configured",
+                            interactive=False,
+                            lines=1,
+                        )
+
+                        test_api_btn = gr.Button("🧪 Test API Connection", size="sm")
+
+                    gr.Markdown("---")
+
+                    # Output Settings
                     output_length = gr.Slider(
                         minimum=50,
                         maximum=500,
@@ -341,6 +437,16 @@ def create_interface():
             )
 
         # Event handlers
+        def update_api_key(api_key):
+            """Handle API key updates"""
+            status = app_instance.update_api_key(api_key)
+            return status
+
+        def test_api_connection(api_key):
+            """Handle API connection testing"""
+            status = app_instance.test_api_connection(api_key)
+            return status
+
         def update_suggestions(
             text,
             context,
@@ -394,6 +500,15 @@ def create_interface():
             copy_update = gr.update(visible=copy_visible, value=copy_text)
             return status, copy_update
 
+        # API Key event handlers
+        openai_key_input.change(
+            fn=update_api_key, inputs=[openai_key_input], outputs=[api_status]
+        )
+
+        test_api_btn.click(
+            fn=test_api_connection, inputs=[openai_key_input], outputs=[api_status]
+        )
+
         # Submit button handler
         submit_btn.click(
             fn=update_suggestions,
@@ -417,15 +532,17 @@ def create_interface():
         ---
         
         ### 🎮 How to Use:
-        1. **Select your context** (Email, Creative, or LinkedIn)
-        2. **Add context information** (optional) - background info, references, or previous context
-        3. **Enter your text** in the main text area
-        4. **Adjust output length** (50-500 tokens) in settings
-        5. **Customize prompts** (optional) - edit AI prompts in "Edit Context Prompts" section
-        6. **Click "Get Suggestions"** to generate completions
-        7. **Copy from the generated text box** (Select All + Ctrl+C/Cmd+C)
+        1. **Add your API key** (optional) - Enter your OpenAI API key in Settings to use your own quota
+        2. **Select your context** (Email, Creative, or LinkedIn)
+        3. **Add context information** (optional) - background info, references, or previous context
+        4. **Enter your text** in the main text area
+        5. **Adjust output length** (50-500 tokens) in settings
+        6. **Customize prompts** (optional) - edit AI prompts in "Edit Context Prompts" section
+        7. **Click "Get Suggestions"** to generate completions
+        8. **Copy from the generated text box** (Select All + Ctrl+C/Cmd+C)
 
         ### 🌟 Pro Tips:
+        - **API Key**: Add your own OpenAI API key to use your personal quota and avoid rate limits
         - **Context Window**: Add background info, previous conversations, or references to improve suggestions
         - **Email**: Try starting with "Dear..." or "I hope..." + add meeting context
         - **Creative**: Start with "Once upon a time..." + add story background
@@ -450,12 +567,15 @@ def create_interface():
 def main():
     """Main function to run the application"""
     try:
-        # Check API configuration
+        # Check API configuration - now optional since users can provide their own keys
         if not settings.validate_api_keys():
-            logger.error("No valid API keys found. Please configure your API keys.")
-            print("❌ Error: No valid API keys configured!")
-            print("Please set OPENAI_API_KEY or ANTHROPIC_API_KEY in your .env file")
-            return
+            logger.warning(
+                "No default API keys found. Users can provide their own keys in the UI."
+            )
+            print("⚠️  No default API keys configured.")
+            print("Users can enter their own OpenAI API key in the Settings section.")
+        else:
+            logger.info("Default API keys found and validated.")
 
         logger.info("Starting Smart Auto-Complete application...")