Upload 4 files

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Run the application
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--timeout", "120", "app:app"]

README.md

@@ -1,12 +1,215 @@
 ---
-title: Openwebui Ollama
-emoji: 🦀
-colorFrom: yellow
-colorTo: indigo
+title: OpenWebUI - Ollama Chat
+emoji: 🤖
+colorFrom: green
+colorTo: blue
 sdk: docker
-pinned: false
-license: apache-2.0
-short_description: openwebui-ollama
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤖 OpenWebUI - Ollama Chat
+
+A beautiful, modern chat interface for Ollama models, deployed as a Hugging Face Space. This Space provides a full-featured web UI that connects to your Ollama API Space for an interactive chat experience.
+
+## 🌟 Features
+
+- **Beautiful Chat Interface**: Modern, responsive design with gradient backgrounds and smooth animations
+- **Model Selection**: Choose from any available Ollama model
+- **Parameter Control**: Adjust temperature, max tokens, and other generation parameters
+- **Real-time Chat**: Interactive chat experience with typing indicators
+- **Mobile Responsive**: Works perfectly on desktop and mobile devices
+- **Ollama Integration**: Seamlessly connects to your Ollama API Space
+- **Health Monitoring**: Built-in health checks and status monitoring
+
+## 🚀 Quick Start
+
+### 1. Deploy to Hugging Face Spaces
+
+1. Fork this repository or create a new Space
+2. Upload these files to your Space
+3. Set the following environment variables in your Space settings:
+   - `OLLAMA_API_URL`: URL to your Ollama Space (e.g., `https://your-ollama-space.hf.space`)
+   - `DEFAULT_MODEL`: Default model to use (e.g., `llama2`)
+   - `MAX_TOKENS`: Maximum tokens for generation (default: `2048`)
+   - `TEMPERATURE`: Default temperature (default: `0.7`)
+
+### 2. Local Development
+
+```bash
+# Clone the repository
+git clone <your-repo-url>
+cd openwebui-space
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Set environment variables
+export OLLAMA_API_URL=https://your-ollama-space.hf.space
+export DEFAULT_MODEL=llama2
+
+# Run the application
+python app.py
+```
+
+## 🔧 Configuration
+
+### Environment Variables
+
+- `OLLAMA_API_URL`: **Required** - URL to your Ollama Space (e.g., `https://your-ollama-space.hf.space`)
+- `DEFAULT_MODEL`: Default model to use (default: `llama2`)
+- `MAX_TOKENS`: Maximum tokens for generation (default: `2048`)
+- `TEMPERATURE`: Default temperature setting (default: `0.7`)
+
+### Prerequisites
+
+Before using this OpenWebUI Space, you need:
+
+1. **Ollama Space**: A deployed Ollama API Space (see the `ollama-space` directory)
+2. **Ollama Instance**: A running Ollama instance that your Ollama Space can connect to
+3. **Network Access**: The OpenWebUI Space must be able to reach your Ollama Space
+
+## 📡 API Endpoints
+
+### GET `/`
+Main chat interface - the beautiful web UI.
+
+### POST `/api/chat`
+Chat API endpoint for programmatic access.
+
+**Request Body:**
+```json
+{
+  "message": "Hello, how are you?",
+  "model": "llama2",
+  "temperature": 0.7,
+  "max_tokens": 2048
+}
+```
+
+**Response:**
+```json
+{
+  "status": "success",
+  "response": "Hello! I'm doing well, thank you for asking...",
+  "model": "llama2",
+  "usage": {
+    "prompt_tokens": 7,
+    "completion_tokens": 15,
+    "total_tokens": 22
+  }
+}
+```
+
+### GET `/api/models`
+Get available models from the connected Ollama Space.
+
+### GET `/health`
+Health check endpoint that also checks the Ollama Space connection.
+
+## 🌐 Integration with Ollama Space
+
+This OpenWebUI Space is designed to work seamlessly with the Ollama Space:
+
+1. **API Communication**: The OpenWebUI Space communicates with your Ollama Space via HTTP API calls
+2. **Model Discovery**: Automatically discovers and lists available models from your Ollama Space
+3. **Text Generation**: Sends generation requests to your Ollama Space and displays responses
+4. **Health Monitoring**: Monitors the health of both the OpenWebUI Space and the Ollama Space
+
+### Architecture
+
+```
+User → OpenWebUI Space → Ollama Space → Ollama Instance
+```
+
+## 🎨 UI Features
+
+### Chat Interface
+- **Message Bubbles**: Distinct styling for user and AI messages
+- **Avatars**: Visual indicators for message sender
+- **Auto-scroll**: Automatically scrolls to new messages
+- **Typing Indicators**: Shows when AI is generating a response
+
+### Controls
+- **Model Selection**: Dropdown to choose from available models
+- **Temperature Slider**: Adjust creativity/randomness (0.0 - 2.0)
+- **Max Tokens**: Set maximum response length
+- **Real-time Updates**: Parameter changes are applied immediately
+
+### Responsive Design
+- **Mobile Optimized**: Touch-friendly interface for mobile devices
+- **Adaptive Layout**: Automatically adjusts to different screen sizes
+- **Modern CSS**: Uses CSS Grid and Flexbox for optimal layouts
+
+## 🐳 Docker Support
+
+The Space includes a Dockerfile for containerized deployment:
+
+```bash
+# Build the image
+docker build -t openwebui-space .
+
+# Run the container
+docker run -p 7860:7860 \
+  -e OLLAMA_API_URL=https://your-ollama-space.hf.space \
+  -e DEFAULT_MODEL=llama2 \
+  openwebui-space
+```
+
+## 🔒 Security Considerations
+
+- **Public Access**: The Space is publicly accessible - consider adding authentication for production use
+- **API Communication**: All communication with the Ollama Space is over HTTPS (when using HF Spaces)
+- **Input Validation**: User inputs are validated before being sent to the Ollama Space
+
+## 🚨 Troubleshooting
+
+### Common Issues
+
+1. **Cannot connect to Ollama Space**: Check the `OLLAMA_API_URL` environment variable
+2. **No models available**: Ensure your Ollama Space is running and has models
+3. **Generation errors**: Check the Ollama Space logs for detailed error messages
+4. **Slow responses**: Large models may take time to generate responses
+
+### Health Checks
+
+Use the `/health` endpoint to monitor:
+- OpenWebUI Space status
+- Connection to Ollama Space
+- Ollama Space health status
+
+### Debug Mode
+
+For local development, you can enable debug mode by setting `debug=True` in the Flask app.
+
+## 📱 Mobile Experience
+
+The interface is fully optimized for mobile devices:
+- Touch-friendly controls
+- Responsive design that adapts to screen size
+- Optimized for portrait and landscape orientations
+- Fast loading and smooth scrolling
+
+## 🎯 Use Cases
+
+- **Personal AI Assistant**: Chat with your local models
+- **Development Testing**: Test model responses and parameters
+- **Demo and Showcase**: Present your Ollama setup to others
+- **API Gateway**: Use the chat interface as a frontend for your Ollama API
+
+## 📝 License
+
+This project is open source and available under the MIT License.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📞 Support
+
+If you encounter any issues or have questions, please open an issue on the repository.
+
+## 🔗 Related Projects
+
+- **Ollama Space**: The backend API Space that this UI connects to
+- **Ollama**: The local LLM runner that powers everything
+- **Hugging Face Spaces**: The deployment platform for both Spaces

