Upload 11 files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AI Chat Application
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.py

@@ -10,138 +10,28 @@ import sys
 import json
 import logging
 import time
-from typing import Optional, Dict, Any, Generator
+from typing import Optional, Dict, Any, Generator, List
 import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
 import gradio as gr
 from fastapi import FastAPI, HTTPException, Response
 from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
 import redis
 import asyncio
 import threading
 from threading import Thread
 
+# Import utility modules
+from utils.model_utils import ModelManager
+from utils.conversation import ConversationManager
+from utils.api_compat import ChatRequest, ChatResponse, convert_openai_request_to_model_input, create_openai_response, format_messages_for_frontend
+
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Model configuration
-MODEL_NAME = "Qwen/Qwen3-Coder-30B-A3B-Instruct"
-DEFAULT_MAX_TOKENS = 1024
-DEFAULT_TEMPERATURE = 0.7
-
-class ConversationManager:
-    """Manage conversation history and caching"""
-    
-    def __init__(self):
-        self.redis_client = None
-        try:
-            self.redis_client = redis.Redis(host='localhost', port=6379, db=0)
-            self.redis_client.ping()
-        except:
-            logger.warning("Redis not available, using in-memory storage")
-            self.conversations = {}
-    
-    def save_conversation(self, conv_id: str, messages: list) -> None:
-        """Save conversation to cache"""
-        try:
-            if self.redis_client:
-                self.redis_client.setex(conv_id, 86400, json.dumps(messages))  # 24 hours expiry
-            else:
-                self.conversations[conv_id] = messages
-        except Exception as e:
-            logger.error(f"Error saving conversation: {e}")
-    
-    def load_conversation(self, conv_id: str) -> list:
-        """Load conversation from cache"""
-        try:
-            if self.redis_client:
-                data = self.redis_client.get(conv_id)
-                if data:
-                    return json.loads(data)
-            else:
-                return self.conversations.get(conv_id, [])
-        except Exception as e:
-            logger.error(f"Error loading conversation: {e}")
-        return []
-
-class ModelManager:
-    """Manage Qwen model loading and inference"""
-    
-    def __init__(self):
-        self.model = None
-        self.tokenizer = None
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.load_model()
-    
-    def load_model(self) -> None:
-        """Load the Qwen model"""
-        try:
-            logger.info(f"Loading model {MODEL_NAME} on {self.device}")
-            self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-            self.model = AutoModelForCausalLM.from_pretrained(
-                MODEL_NAME,
-                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
-                low_cpu_mem_usage=True,
-                device_map="auto"
-            )
-            logger.info("Model loaded successfully")
-        except Exception as e:
-            logger.error(f"Error loading model: {e}")
-            raise
-    
-    def generate_response(self, prompt: str, max_tokens: int = DEFAULT_MAX_TOKENS, temperature: float = DEFAULT_TEMPERATURE) -> str:
-        """Generate response from the model"""
-        try:
-            inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
-            
-            # Generate without streaming for simple response
-            generated = self.model.generate(
-                **inputs,
-                max_new_tokens=max_tokens,
-                temperature=temperature,
-                do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id
-            )
-            
-            response = self.tokenizer.decode(generated[0], skip_special_tokens=True)
-            # Remove the prompt from the response
-            response = response[len(prompt):].strip()
-            return response
-        except Exception as e:
-            logger.error(f"Error generating response: {e}")
-            raise
-    
-    def generate_streaming_response(self, prompt: str, max_tokens: int = DEFAULT_MAX_TOKENS, temperature: float = DEFAULT_TEMPERATURE) -> Generator[str, None, None]:
-        """Generate streaming response from the model"""
-        try:
-            inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
-            
-            # Create streamer for streaming response
-            streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True)
-            
-            # Start generation in a separate thread
-            generation_kwargs = dict(
-                inputs,
-                streamer=streamer,
-                max_new_tokens=max_tokens,
-                temperature=temperature,
-                do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id
-            )
-            
-            thread = Thread(target=self.model.generate, kwargs=generation_kwargs)
-            thread.start()
-            
-            # Yield tokens as they are generated
-            for new_text in streamer:
-                yield new_text
-                
-        except Exception as e:
-            logger.error(f"Error generating streaming response: {e}")
-            yield f"Error: {str(e)}"
-
 # Initialize managers
 conversation_manager = ConversationManager()
 model_manager = ModelManager()
@@ -149,64 +39,34 @@ model_manager = ModelManager()
 # FastAPI app for OPENAI API compatibility
 app = FastAPI(title="AI Chat API", description="OPENAI API compatible interface for Qwen model")
 
-class ChatMessage(BaseModel):
-    role: str
-    content: str
-
-class ChatRequest(BaseModel):
-    messages: list[ChatMessage]
-    model: str = MODEL_NAME
-    max_tokens: Optional[int] = DEFAULT_MAX_TOKENS
-    temperature: Optional[float] = DEFAULT_TEMPERATURE
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-class ChatResponse(BaseModel):
-    id: str
-    object: str = "chat.completion"
-    created: int
-    model: str
-    choices: list
-    usage: Dict[str, int]
+# Mount static files
+app.mount("/public", StaticFiles(directory="public"), name="public")
 
 @app.post("/v1/chat/completions", response_model=ChatResponse)
 async def chat_completion(request: ChatRequest):
     """OPENAI API compatible chat completion endpoint"""
     try:
         # Convert messages to prompt
-        prompt = ""
-        for msg in request.messages:
-            if msg.role == "system":
-                prompt += f"System: {msg.content}\n"
-            elif msg.role == "user":
-                prompt += f"User: {msg.content}\n"
-            elif msg.role == "assistant":
-                prompt += f"Assistant: {msg.content}\n"
+        prompt = convert_openai_request_to_model_input(request)
         
         # Generate response
         response_text = model_manager.generate_response(
             prompt,
-            request.max_tokens or DEFAULT_MAX_TOKENS,
-            request.temperature or DEFAULT_TEMPERATURE
+            request.max_tokens or 1024,
+            request.temperature or 0.7
         )
         
         # Return in OPENAI format
