Create app.py

app.py

@@ -0,0 +1,368 @@
+import gradio as gr
+import openai
+import json
+import os
+import time
+from typing import List, Tuple, Optional
+import requests
+from datetime import datetime
+
+class ChatbotManager:
+    def __init__(self):
+        self.conversation_history = []
+        self.current_api_key = None
+        self.current_model = "gpt-3.5-turbo"
+        self.system_prompt = "You are a helpful AI assistant. Respond in a friendly and informative manner."
+        self.max_tokens = 150
+        self.temperature = 0.7
+        
+    def set_api_key(self, api_key: str) -> str:
+        """Set the OpenAI API key"""
+        if not api_key.strip():
+            return "❌ Please enter a valid API key"
+        
+        self.current_api_key = api_key.strip()
+        openai.api_key = self.current_api_key
+        
+        # Test the API key
+        try:
+            openai.Model.list()
+            return "✅ API key validated successfully!"
+        except Exception as e:
+            return f"❌ Invalid API key: {str(e)}"
+    
+    def update_settings(self, model: str, system_prompt: str, max_tokens: int, temperature: float) -> str:
+        """Update chatbot settings"""
+        self.current_model = model
+        self.system_prompt = system_prompt
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+        return f"✅ Settings updated: Model={model}, Max Tokens={max_tokens}, Temperature={temperature}"
+    
+    def preprocess_data(self, data_text: str) -> str:
+        """Preprocess and integrate custom data into the system prompt"""
+        if not data_text.strip():
+            return "No custom data provided"
+        
+        # Add custom data to system prompt
+        self.system_prompt += f"\n\nAdditional Context:\n{data_text}"
+        return f"✅ Custom data integrated ({len(data_text)} characters)"
+    
+    def generate_response(self, user_input: str, history: List[Tuple[str, str]]) -> Tuple[str, List[Tuple[str, str]]]:
+        """Generate response using the selected LLM model"""
+        if not self.current_api_key:
+            return "❌ Please set your API key first!", history
+        
+        if not user_input.strip():
+            return "Please enter a message.", history
+        
+        try:
+            # Prepare conversation context
+            messages = [{"role": "system", "content": self.system_prompt}]
+            
+            # Add conversation history
+            for user_msg, assistant_msg in history:
+                messages.append({"role": "user", "content": user_msg})
+                messages.append({"role": "assistant", "content": assistant_msg})
+            
+            # Add current user input
+            messages.append({"role": "user", "content": user_input})
+            
+            # Generate response
+            response = openai.ChatCompletion.create(
+                model=self.current_model,
+                messages=messages,
+                max_tokens=self.max_tokens,
+                temperature=self.temperature,
+                n=1,
+                stop=None,
+            )
+            
+            assistant_response = response.choices[0].message.content.strip()
+            
+            # Update history
+            history.append((user_input, assistant_response))
+            
+            return assistant_response, history
+            
+        except Exception as e:
+            error_msg = f"❌ Error generating response: {str(e)}"
+            return error_msg, history
+    
+    def clear_conversation(self) -> Tuple[str, List[Tuple[str, str]]]:
+        """Clear conversation history"""
+        self.conversation_history = []
+        return "", []
+    
+    def export_conversation(self, history: List[Tuple[str, str]]) -> str:
+        """Export conversation history to JSON format"""
+        if not history:
+            return "No conversation to export"
+        
+        export_data = {
+            "timestamp": datetime.now().isoformat(),
+            "model": self.current_model,
+            "conversation": [
+                {"user": user_msg, "assistant": assistant_msg}
+                for user_msg, assistant_msg in history
+            ]
+        }
+        
+        filename = f"conversation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        
+        try:
+            with open(filename, 'w', encoding='utf-8') as f:
+                json.dump(export_data, f, indent=2, ensure_ascii=False)
+            return f"✅ Conversation exported to {filename}"
+        except Exception as e:
+            return f"❌ Export failed: {str(e)}"
+
+# Initialize chatbot manager
+chatbot = ChatbotManager()
+
+# Define available models
+AVAILABLE_MODELS = [
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-16k",
+    "gpt-4",
+    "gpt-4-32k",
+    "gpt-4-turbo-preview",
+    "gpt-4o",
+    "gpt-4o-mini"
+]
+
+def create_interface():
+    """Create the Gradio interface"""
+    
+    with gr.Blocks(title="LLM-Based Chatbot", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🤖 LLM-Based Conversational AI Chatbot
+        
+        This chatbot leverages powerful Language Models to provide intelligent conversations.
+        Enter your OpenAI API key to get started!
+        """)
+        
+        with gr.Tab("💬 Chat Interface"):
+            with gr.Row():
+                with gr.Column(scale=3):
+                    chatbot_interface = gr.Chatbot(
+                        label="Conversation",
+                        height=400,
+                        show_label=True,
+                        avatar_images=("👤", "🤖")
+                    )
+                    
+                    with gr.Row():
+                        user_input = gr.Textbox(
+                            placeholder="Type your message here...",
+                            scale=4,
+                            show_label=False
+                        )
+                        send_btn = gr.Button("Send", variant="primary", scale=1)
+                    
+                    with gr.Row():
+                        clear_btn = gr.Button("Clear Chat", variant="secondary")
+                        export_btn = gr.Button("Export Chat", variant="secondary")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🔧 Quick Settings")
+                    
+                    api_key_input = gr.Textbox(
+                        label="OpenAI API Key",
+                        placeholder="sk-...",
+                        type="password"
+                    )
+                    api_status = gr.Textbox(
+                        label="API Status",
+                        interactive=False,
+                        value="❌ No API key provided"
+                    )
+                    
+                    model_dropdown = gr.Dropdown(
+                        choices=AVAILABLE_MODELS,
+                        value="gpt-3.5-turbo",
+                        label="Model"
+                    )
+                    
+                    max_tokens_slider = gr.Slider(
+                        minimum=50,
+                        maximum=500,
+                        value=150,
+                        step=10,
+                        label="Max Tokens"
+                    )
+                    
+                    temperature_slider = gr.Slider(
+                        minimum=0.0,
+                        maximum=1.0,
+                        value=0.7,
+                        step=0.1,
+                        label="Temperature"
+                    )
+        
+        with gr.Tab("⚙️ Advanced Settings"):
+            gr.Markdown("### System Prompt Configuration")
+            system_prompt_input = gr.Textbox(
+                label="System Prompt",
+                value="You are a helpful AI assistant. Respond in a friendly and informative manner.",
+                lines=5,
+                placeholder="Enter custom system prompt..."
+            )
+            
+            gr.Markdown("### 📊 Custom Data Integration")
+            custom_data_input = gr.Textbox(
+                label="Custom Training Data",
+                lines=10,
+                placeholder="Enter custom data, FAQs, or domain-specific information..."
+            )
+            
+            with gr.Row():
+                update_settings_btn = gr.Button("Update Settings", variant="primary")
+                integrate_data_btn = gr.Button("Integrate Custom Data", variant="secondary")
+            
+            settings_status = gr.Textbox(
+                label="Settings Status",
+                interactive=False
+            )
+        
+        with gr.Tab("📋 Usage Guide"):
+            gr.Markdown("""
+            ## 🚀 Getting Started
+            
+            ### 1. **Set Up API Key**
+            - Obtain an OpenAI API key from [OpenAI Platform](https://platform.openai.com/)
+            - Enter your API key in the "OpenAI API Key" field
+            - Wait for the green checkmark confirmation
+            
+            ### 2. **Configure Settings**
+            - **Model**: Choose from available GPT models
+            - **Max Tokens**: Control response length (50-500)
+            - **Temperature**: Adjust creativity (0.0 = focused, 1.0 = creative)
+            
+            ### 3. **Advanced Customization**
+            - **System Prompt**: Define the AI's personality and behavior
+            - **Custom Data**: Add domain-specific information or FAQs
+            
+            ### 4. **Chat Features**
+            - Type messages and get intelligent responses
+            - Clear conversation history anytime
+            - Export chat history as JSON
+            
+            ## 🛠️ Technical Features
+            
+            - **Multi-model support**: GPT-3.5, GPT-4, and variants
+            - **Conversation memory**: Maintains context throughout the session
+            - **Custom data integration**: Enhance responses with your own data
+            - **Export functionality**: Save conversations for later analysis
+            - **Real-time validation**: API key and settings verification
+            
+            ## 💡 Use Cases
+            
+            - **Customer Support**: Create domain-specific support chatbots
+            - **Education**: Build tutoring assistants with custom curriculum
+            - **Business**: Develop FAQ bots with company-specific information
+            - **Research**: Analyze conversations and response patterns
+            """)
+        
+        # Event handlers
+        def handle_api_key(api_key):
+            status = chatbot.set_api_key(api_key)
+            return status
+        
+        def handle_chat(user_input, history):
+            if not user_input.strip():
+                return history, ""
+            
+            response, updated_history = chatbot.generate_response(user_input, history)
+            return updated_history, ""
+        
+        def handle_settings_update(model, system_prompt, max_tokens, temperature):
+            status = chatbot.update_settings(model, system_prompt, max_tokens, temperature)
+            return status
+        
+        def handle_data_integration(custom_data):
+            status = chatbot.preprocess_data(custom_data)
+            return status
+        
+        def handle_clear():
+            return chatbot.clear_conversation()
+        
+        def handle_export(history):
+            return chatbot.export_conversation(history)
+        
+        # Connect events
+        api_key_input.change(
+            handle_api_key,
+            inputs=[api_key_input],
+            outputs=[api_status]
+        )
+        
+        send_btn.click(
+            handle_chat,
+            inputs=[user_input, chatbot_interface],
+            outputs=[chatbot_interface, user_input]
+        )
+        
+        user_input.submit(
+            handle_chat,
+            inputs=[user_input, chatbot_interface],
+            outputs=[chatbot_interface, user_input]
+        )
+        
+        update_settings_btn.click(
+            handle_settings_update,
+            inputs=[model_dropdown, system_prompt_input, max_tokens_slider, temperature_slider],
+            outputs=[settings_status]
+        )
+        
+        integrate_data_btn.click(
+            handle_data_integration,
+            inputs=[custom_data_input],
+            outputs=[settings_status]
+        )
+        
+        clear_btn.click(
+            handle_clear,
+            outputs=[user_input, chatbot_interface]
+        )
+        
+        export_btn.click(
+            handle_export,
+            inputs=[chatbot_interface],
+            outputs=[settings_status]
+        )
+    
+    return demo
+
+# Requirements and setup instructions
+def print_setup_instructions():
+    """Print setup instructions"""
+    print("""
+    🤖 LLM-Based Chatbot Setup Instructions
+    =====================================
+    
+    📦 Required Dependencies:
+    pip install gradio openai requests
+    
+    🔑 API Key Setup:
+    1. Visit https://platform.openai.com/
+    2. Create an account and generate an API key
+    3. Enter the API key in the interface
+    
+    🚀 Running the Application:
+    python app.py
+    
+    📂 Files Created:
+    - conversation_YYYYMMDD_HHMMSS.json (exported chats)
+    """)
+
+if __name__ == "__main__":
+    print_setup_instructions()
+    
+    # Create and launch the interface
+    demo = create_interface()
+    
+    # Launch with custom settings
+    demo.launch(
+        share=True            
+    )