app.py

@@ -0,0 +1,611 @@
+from flask import Flask, request, jsonify, render_template_string
+import os
+import requests
+import json
+import logging
+from typing import Dict, Any, List
+import time
+
+app = Flask(__name__)
+logging.basicConfig(level=logging.INFO)
+
+# Configuration
+OLLAMA_API_URL = os.getenv('OLLAMA_API_URL', 'https://your-ollama-space.hf.space')
+DEFAULT_MODEL = os.getenv('DEFAULT_MODEL', 'llama2')
+MAX_TOKENS = int(os.getenv('MAX_TOKENS', '2048'))
+TEMPERATURE = float(os.getenv('TEMPERATURE', '0.7'))
+
+class OllamaClient:
+    def __init__(self, api_url: str):
+        self.api_url = api_url.rstrip('/')
+        self.available_models = []
+        self.refresh_models()
+    
+    def refresh_models(self):
+        """Refresh the list of available models"""
+        try:
+            response = requests.get(f"{self.api_url}/api/models", timeout=10)
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('status') == 'success':
+                    self.available_models = data.get('models', [])
+                else:
+                    self.available_models = []
+            else:
+                self.available_models = []
+        except Exception as e:
+            logging.error(f"Error refreshing models: {e}")
+            self.available_models = []
+    
+    def list_models(self) -> List[str]:
+        """List all available models"""
+        self.refresh_models()
+        return self.available_models
+    
+    def generate(self, model_name: str, prompt: str, **kwargs) -> Dict[str, Any]:
+        """Generate text using a model"""
+        try:
+            payload = {
+                "model": model_name,
+                "prompt": prompt,
+                "stream": False
+            }
+            payload.update(kwargs)
+            
+            response = requests.post(f"{self.api_url}/api/generate", 
+                                  json=payload, 
+                                  timeout=120)
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('status') == 'success':
+                    return {
+                        "status": "success",
+                        "response": data.get('response', ''),
+                        "model": model_name,
+                        "usage": data.get('usage', {})
+                    }
+                else:
+                    return {"status": "error", "message": data.get('message', 'Unknown error')}
+            else:
+                return {"status": "error", "message": f"Generation failed: {response.text}"}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+    
+    def health_check(self) -> Dict[str, Any]:
+        """Check the health of the Ollama API"""
+        try:
+            response = requests.get(f"{self.api_url}/health", timeout=10)
+            if response.status_code == 200:
+                return response.json()
+            else:
+                return {"status": "unhealthy", "error": f"HTTP {response.status_code}"}
+        except Exception as e:
+            return {"status": "unhealthy", "error": str(e)}
+
+# Initialize Ollama client
+ollama_client = OllamaClient(OLLAMA_API_URL)
+
+# HTML template for the chat interface
+HTML_TEMPLATE = '''
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>OpenWebUI - Ollama Chat</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+        
+        .header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 30px;
+            text-align: center;
+        }
+        
+        .header h1 {
+            font-size: 2.5rem;
+            margin-bottom: 10px;
+            font-weight: 700;
+        }
+        
+        .header p {
+            font-size: 1.1rem;
+            opacity: 0.9;
+        }
+        
+        .controls {
+            padding: 20px 30px;
+            background: #f8f9fa;
+            border-bottom: 1px solid #e9ecef;
+            display: flex;
+            gap: 15px;
+            align-items: center;
+            flex-wrap: wrap;
+        }
+        
+        .control-group {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+        
+        .control-group label {
+            font-weight: 600;
+            color: #495057;
+            min-width: 80px;
+        }
+        
+        .control-group select,
+        .control-group input {
+            padding: 8px 12px;
+            border: 2px solid #e9ecef;
+            border-radius: 8px;
+            font-size: 14px;
+            transition: border-color 0.3s;
+        }
+        
+        .control-group select:focus,
+        .control-group input:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+        
+        .chat-container {
+            height: 500px;
+            overflow-y: auto;
+            padding: 20px;
+            background: #fafbfc;
+        }
+        
+        .message {
+            margin-bottom: 20px;
+            display: flex;
+            gap: 15px;
+        }
+        
+        .message.user {
+            flex-direction: row-reverse;
+        }
+        
+        .message-avatar {
+            width: 40px;
+            height: 40px;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-weight: bold;
+            color: white;
+            flex-shrink: 0;
+        }
+        
+        .message.user .message-avatar {
+            background: #667eea;
+        }
+        
+        .message.assistant .message-avatar {
+            background: #28a745;
+        }
+        
+        .message-content {
+            background: white;
+            padding: 15px 20px;
+            border-radius: 18px;
+            max-width: 70%;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            line-height: 1.5;
+        }
+        
+        .message.user .message-content {
+            background: #667eea;
+            color: white;
+        }
+        
+        .message.assistant .message-content {
+            background: white;
+            color: #333;
+        }
+        
+        .input-container {
+            padding: 20px 30px;
+            background: white;
+            border-top: 1px solid #e9ecef;
+        }
+        
+        .input-form {
+            display: flex;
+            gap: 15px;
+        }
+        
+        .input-field {
+            flex: 1;
+            padding: 15px 20px;
+            border: 2px solid #e9ecef;
+            border-radius: 25px;
+            font-size: 16px;
+            transition: border-color 0.3s;
+            resize: none;
+            min-height: 50px;
+            max-height: 120px;
+        }
+        
+        .input-field:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+        
+        .send-button {
+            padding: 15px 30px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border: none;
+            border-radius: 25px;
+            font-size: 16px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: transform 0.2s;
+            min-width: 100px;
+        }
+        
+        .send-button:hover {
+            transform: translateY(-2px);
+        }
+        
+        .send-button:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+            transform: none;
+        }
+        
+        .status {
+            text-align: center;
+            padding: 10px;
+            font-size: 14px;
+            color: #6c757d;
+        }
+        
+        .status.error {
+            color: #dc3545;
+        }
+        
+        .status.success {
+            color: #28a745;
+        }
+        
+        .typing-indicator {
+            display: none;
+            padding: 15px 20px;
+            background: white;
+            border-radius: 18px;
+            color: #6c757d;
+            font-style: italic;
+        }
+        
+        @media (max-width: 768px) {
+            .controls {
+                flex-direction: column;
+                align-items: stretch;
+            }
+            
+            .control-group {
+                justify-content: space-between;
+            }
+            
+            .message-content {
+                max-width: 85%;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🤖 OpenWebUI</h1>
+            <p>Chat with your local Ollama models through Hugging Face Spaces</p>
+        </div>
+        
+        <div class="controls">
+            <div class="control-group">
+                <label for="model-select">Model:</label>
+                <select id="model-select">
+                    <option value="">Loading models...</option>
+                </select>
+            </div>
+            
+            <div class="control-group">
+                <label for="temperature">Temperature:</label>
+                <input type="range" id="temperature" min="0" max="2" step="0.1" value="0.7">
+                <span id="temp-value">0.7</span>
+            </div>
+            
+            <div class="control-group">
+                <label for="max-tokens">Max Tokens:</label>
+                <input type="number" id="max-tokens" min="1" max="4096" value="2048">
+            </div>
+        </div>
+        
+        <div class="chat-container" id="chat-container">
+            <div class="message assistant">
+                <div class="message-avatar">AI</div>
+                <div class="message-content">
+                    Hello! I'm your AI assistant powered by Ollama. How can I help you today?
+                </div>
+            </div>
+        </div>
+        
+        <div class="typing-indicator" id="typing-indicator">
+            AI is thinking...
+        </div>
+        
+        <div class="input-container">
+            <form class="input-form" id="chat-form">
+                <textarea 
+                    class="input-field" 
+                    id="message-input" 
+                    placeholder="Type your message here..."
+                    rows="1"
+                ></textarea>
+                <button type="submit" class="send-button" id="send-button">
+                    Send
+                </button>
+            </form>
+        </div>
+        
+        <div class="status" id="status"></div>
+    </div>
+
+    <script>
+        let conversationHistory = [];
+        
+        // Initialize the interface
+        document.addEventListener('DOMContentLoaded', function() {
+            loadModels();
+            setupEventListeners();
+            autoResizeTextarea();
+        });
+        
+        function loadModels() {
+            fetch('{{ ollama_api_url }}/api/models')
+                .then(response => response.json())
+                .then(data => {
+                    const modelSelect = document.getElementById('model-select');
+                    modelSelect.innerHTML = '';
+                    
+                    if (data.status === 'success' && data.models.length > 0) {
+                        data.models.forEach(model => {
+                            const option = document.createElement('option');
+                            option.value = model;
+                            option.textContent = model;
+                            if (model === '{{ default_model }}') {
+                                option.selected = true;
+                            }
+                            modelSelect.appendChild(option);
+                        });
+                    } else {
+                        modelSelect.innerHTML = '<option value="">No models available</option>';
+                    }
+                })
+                .catch(error => {
+                    console.error('Error loading models:', error);
+                    showStatus('Error loading models', 'error');
+                });
+        }
+        
+        function setupEventListeners() {
+            // Chat form submission
+            document.getElementById('chat-form').addEventListener('submit', handleSubmit);
+            
+            // Temperature slider
+            document.getElementById('temperature').addEventListener('input', function() {
+                document.getElementById('temp-value').textContent = this.value;
+            });
+            
+            // Auto-resize textarea
+            document.getElementById('message-input').addEventListener('input', autoResizeTextarea);
+        }
+        
+        function autoResizeTextarea() {
+            const textarea = document.getElementById('message-input');
+            textarea.style.height = 'auto';
+            textarea.style.height = Math.min(textarea.scrollHeight, 120) + 'px';
+        }
+        
+        function handleSubmit(e) {
+            e.preventDefault();
+            
+            const messageInput = document.getElementById('message-input');
+            const message = messageInput.value.trim();
+            
+            if (!message) return;
+            
+            const model = document.getElementById('model-select').value;
+            const temperature = parseFloat(document.getElementById('temperature').value);
+            const maxTokens = parseInt(document.getElementById('max-tokens').value);
+            
+            if (!model) {
+                showStatus('Please select a model', 'error');
+                return;
+            }
+            
+            // Add user message to chat
+            addMessage(message, 'user');
+            messageInput.value = '';
+            autoResizeTextarea();
+            
+            // Show typing indicator
+            showTypingIndicator(true);
+            
+            // Send message to API
+            sendMessage(message, model, temperature, maxTokens);
+        }
+        
+        function addMessage(content, sender) {
+            const chatContainer = document.getElementById('chat-container');
+            const messageDiv = document.createElement('div');
+            messageDiv.className = `message ${sender}`;
+            
+            const avatar = document.createElement('div');
+            avatar.className = 'message-avatar';
+            avatar.textContent = sender === 'user' ? 'U' : 'AI';
+            
+            const messageContent = document.createElement('div');
+            messageContent.className = 'message-content';
+            messageContent.textContent = content;
+            
+            messageDiv.appendChild(avatar);
+            messageDiv.appendChild(messageContent);
+            chatContainer.appendChild(messageDiv);
+            
+            // Scroll to bottom
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+            
+            // Add to conversation history
+            conversationHistory.push({ role: sender, content: content });
+        }
+        
+        function sendMessage(message, model, temperature, maxTokens) {
+            const payload = {
+                model: model,
+                prompt: message,
+                temperature: temperature,
+                max_tokens: maxTokens
+            };
+            
+            fetch('{{ ollama_api_url }}/api/generate', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(payload)
+            })
+            .then(response => response.json())
+            .then(data => {
+                showTypingIndicator(false);
+                
+                if (data.status === 'success') {
+                    addMessage(data.response, 'assistant');
+                    showStatus(`Response generated using ${model}`, 'success');
+                } else {
+                    addMessage('Sorry, I encountered an error while processing your request.', 'assistant');
+                    showStatus(`Error: ${data.message}`, 'error');
+                }
+            })
+            .catch(error => {
+                showTypingIndicator(false);
+                addMessage('Sorry, I encountered an error while processing your request.', 'assistant');
+                showStatus('Network error occurred', 'error');
+                console.error('Error:', error);
+            });
+        }
+        
+        function showTypingIndicator(show) {
+            const indicator = document.getElementById('typing-indicator');
+            indicator.style.display = show ? 'block' : 'none';
+            
+            if (show) {
+                const chatContainer = document.getElementById('chat-container');
+                chatContainer.scrollTop = chatContainer.scrollHeight;
+            }
+        }
+        
+        function showStatus(message, type = '') {
+            const statusDiv = document.getElementById('status');
+            statusDiv.textContent = message;
+            statusDiv.className = `status ${type}`;
+            
+            // Clear status after 5 seconds
+            setTimeout(() => {
+                statusDiv.textContent = '';
+                statusDiv.className = 'status';
+            }, 5000);
+        }
+    </script>
+</body>
+</html>
+'''
+
+@app.route('/')
+def home():
+    """Main chat interface"""
+    return render_template_string(HTML_TEMPLATE, 
+                                ollama_api_url=OLLAMA_API_URL,
+                                default_model=DEFAULT_MODEL)
+
+@app.route('/api/chat', methods=['POST'])
+def chat():
+    """Chat API endpoint"""
+    try:
+        data = request.get_json()
+        if not data or 'message' not in data or 'model' not in data:
+            return jsonify({"status": "error", "message": "Message and model are required"}), 400
+        
+        message = data['message']
+        model = data['model']
+        temperature = data.get('temperature', TEMPERATURE)
+        max_tokens = data.get('max_tokens', MAX_TOKENS)
+        
+        result = ollama_client.generate(model, message, 
+                                      temperature=temperature, 
+                                      max_tokens=max_tokens)
+        
+        if result["status"] == "success":
+            return jsonify(result)
+        else:
+            return jsonify(result), 500
+    except Exception as e:
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route('/api/models', methods=['GET'])
+def get_models():
+    """Get available models"""
+    try:
+        models = ollama_client.list_models()
+        return jsonify({
+            "status": "success",
+            "models": models,
+            "count": len(models)
+        })
+    except Exception as e:
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    try:
+        ollama_health = ollama_client.health_check()
+        return jsonify({
+            "status": "healthy",
+            "ollama_api": ollama_health,
+            "timestamp": time.time()
+        })
+    except Exception as e:
+        return jsonify({
+            "status": "unhealthy",
+            "error": str(e),
+            "timestamp": time.time()
+        }), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860, debug=False)

requirements.txt

@@ -0,0 +1,3 @@
+flask==2.3.3
+requests==2.31.0
+gunicorn==21.2.0