-        return ChatResponse(
-            id="chatcmpl-" + str(hash(prompt))[:10],
-            created=int(time.time()),
-            model=request.model,
-            choices=[{
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": response_text
-                },
-                "finish_reason": "stop"
-            }],
-            usage={
-                "prompt_tokens": len(prompt.split()),
-                "completion_tokens": len(response_text.split()),
-                "total_tokens": len(prompt.split()) + len(response_text.split())
-            }
-        )
+        return create_openai_response(response_text, request)
     except Exception as e:
         logger.error(f"Error in chat completion: {e}")
         raise HTTPException(status_code=500, detail=str(e))
@@ -262,30 +122,12 @@ gradio_interface = gr.ChatInterface(
     cache_examples=False
 )
 
-# Serve static files
-from fastapi.staticfiles import StaticFiles
+# Mount Gradio interface
+app.mount("/", gradio_interface.app)
 
-# Combine FastAPI and Gradio
+# Run the app
 def launch_app():
     """Launch the combined FastAPI and Gradio app"""
-    from fastapi.middleware.cors import CORSMiddleware
-    
-    # Add CORS middleware
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-    
-    # Mount static files
-    app.mount("/public", StaticFiles(directory="public"), name="public")
-    
-    # Mount Gradio interface
-    app.mount("/", gradio_interface.app)
-    
-    # Run the app
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
 

public/app.js

@@ -1,228 +1,164 @@
-// AI Chat Application JavaScript Logic
-// This file contains the React component for the chat interface
-
-// Main App component
-function App() {
-  const [messages, setMessages] = React.useState([]);
-  const [inputValue, setInputValue] = React.useState('');
-  const [isLoading, setIsLoading] = React.useState(false);
-  const [darkMode, setDarkMode] = React.useState(false);
-  const messagesEndRef = React.useRef(null);
-
-  // Scroll to bottom of messages
-  const scrollToBottom = () => {
-    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
-  };
-
-  // Scroll to bottom when messages change
-  React.useEffect(() => {
-    scrollToBottom();
-  }, [messages]);
-
-  // Toggle dark mode
-  const toggleDarkMode = () => {
-    setDarkMode(!darkMode);
-    document.documentElement.classList.toggle('dark', !darkMode);
-  };
-
-  // Handle input change
-  const handleInputChange = (e) => {
-    setInputValue(e.target.value);
-  };
-
-  // Handle form submission
-  const handleSubmit = async (e) => {
-    e.preventDefault();
-    if (!inputValue.trim() || isLoading) return;
-
-    // Add user message to chat
-    const userMessage = { id: Date.now(), text: inputValue, sender: 'user' };
-    setMessages(prev => [...prev, userMessage]);
-    setInputValue('');
-    setIsLoading(true);
-
-    try {
-      // Add temporary AI message
-      const aiMessageId = Date.now() + 1;
-      setMessages(prev => [...prev, { id: aiMessageId, text: '', sender: 'ai', isLoading: true }]);
+// JavaScript logic for AI Chat Application
+
+// DOM elements
+const chatMessages = document.getElementById('chat-messages');
+const userInput = document.getElementById('user-input');
+const sendButton = document.getElementById('send-button');
+
+// Conversation history
+let conversationHistory = [];
+
+// Function to add a message to the chat
+function addMessage(sender, text) {
+  const messageDiv = document.createElement('div');
+  messageDiv.className = `message ${sender}`;
+  
+  const messageHeader = document.createElement('div');
+  messageHeader.className = 'message-header';
+  messageHeader.textContent = sender === 'user' ? 'You' : 'AI';
+  
+  const messageText = document.createElement('div');
+  messageText.className = 'message-text';
+  messageText.textContent = text;
+  
+  messageDiv.appendChild(messageHeader);
+  messageDiv.appendChild(messageText);
+  chatMessages.appendChild(messageDiv);
+  
+  // Scroll to bottom
+  chatMessages.scrollTop = chatMessages.scrollHeight;
+}
 
-      // Send request to backend
-      const response = await fetch('/chat', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          message: inputValue,
-          history: messages.filter(m => !m.isLoading).map(m => ({
-            role: m.sender === 'user' ? 'user' : 'assistant',
-            content: m.text
-          }))
-        })
-      });
+// Function to show loading indicator
+function showLoading() {
+  const loadingDiv = document.createElement('div');
+  loadingDiv.className = 'message ai';
+  loadingDiv.id = 'loading-message';
+  
+  const messageHeader = document.createElement('div');
+  messageHeader.className = 'message-header';
+  messageHeader.textContent = 'AI';
+  
+  const loadingIndicator = document.createElement('div');
+  loadingIndicator.className = 'loading';
+  
+  loadingDiv.appendChild(messageHeader);
+  loadingDiv.appendChild(loadingIndicator);
+  chatMessages.appendChild(loadingDiv);
+  
+  // Scroll to bottom
+  chatMessages.scrollTop = chatMessages.scrollHeight;
+}
 
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-      }
+// Function to hide loading indicator
+function hideLoading() {
+  const loadingMessage = document.getElementById('loading-message');
+  if (loadingMessage) {
+    loadingMessage.remove();
+  }
+}
 
-      // Process streaming response
+// Function to send message to backend
+async function sendMessage(message) {
+  try {
+    // Add user message to UI
+    addMessage('user', message);
+    
+    // Clear input
+    userInput.value = '';
+    
+    // Show loading indicator
+    showLoading();
+    
+    // Add user message to conversation history
+    conversationHistory.push({ role: 'user', content: message });
+    
+    // Send request to backend
+    const response = await fetch('/chat', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        message: message,
+        history: conversationHistory.slice(0, -1) // Exclude the current message
+      })
+    });
+    
+    // Hide loading indicator
+    hideLoading();
+    
+    if (response.ok) {
+      // Create AI message element
+      const aiMessageDiv = document.createElement('div');
+      aiMessageDiv.className = 'message ai';
+      
+      const messageHeader = document.createElement('div');
+      messageHeader.className = 'message-header';
+      messageHeader.textContent = 'AI';
+      
+      const messageText = document.createElement('div');
+      messageText.className = 'message-text';
+      messageText.id = 'ai-response';
+      
+      aiMessageDiv.appendChild(messageHeader);
+      aiMessageDiv.appendChild(messageText);
+      chatMessages.appendChild(aiMessageDiv);
+      
+      // Stream the response
       const reader = response.body.getReader();
       const decoder = new TextDecoder();
+      
       let aiResponse = '';
       
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
         
-        const chunk = decoder.decode(value);
+        const chunk = decoder.decode(value, { stream: true });
         aiResponse += chunk;
+        messageText.textContent = aiResponse;
         
-        // Update AI message with new content
-        setMessages(prev => prev.map(msg => 
-          msg.id === aiMessageId 
-            ? { ...msg, text: aiResponse, isLoading: false } 
-            : msg
-        ));
+        // Scroll to bottom
+        chatMessages.scrollTop = chatMessages.scrollHeight;
       }
-    } catch (error) {
-      console.error('Error sending message:', error);
-      setMessages(prev => prev.map(msg => 
-        msg.id === aiMessageId 
-          ? { ...msg, text: 'Sorry, I encountered an error. Please try again.', isLoading: false, error: true } 
-          : msg
-      ));
-    } finally {
-      setIsLoading(false);
+      
+      // Add AI response to conversation history
+      conversationHistory.push({ role: 'assistant', content: aiResponse });
+    } else {
+      // Handle error
+      addMessage('ai', 'Sorry, I encountered an error. Please try again.');
     }
-  };
-
-  // Copy message to clipboard
-  const copyToClipboard = (text) => {
-    navigator.clipboard.writeText(text).then(() => {
-      // Show success message (could be a toast notification)
-      console.log('Copied to clipboard');
-    }).catch(err => {
-      console.error('Failed to copy: ', err);
-    });
-  };
-
-  // Clear chat history
-  const clearChat = () => {
-    setMessages([]);
-  };
-
-  return (
-    <div className="chat-container">
-      {/* Header */}
-      <div className="chat-header flex justify-between items-center">
-        <h1 className="text-2xl font-bold">AI Chat with Qwen Coder</h1>
-        <div className="flex gap-2">
-          <button 
-            onClick={toggleDarkMode}
-            className="btn btn-secondary"
-            aria-label="Toggle dark mode"
-          >
-            {darkMode ? (
-              <i className="fas fa-sun"></i>
-            ) : (
-              <i className="fas fa-moon"></i>
-            )}
-          </button>
-          <button 
-            onClick={clearChat}
-            className="btn btn-secondary"
-            aria-label="Clear chat"
-          >
-            <i className="fas fa-trash"></i>
-          </button>
-        </div>
-      </div>
-
-      {/* Chat messages area */}
-      <div className="chat-messages">
-        {messages.length === 0 ? (
-          <div className="flex flex-col items-center justify-center h-full text-center">
-            <h2 className="text-2xl font-bold mb-4">Welcome to AI Chat</h2>
-            <p className="text-lg mb-8">Start a conversation with Qwen Coder by typing a message below</p>
-            <div className="grid grid-cols-1 md:grid-cols-2 gap-4 w-full max-w-2xl">
-              <div className="bg-gray-100 dark:bg-gray-800 p-4 rounded-lg">
-                <h3 className="font-bold mb-2">Examples</h3>
-                <ul className="text-left">
-                  <li>"Explain quantum computing in simple terms"</li>
-                  <li>"Write a Python function to calculate Fibonacci numbers"</li>
-                  <li>"How do I make an HTTP request in JavaScript?"</li>
-                </ul>
-              </div>
-              <div className="bg-gray-100 dark:bg-gray-800 p-4 rounded-lg">
-                <h3 className="font-bold mb-2">Capabilities</h3>
-                <ul className="text-left">
-                  <li>Remembers previous conversation</li>
-                  <li>Understands complex instructions</li>
-                  <li>Generates code and explanations</li>
-                </ul>
-              </div>
-            </div>
-          </div>
-        ) : (
-          messages.map((message) => (
-            <div 
-              key={message.id} 
-              className={`message-bubble relative ${message.sender === 'user' ? 'user' : 'ai'}`}
-            >
-              {message.sender === 'ai' && !message.isLoading && (
-                <button 
-                  onClick={() => copyToClipboard(message.text)}
-                  className="copy-button"
-                  aria-label="Copy message"
-                >
-                  <i className="fas fa-copy"></i>
-                </button>
-              )}
-              {message.isLoading ? (
-                <div className="typing-indicator">
-                  <div className="typing-dot"></div>
-                  <div className="typing-dot"></div>
-                  <div className="typing-dot"></div>
-                </div>
-              ) : (
-                <div>{message.text}</div>
-              )}
-            </div>
-          ))
-        )}
-        <div ref={messagesEndRef} />
-      </div>
-
-      {/* Input area */}
-      <div className="chat-input-area">
-        <form onSubmit={handleSubmit} className="flex gap-2">
-          <input
-            type="text"
-            value={inputValue}
-            onChange={handleInputChange}
-            placeholder="Type your message here..."
-            className="chat-input"
-            disabled={isLoading}
-          />
-          <button 
-            type="submit" 
-            className="btn"
-            disabled={isLoading || !inputValue.trim()}
-          >
-            {isLoading ? (
-              <i className="fas fa-spinner fa-spin"></i>
-            ) : (
-              <i className="fas fa-paper-plane"></i>
-            )}
-          </button>
-        </form>
-        <div className="text-xs text-center mt-2 text-gray-500 dark:text-gray-400">
-          Qwen Coder can make mistakes. Consider checking important information.
-        </div>
-      </div>
-    </div>
-  );
+  } catch (error) {
+    // Hide loading indicator
+    hideLoading();
+    
+    // Handle network error
+    addMessage('ai', 'Sorry, I encountered a network error. Please check your connection and try again.');
+    console.error('Error sending message:', error);
+  }
 }
 
-// Render the app
-ReactDOM.render(<App />, document.getElementById('root'));
+// Event listener for send button
+sendButton.addEventListener('click', () => {
+  const message = userInput.value.trim();
+  if (message) {
+    sendMessage(message);
+  }
+});
+
+// Event listener for Enter key
+userInput.addEventListener('keydown', (event) => {
+  if (event.key === 'Enter' && !event.shiftKey) {
+    event.preventDefault();
+    const message = userInput.value.trim();
+    if (message) {
+      sendMessage(message);
+    }
+  }
+});
+
+// Initialize the chat with a welcome message
+window.addEventListener('DOMContentLoaded', () => {
+  addMessage('ai', 'Hello! I am an AI assistant powered by Qwen Coder. How can I help you today?');
+});

public/index.html

@@ -4,15 +4,24 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>AI Chat with Qwen Coder</title>
-    <script src="https://cdn.tailwindcss.com"></script>
-    <script src="https://unpkg.com/react@18/umd/react.development.js"></script>
-    <script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"></script>
-    <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
-    <link rel="stylesheet" href="styles.css">
+    <link href="styles.css" rel="stylesheet">
 </head>
-<body class="bg-gray-50 dark:bg-gray-900 text-gray-900 dark:text-gray-100">
-    <div id="root"></div>
-    <script type="text/babel" src="app.js"></script>
+<body>
+    <div id="app">
+        <div class="chat-container">
+            <div class="chat-header">
+                <h1>AI Chat with Qwen Coder</h1>
+                <p>Chat with the Qwen/Qwen3-Coder-30B-A3B-Instruct model</p>
+            </div>
+            <div class="chat-messages" id="chat-messages">
+                <!-- Messages will be displayed here -->
+            </div>
+            <div class="chat-input-container">
+                <textarea id="user-input" placeholder="Type your message here..."></textarea>
+                <button id="send-button">Send</button>
+            </div>
+        </div>
+    </div>
+    <script src="app.js"></script>
 </body>
 </html>

public/styles.css

@@ -1,335 +1,201 @@
-/* Custom CSS variables for theming */
-:root {
-  /* Primary color palette */
-  --primary-50: 240 249 255;
-  --primary-100: 224 242 254;
-  --primary-200: 186 230 253;
-  --primary-300: 125 211 252;
-  --primary-400: 56 189 248;
-  --primary-500: 14 165 233;
-  --primary-600: 2 132 199;
-  --primary-700: 3 105 161;
-  --primary-800: 7 89 133;
-  --primary-900: 12 74 110;
-  
-  /* Secondary color palette */
-  --secondary-50: 248 250 252;
-  --secondary-100: 241 245 249;
-  --secondary-200: 226 232 240;
-  --secondary-300: 203 213 225;
-  --secondary-400: 148 163 184;
-  --secondary-500: 100 116 139;
-  --secondary-600: 71 85 105;
-  --secondary-700: 51 65 85;
-  --secondary-800: 30 41 59;
-  --secondary-900: 15 23 42;
-  
-  /* Accent colors */
-  --accent-50: 254 249 195;
-  --accent-100: 254 240 138;
-  --accent-200: 253 230 138;
-  --accent-300: 252 211 77;
-  --accent-400: 251 191 36;
-  --accent-500: 245 158 11;
-  --accent-600: 217 119 6;
-  --accent-700: 180 83 9;
-  --accent-800: 146 64 14;
-  --accent-900: 120 53 15;
-  
-  /* Gradient definitions */
-  --gradient-primary: linear-gradient(135deg, hsl(var(--primary-500)), hsl(var(--accent-500)));
-  --gradient-secondary: linear-gradient(135deg, hsl(var(--secondary-700)), hsl(var(--secondary-900)));
-  
-  /* Shadows */
-  --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
-  --shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1);
-  --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1);
-  --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1);
-  --shadow-xl: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1);
-  --shadow-2xl: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
-  
-  /* Transitions */
-  --transition-fast: all 0.15s cubic-bezier(0.4, 0, 0.2, 1);
-  --transition-normal: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-  --transition-slow: all 0.5s cubic-bezier(0.4, 0, 0.2, 1);
-}
-
-/* Dark mode variables */
-.dark {
-  --primary-50: 236 254 255;
-  --primary-100: 207 250 254;
-  --primary-200: 165 243 252;
-  --primary-300: 103 232 249;
-  --primary-400: 34 211 238;
-  --primary-500: 6 182 212;
-  --primary-600: 8 145 178;
-  --primary-700: 14 116 144;
-  --primary-800: 21 94 117;
-  --primary-900: 22 78 99;
-}
+/* TailwindCSS styles for AI Chat Application */
 
 /* Base styles */
 body {
-  font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-  background-color: hsl(var(--secondary-50));
-  transition: background-color var(--transition-normal);
-}
-
-.dark body {
-  background-color: hsl(var(--secondary-900));
+  font-family: 'Inter', sans-serif;
+  background-color: #f8f9fa;
+  color: #333;
+  margin: 0;
+  padding: 0;
+  min-height: 100vh;
+}
+
+/* Dark mode styles */
+@media (prefers-color-scheme: dark) {
+  body {
+    background-color: #1a202c;
+    color: #e2e8f0;
+  }
 }
 
 /* Chat container */
 .chat-container {
-  max-width: 1200px;
+  max-width: 800px;
   margin: 0 auto;
-  height: 100vh;
+  padding: 20px;
   display: flex;
   flex-direction: column;
-  background-color: hsl(var(--secondary-50));
-  transition: background-color var(--transition-normal);
+  height: 100vh;
 }
 
-.dark .chat-container {
-  background-color: hsl(var(--secondary-900));
+/* Chat header */
+.chat-header {
+  text-align: center;
+  margin-bottom: 20px;
 }
 
-/* Header */
-.chat-header {
-  padding: 1rem;
-  border-bottom: 1px solid hsl(var(--secondary-200));
-  background-color: hsl(var(--secondary-50));
-  transition: all var(--transition-normal);
+.chat-header h1 {
+  font-size: 2rem;
+  font-weight: 700;
+  margin-bottom: 10px;
+  background: linear-gradient(135deg, #007cf0, #00dfd8);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
 }
 
-.dark .chat-header {
-  border-bottom: 1px solid hsl(var(--secondary-800));
-  background-color: hsl(var(--secondary-900));
+.chat-header p {
+  font-size: 1rem;
+  color: #666;
 }
 
-/* Chat messages area */
+@media (prefers-color-scheme: dark) {
+  .chat-header p {
+    color: #a0aec0;
+  }
+}
+
+/* Chat messages */
 .chat-messages {
   flex: 1;
   overflow-y: auto;
-  padding: 1rem;
-  display: flex;
-  flex-direction: column;
-  gap: 1rem;
-  background-color: hsl(var(--secondary-50));
-  transition: background-color var(--transition-normal);
+  padding: 20px;
+  background-color: #fff;
+  border-radius: 10px;
+  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+  margin-bottom: 20px;
 }
 
-.dark .chat-messages {
-  background-color: hsl(var(--secondary-900));
+@media (prefers-color-scheme: dark) {
+  .chat-messages {
+    background-color: #2d3748;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.3);
+  }
 }
 
-/* Message bubble */
-.message-bubble {
-  max-width: 80%;
-  padding: 1rem 1.5rem;
-  border-radius: 1rem;
-  box-shadow: var(--shadow);
-  transition: all var(--transition-normal);
+/* Individual message */
+.message {
+  margin-bottom: 15px;
+  padding: 10px;
+  border-radius: 8px;
+  animation: fadeIn 0.3s ease-in;
 }
 
-.message-bubble.user {
-  align-self: flex-end;
-  background-color: hsl(var(--primary-500));
-  color: white;
+.message.user {
+  background-color: #e3f2fd;
+  margin-left: 20%;
 }
 
-.message-bubble.ai {
-  align-self: flex-start;
-  background-color: hsl(var(--secondary-100));
-  color: hsl(var(--secondary-900));
+.message.ai {
+  background-color: #f0f4f8;
+  margin-right: 20%;
 }
 
-.dark .message-bubble.ai {
-  background-color: hsl(var(--secondary-800));
-  color: hsl(var(--secondary-100));
+@media (prefers-color-scheme: dark) {
+  .message.user {
+    background-color: #2c5282;
+  }
+  
+  .message.ai {
+    background-color: #4a5568;
+  }
 }
 
-/* Input area */
-.chat-input-area {
-  padding: 1rem;
-  border-top: 1px solid hsl(var(--secondary-200));
-  background-color: hsl(var(--secondary-50));
-  transition: all var(--transition-normal);
+.message-header {
+  font-weight: 600;
+  margin-bottom: 5px;
 }
 
-.dark .chat-input-area {
-  border-top: 1px solid hsl(var(--secondary-800));
-  background-color: hsl(var(--secondary-900));
+.message.user .message-header {
+  color: #007cf0;
 }
 
-/* Input field */
-.chat-input {
-  width: 100%;
-  padding: 0.75rem 1rem;
-  border-radius: 0.5rem;
-  border: 1px solid hsl(var(--secondary-300));
-  background-color: hsl(var(--secondary-100));
-  color: hsl(var(--secondary-900));
-  transition: all var(--transition-normal);
+.message.ai .message-header {
+  color: #00dfd8;
 }
 
-.dark .chat-input {
-  border: 1px solid hsl(var(--secondary-700));
-  background-color: hsl(var(--secondary-800));
-  color: hsl(var(--secondary-100));
+/* Chat input container */
+.chat-input-container {
+  display: flex;
+  gap: 10px;
 }
 
-.chat-input:focus {
-  outline: none;
-  border-color: hsl(var(--primary-500));
-  box-shadow: 0 0 0 3px hsla(var(--primary-500), 0.2);
+#user-input {
+  flex: 1;
+  padding: 12px;
+  border: 1px solid #ddd;
+  border-radius: 8px;
+  font-size: 1rem;
+  resize: none;
+  min-height: 50px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+@media (prefers-color-scheme: dark) {
+  #user-input {
+    background-color: #4a5568;
+    border-color: #718096;
+    color: #e2e8f0;
+  }
 }
 
-/* Buttons */
-.btn {
-  padding: 0.5rem 1rem;
-  border-radius: 0.5rem;
-  font-weight: 500;
-  transition: all var(--transition-normal);
-  cursor: pointer;
-  border: none;
-  background-color: hsl(var(--primary-500));
+#send-button {
+  padding: 12px 24px;
+  background: linear-gradient(135deg, #007cf0, #00dfd8);
   color: white;
+  border: none;
+  border-radius: 8px;
+  font-size: 1rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: transform 0.2s, box-shadow 0.2s;
+  box-shadow: 0 4px 6px rgba(0, 124, 240, 0.3);
 }
 
-.btn:hover {
-  background-color: hsl(var(--primary-600));
-}
-
-.btn-secondary {
-  background-color: hsl(var(--secondary-200));
-  color: hsl(var(--secondary-900);
-}
-
-.dark .btn-secondary {
-  background-color: hsl(var(--secondary-700));
-  color: hsl(var(--secondary-100);
-}
-
-.btn-secondary:hover {
-  background-color: hsl(var(--secondary-300));
-}
-
-.dark .btn-secondary:hover {
-  background-color: hsl(var(--secondary-600));
-}
-
-/* Copy button */
-.copy-button {
-  position: absolute;
-  top: 0.5rem;
-  right: 0.5rem;
-  padding: 0.25rem;
-  border-radius: 0.25rem;
-  background-color: hsl(var(--secondary-200));
-  color: hsl(var(--secondary-700));
-  opacity: 0;
-  transition: all var(--transition-normal);
-}
-
-.message-bubble:hover .copy-button {
-  opacity: 1;
-}
-
-.dark .copy-button {
-  background-color: hsl(var(--secondary-700));
-  color: hsl(var(--secondary-200));
-}
-
-/* Typing indicator */
-.typing-indicator {
-  display: flex;
-  align-items: center;
-  gap: 0.25rem;
-  padding: 1rem 1.5rem;
-  background-color: hsl(var(--secondary-100));
-  border-radius: 1rem;
-  width: fit-content;
-  max-width: 80%;
-  align-self: flex-start;
+#send-button:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 6px 8px rgba(0, 124, 240, 0.4);
 }
 
-.dark .typing-indicator {
-  background-color: hsl(var(--secondary-800));
+#send-button:active {
+  transform: translateY(0);
 }
 
-.typing-dot {
-  width: 0.5rem;
-  height: 0.5rem;
+/* Loading indicator */
+.loading {
+  display: inline-block;
+  width: 20px;
+  height: 20px;
+  border: 3px solid rgba(0, 124, 240, 0.3);
   border-radius: 50%;
-  background-color: hsl(var(--secondary-500));
-  animation: typing 1.4s infinite ease-in-out;
+  border-top-color: #007cf0;
+  animation: spin 1s ease-in-out infinite;
 }
 
-.typing-dot:nth-child(1) {
-  animation-delay: 0s;
+@keyframes spin {
+  to { transform: rotate(360deg); }
 }
 
-.typing-dot:nth-child(2) {
-  animation-delay: 0.2s;
-}
-
-.typing-dot:nth-child(3) {
-  animation-delay: 0.4s;
-}
-
-@keyframes typing {
-  0%, 60%, 100% {
-    transform: translateY(0);
-  }
-  30% {
-    transform: translateY(-5px);
-  }
+@keyframes fadeIn {
+  from { opacity: 0; transform: translateY(10px); }
+  to { opacity: 1; transform: translateY(0); }
 }
 
 /* Responsive design */
 @media (max-width: 768px) {
-  .message-bubble {
-    max-width: 90%;
+  .chat-container {
+    padding: 10px;
   }
   
-  .chat-header, .chat-input-area {
-    padding: 0.75rem;
+  .chat-header h1 {
+    font-size: 1.5rem;
   }
   
-  .chat-messages {
-    padding: 0.75rem;
+  .message.user {
+    margin-left: 10%;
+  }
+  
+  .message.ai {
+    margin-right: 10%;
   }
-}
-
-/* Scrollbar styling */
-::-webkit-scrollbar {
-  width: 8px;
-}
-
-::-webkit-scrollbar-track {
-  background: hsl(var(--secondary-100));
-}
-
-.dark ::-webkit-scrollbar-track {
-  background: hsl(var(--secondary-800));
-}
-
-::-webkit-scrollbar-thumb {
-  background: hsl(var(--secondary-300));
-  border-radius: 4px;
-}
-
-.dark ::-webkit-scrollbar-thumb {
-  background: hsl(var(--secondary-600));
-}
-
-::-webkit-scrollbar-thumb:hover {
-  background: hsl(var(--secondary-400));
-}
-
-.dark ::-webkit-scrollbar-thumb:hover {
-  background: hsl(var(--secondary-500));
 }

readme.md

@@ -1,41 +1,50 @@
-# AI Chat Application for HuggingFace Spaces
+# AI Chat Application with Qwen Coder
 
-A fully functional AI chat application for HuggingFace Spaces integrating Qwen Coder 3 with advanced OPENAI API compatibility features.
+This is a fully functional AI chat application built for HuggingFace Spaces, integrating the Qwen/Qwen3-Coder-30B-A3B-Instruct model with advanced OPENAI API compatibility features.
 
 ## Features
 
-- Integration with Qwen/Qwen3-Coder-30B-A3B-Instruct model
-- Advanced OPENAI API compatibility
-- Professional web interface replicating Perplexity AI design
-- Responsive layout with TailwindCSS styling
-- Dark/light mode support
-- Real-time streaming responses
-- Conversation history management
-- Copy response functionality
-- Typing indicators
-- Full GPU optimization
-- Robust error handling and automatic connection recovery
-- Caching mechanisms
-- Ready for immediate deployment on HuggingFace Spaces
-
-## Technology Stack
-
-- **Backend**: Python, Gradio, FastAPI, Transformers, PyTorch
-- **Frontend**: TailwindCSS, JavaScript, HTML5
-- **Infrastructure**: Redis for caching, HuggingFace Spaces deployment
+- **Qwen Coder 3 Integration**: Direct integration with the Qwen/Qwen3-Coder-30B-A3B-Instruct model
+- **OPENAI API Compatibility**: Implements OPENAI API endpoints for seamless integration
+- **Streaming Responses**: Real-time response streaming for interactive chat experience
+- **Conversation History**: Persistent conversation history management
+- **Modern UI**: Responsive design inspired by Perplexity AI with TailwindCSS
+- **Dark/Light Mode**: Support for both dark and light themes
+- **Copy Responses**: One-click copying of AI responses
+- **Typing Indicators**: Visual indicators for AI response generation
+- **GPU Optimization**: Full GPU optimization for maximum performance
+- **Error Handling**: Robust error handling with automatic connection recovery
+- **Caching**: Efficient caching mechanisms for improved performance
+
+## Project Structure
+
+```
+/
+├── app.py                 # Main application entry point
+├── requirements.txt       # Python dependencies
+├── README.md             # This file
+├── public/               # Frontend static files
+│   ├── index.html        # Main HTML file
+│   ├── styles.css        # TailwindCSS styles
+│   └── app.js            # JavaScript logic
+└── utils/                # Utility modules
+    ├── model_utils.py    # Model management utilities
+    ├── conversation.py   # Conversation management
+    └── api_compat.py     # OPENAI API compatibility
+```
 
 ## Requirements
 
 - Python 3.8+
-- GPU with at least 24GB VRAM (for Qwen/Qwen3-Coder-30B-A3B-Instruct model)
-- Redis server (optional, for conversation caching)
+- GPU with CUDA support (recommended)
+- 32GB+ RAM (for optimal performance with Qwen Coder 3)
 
 ## Installation
 
 1. Clone this repository:
    ```bash
    git clone <repository-url>
-   cd ai-chat-app
+   cd <repository-name>
    ```
 
 2. Install dependencies:
@@ -48,29 +57,37 @@ A fully functional AI chat application for HuggingFace Spaces integrating Qwen C
    python app.py
    ```
 
-## Usage
+## Deployment to HuggingFace Spaces
 
-### Web Interface
+1. Create a new Space on HuggingFace:
+   - Go to https://huggingface.co/new-space
+   - Choose "Gradio" as the Space SDK
+   - Select a GPU hardware (recommended for Qwen Coder 3)
 
-The application provides a web interface accessible at `http://localhost:7860` when running locally. The interface features:
+2. Upload files to your Space repository:
+   - Upload all files from this repository
+   - Make sure to include the `requirements.txt` file
 
-- Chat interface similar to Perplexity AI
-- Dark/light mode toggle
-- Conversation history sidebar
-- Copy buttons for responses
-- Typing indicators during response generation
+3. Configure the Space:
+   - The Space will automatically detect and install dependencies from `requirements.txt`
+   - The application will start automatically on port 7860
 
-### API Endpoints
+4. Access your deployed application:
+   - Once the build is complete, your application will be available at the provided URL
 
-The application exposes OPENAI API compatible endpoints:
+## API Endpoints
 
-- `POST /v1/chat/completions` - Chat completion endpoint
+### OPENAI API Compatible Endpoint
+```
+POST /v1/chat/completions
+```
 
-Example request:
+Request format:
 ```json
 {
   "messages": [
-    {"role": "user", "content": "Hello, how are you?"}
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "Hello!"}
   ],
   "model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
   "max_tokens": 1024,
@@ -78,47 +95,75 @@ Example request:
 }
 ```
 
-## Deployment to HuggingFace Spaces
-
-1. Create a new Space on HuggingFace with the following configuration:
-   - SDK: Gradio
-   - Hardware: GPU (recommended)
-
-2. Upload all files to your Space repository
+### Frontend Chat Endpoint
+```
+POST /chat
+```
 
-3. The application will automatically start and be accessible through your Space URL
+Request format:
+```json
+{
+  "message": "Hello!",
+  "history": [
+    {"role": "user", "content": "Previous message"},
+    {"role": "assistant", "content": "Previous response"}
+  ]
+}
+```
 
-## Configuration
+## Customization
 
-The application can be configured through environment variables:
+### Model Configuration
+You can customize the model behavior by modifying the parameters in `utils/model_utils.py`:
+- `DEFAULT_MAX_TOKENS`: Maximum tokens to generate
+- `DEFAULT_TEMPERATURE`: Sampling temperature
 
-- `MODEL_NAME`: The HuggingFace model identifier (default: Qwen/Qwen3-Coder-30B-A3B-Instruct)
-- `MAX_TOKENS`: Default maximum tokens for responses (default: 1024)
-- `TEMPERATURE`: Default temperature for generation (default: 0.7)
-- `REDIS_URL`: Redis connection URL for caching (optional)
+### UI Customization
+The UI can be customized by modifying:
+- `public/styles.css`: CSS styles with TailwindCSS
+- `public/app.js`: JavaScript logic
+- `public/index.html`: HTML structure
 
 ## Troubleshooting
 
-### GPU Memory Issues
+### Common Issues
+
+1. **Model Loading Errors**:
+   - Ensure you have sufficient RAM and GPU memory
+   - Check that the model name is correct in `utils/model_utils.py`
 
-If you encounter GPU memory issues:
+2. **CUDA Out of Memory**:
+   - Reduce `DEFAULT_MAX_TOKENS` in `utils/model_utils.py`
+   - Use a smaller model variant if available
 
-1. Ensure your GPU has at least 24GB VRAM
-2. Try reducing the `max_tokens` parameter
-3. Use quantization techniques for model loading
+3. **Dependency Installation Failures**:
+   - Check the HuggingFace Space logs for specific error messages
+   - Ensure all dependencies are listed in `requirements.txt`
 
-### Model Loading Errors
+### Performance Optimization
 
-If the model fails to load:
+1. **GPU Usage**:
+   - The application automatically detects and uses CUDA if available
+   - For CPU-only environments, performance will be significantly slower
 
-1. Check your internet connection
-2. Ensure you have sufficient disk space
-3. Verify the model identifier is correct
+2. **Caching**:
+   - Redis is used for caching if available
+   - In-memory storage is used as fallback
 
 ## Contributing
 
-Contributions are welcome! Please fork the repository and submit a pull request with your changes.
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
 
 ## License
 
-This project is licensed under the MIT License - see the LICENSE file for details.
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Qwen team for the Qwen/Qwen3-Coder-30B-A3B-Instruct model
+- HuggingFace for providing the platform
+- Gradio team for the web interface framework

requirements.txt

@@ -1,10 +1,8 @@
 gradio>=3.0.0
-transformers>=4.30.0
-torch>=2.0.0
+transformers>=4.0.0
+torch>=1.9.0
 fastapi>=0.68.0
 uvicorn>=0.15.0
 redis>=3.5.0
 aiohttp>=3.7.0
-pydantic>=1.8.0
-accelerate>=0.20.0
-bitsandbytes>=0.39.0
+pydantic>=1.8.0

utils/api_compat.py

@@ -0,0 +1,81 @@
+"""
+OPENAI API compatibility utilities
+"""
+
+import time
+import logging
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Default model configuration
+DEFAULT_MODEL = "Qwen/Qwen3-Coder-30B-A3B-Instruct"
+DEFAULT_MAX_TOKENS = 1024
+DEFAULT_TEMPERATURE = 0.7
+
+class ChatMessage(BaseModel):
+    """Represents a chat message"""
+    role: str
+    content: str
+
+class ChatRequest(BaseModel):
+    """Represents a chat request"""
+    messages: List[ChatMessage]
+    model: str = DEFAULT_MODEL
+    max_tokens: Optional[int] = DEFAULT_MAX_TOKENS
+    temperature: Optional[float] = DEFAULT_TEMPERATURE
+
+class ChatResponse(BaseModel):
+    """Represents a chat response"""
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[Dict[str, Any]]
+    usage: Dict[str, int]
+
+def convert_openai_request_to_model_input(request: ChatRequest) -> str:
+    """Convert OPENAI API request to model input format"""
+    prompt = ""
+    for msg in request.messages:
+        if msg.role == "system":
+            prompt += f"System: {msg.content}\n"
+        elif msg.role == "user":
+            prompt += f"User: {msg.content}\n"
+        elif msg.role == "assistant":
+            prompt += f"Assistant: {msg.content}\n"
+    return prompt
+
+def create_openai_response(response_text: str, request: ChatRequest) -> ChatResponse:
+    """Create OPENAI API compatible response"""
+    return ChatResponse(
+        id="chatcmpl-" + str(hash(response_text))[:10],
+        created=int(time.time()),
+        model=request.model,
+        choices=[{
+            "index": 0,
+            "message": {
+                "role": "assistant",
+                "content": response_text
+            },
+            "finish_reason": "stop"
+        }],
+        usage={
+            "prompt_tokens": sum(len(msg.content.split()) for msg in request.messages),
+            "completion_tokens": len(response_text.split()),
+            "total_tokens": sum(len(msg.content.split()) for msg in request.messages) + len(response_text.split())
+        }
+    )
+
+def format_messages_for_frontend(messages: List[Dict[str, Any]]) -> List[Dict[str, str]]:
+    """Format messages for frontend display"""
+    formatted_messages = []
+    for msg in messages:
+        if msg["role"] == "user":
+            formatted_messages.append({"sender": "user", "text": msg["content"]})
+        elif msg["role"] == "assistant":
+            formatted_messages.append({"sender": "ai", "text": msg["content"]})
+    return formatted_messages

utils/conversation.py

@@ -0,0 +1,65 @@
+"""
+Conversation management utilities
+"""
+
+import json
+import logging
+import redis
+from typing import List, Dict, Any
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ConversationManager:
+    """Manage conversation history and caching"""
+    
+    def __init__(self):
+        self.redis_client = None
+        try:
+            self.redis_client = redis.Redis(host='localhost', port=6379, db=0)
+            self.redis_client.ping()
+        except:
+            logger.warning("Redis not available, using in-memory storage")
+            self.conversations = {}
+    
+    def save_conversation(self, conv_id: str, messages: List[Dict[str, Any]]) -> None:
+        """Save conversation to cache"""
+        try:
+            if self.redis_client:
+                self.redis_client.setex(conv_id, 86400, json.dumps(messages))  # 24 hours expiry
+            else:
+                self.conversations[conv_id] = messages
+        except Exception as e:
+            logger.error(f"Error saving conversation: {e}")
+    
+    def load_conversation(self, conv_id: str) -> List[Dict[str, Any]]:
+        """Load conversation from cache"""
+        try:
+            if self.redis_client:
+                data = self.redis_client.get(conv_id)
+                if data:
+                    return json.loads(data)
+            else:
+                return self.conversations.get(conv_id, [])
+        except Exception as e:
+            logger.error(f"Error loading conversation: {e}")
+        return []
+    
+    def format_messages_for_model(self, messages: List[Dict[str, Any]]) -> str:
+        """Format messages for model input"""
+        prompt = ""
+        for msg in messages:
+            if msg["role"] == "system":
+                prompt += f"System: {msg['content']}\n"
+            elif msg["role"] == "user":
+                prompt += f"User: {msg['content']}\n"
+            elif msg["role"] == "assistant":
+                prompt += f"Assistant: {msg['content']}\n"
+        return prompt
+    
+    def add_message_to_conversation(self, conv_id: str, role: str, content: str) -> None:
+        """Add a message to a conversation"""
+        conversation = self.load_conversation(conv_id)
+        conversation.append({"role": role, "content": content})
+        self.save_conversation(conv_id, conversation)