Spaces:

IamSamkk
/

mindfull

Configuration error

File size: 13,873 Bytes

27caffe

# 🛡️ Police Bot AI Integration Guide

This guide explains how to integrate the AI wellness assistant with your website and enhance it with additional local LLM capabilities.

## 🏗️ System Architecture

```
Website Frontend (React/HTML/CSS)
    ↓ HTTP/WebSocket
Flask Web API (web_api.py)
    ↓
Police Bot Runtime (police_runtime.py)
    ↓
├── LLaMA3 via Ollama (Primary Reasoning)
├── F5-TTS (Voice Synthesis)
└── [Third Local LLM] (Enhanced Capabilities)
```

## 🚀 Quick Start

### 1. Setup the AI Runtime

```bash
# Run the setup script
python setup.py

# Start Ollama with the police-bot model
ollama run police-bot

# Start the web API
python web_api.py
```

### 2. Test the System

```bash
# Test the command-line interface
python police_runtime.py

# Test the web API
curl -X POST http://localhost:5000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "I am feeling stressed today"}'
```

## 🌐 Website Integration

### Option 1: Simple HTML Integration

Add this to your website:

```html
<!DOCTYPE html>
<html>
<head>
    <title>Police Wellness Assistant</title>
    <style>
        .police-bot-chat {
            max-width: 600px;
            margin: 20px auto;
            border: 1px solid #ccc;
            border-radius: 8px;
            overflow: hidden;
        }
        
        .chat-header {
            background: #1e40af;
            color: white;
            padding: 15px;
            text-align: center;
        }
        
        .chat-messages {
            height: 400px;
            overflow-y: auto;
            padding: 15px;
            background: #f8fafc;
        }
        
        .message {
            margin-bottom: 10px;
            padding: 10px;
            border-radius: 8px;
        }
        
        .user-message {
            background: #dbeafe;
            margin-left: 20%;
        }
        
        .bot-message {
            background: white;
            margin-right: 20%;
        }
        
        .chat-input {
            display: flex;
            padding: 15px;
            background: white;
        }
        
        .chat-input input {
            flex: 1;
            padding: 10px;
            border: 1px solid #ccc;
            border-radius: 4px;
            margin-right: 10px;
        }
        
        .chat-input button {
            padding: 10px 20px;
            background: #1e40af;
            color: white;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        
        .wellness-tips {
            padding: 15px;
            background: #f0f9ff;
            border-top: 1px solid #ccc;
        }
    </style>
</head>
<body>
    <div id="police-bot-container"></div>
    
    <script src="static/js/police-bot-client.js"></script>
    <script>
        // Initialize the Police Bot UI
        const policeBot = new PoliceBotUI('police-bot-container');
    </script>
</body>
</html>
```

### Option 2: React Integration

```jsx
import React, { useState, useEffect } from 'react';
import { PoliceBotClient } from './police-bot-client.js';

function PoliceBotChat() {
    const [messages, setMessages] = useState([]);
    const [input, setInput] = useState('');
    const [isProcessing, setIsProcessing] = useState(false);
    const [wellnessTips, setWellnessTips] = useState([]);
    
    const client = new PoliceBotClient('http://localhost:5000');
    
    const sendMessage = async () => {
        if (!input.trim() || isProcessing) return;
        
        const userMessage = { text: input, sender: 'user', timestamp: Date.now() };
        setMessages(prev => [...prev, userMessage]);
        setInput('');
        setIsProcessing(true);
        
        try {
            await client.sendMessage(
                input,
                (response) => {
                    const botMessage = { 
                        text: response.text, 
                        sender: 'bot', 
                        timestamp: Date.now() 
                    };
                    setMessages(prev => [...prev, botMessage]);
                    setWellnessTips(response.wellness_tips || []);
                },
                (error) => {
                    const errorMessage = { 
                        text: `Error: ${error}`, 
                        sender: 'bot', 
                        timestamp: Date.now() 
                    };
                    setMessages(prev => [...prev, errorMessage]);
                }
            );
        } finally {
            setIsProcessing(false);
        }
    };
    
    return (
        <div className="police-bot-chat">
            <div className="chat-header">
                <h3>🛡️ Police Wellness Assistant</h3>
            </div>
            
            <div className="chat-messages">
                {messages.map((msg, index) => (
                    <div key={index} className={`message ${msg.sender}-message`}>
                        {msg.text}
                    </div>
                ))}
            </div>
            
            <div className="chat-input">
                <input
                    type="text"
                    value={input}
                    onChange={(e) => setInput(e.target.value)}
                    onKeyPress={(e) => e.key === 'Enter' && sendMessage()}
                    placeholder="Type your message..."
                    disabled={isProcessing}
                />
                <button onClick={sendMessage} disabled={isProcessing}>
                    {isProcessing ? 'Processing...' : 'Send'}
                </button>
            </div>
            
            {wellnessTips.length > 0 && (
                <div className="wellness-tips">
                    <h4>Wellness Tips</h4>
                    <ul>
                        {wellnessTips.map((tip, index) => (
                            <li key={index}>{tip}</li>
                        ))}
                    </ul>
                </div>
            )}
        </div>
    );
}

export default PoliceBotChat;
```

## 🤖 Adding a Third Local LLM

You can enhance the system with additional local LLMs for specialized tasks:

### Option 1: Emotion Analysis LLM

```python
# Add to police_runtime.py
def get_emotion_llm_response(self, text: str) -> str:
    """Get emotion analysis from a dedicated LLM"""
    try:
        # You can use a smaller, specialized model for emotion analysis
        data = {
            "model": "emotion-analyzer",  # Different Ollama model
            "prompt": f"Analyze the emotional state of this text: '{text}'. Respond with only: stressed, positive, negative, or neutral.",
            "stream": False,
            "options": {
                "temperature": 0.1,  # Lower temperature for consistent analysis
                "max_tokens": 10
            }
        }
        
        response = requests.post(self.ollama_url, json=data, timeout=10)
        response.raise_for_status()
        
        result = response.json()
        emotion = result.get("response", "").strip().lower()
        
        # Validate emotion
        valid_emotions = ["stressed", "positive", "negative", "neutral"]
        return emotion if emotion in valid_emotions else "neutral"
        
    except Exception as e:
        logger.error(f"Error in emotion analysis: {e}")
        return "neutral"
```

### Option 2: Wellness Recommendation LLM

```python
def get_wellness_llm_response(self, emotional_state: str, context: str = "") -> list:
    """Get personalized wellness recommendations from a specialized LLM"""
    try:
        prompt = f"""
        As a wellness expert for police officers, provide 3-4 specific, actionable wellness tips for someone who is feeling {emotional_state}.
        
        Context: {context}
        
        Focus on:
        - Quick, practical interventions (2-5 minutes)
        - Stress management techniques
        - Physical wellness (hydration, movement)
        - Mental wellness (mindfulness, perspective)
        
        Respond with only the tips, one per line, no numbering.
        """
        
        data = {
            "model": "wellness-expert",  # Specialized wellness model
            "prompt": prompt,
            "stream": False,
            "options": {
                "temperature": 0.7,
                "max_tokens": 200
            }
        }
        
        response = requests.post(self.ollama_url, json=data, timeout=15)
        response.raise_for_status()
        
        result = response.json()
        tips_text = result.get("response", "").strip()
        
        # Parse tips into list
        tips = [tip.strip() for tip in tips_text.split('\n') if tip.strip()]
        return tips[:4]  # Limit to 4 tips
        
    except Exception as e:
        logger.error(f"Error in wellness recommendations: {e}")
        return self.generate_wellness_tips(emotional_state)  # Fallback
```

### Option 3: Multi-Model Setup

Create a model manager to handle multiple LLMs:

```python
class ModelManager:
    def __init__(self):
        self.models = {
            "primary": "police-bot",      # Main conversation
            "emotion": "emotion-analyzer", # Emotion analysis
            "wellness": "wellness-expert", # Wellness recommendations
            "kannada": "kannada-assistant" # Kannada language support
        }
    
    def get_response(self, model_type: str, prompt: str, **kwargs) -> str:
        """Get response from specified model"""
        model_name = self.models.get(model_type, "police-bot")
        
        data = {
            "model": model_name,
            "prompt": prompt,
            "stream": False,
            **kwargs
        }
        
        response = requests.post("http://localhost:11434/api/generate", json=data)
        return response.json().get("response", "").strip()
```

## 🔧 Configuration

### Environment Variables

Create a `.env` file:

```env
# Ollama Configuration
OLLAMA_URL=http://localhost:11434
OLLAMA_MODEL=police-bot

# F5-TTS Configuration
F5TTS_CKPT=C:\Users\Samarth Kadam\Voice-train\F5-TTS\ckpts\my_speak\model_last.pt
F5TTS_SCRIPT=C:\Users\Samarth Kadam\Voice-train\F5-TTS\src\f5_tts\infer\infer_cli.py

# Web API Configuration
WEB_PORT=5000
WEB_HOST=0.0.0.0

# Security
API_KEY=your-secret-api-key
```

### CORS Configuration

For production deployment, configure CORS properly:

```python
# In web_api.py
from flask_cors import CORS

app = Flask(__name__)
CORS(app, origins=[
    "http://localhost:3000",  # React dev server
    "http://your-website.com", # Production website
    "https://your-website.com"
])
```

## 🚀 Production Deployment

### Using Gunicorn

```bash
# Install gunicorn
pip install gunicorn

# Start production server
gunicorn -w 4 -b 0.0.0.0:5000 web_api:app
```

### Using Docker

```dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 5000

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "web_api:app"]
```

### Systemd Service (Linux)

```ini
# /etc/systemd/system/police-bot.service
[Unit]
Description=Police Bot AI Runtime
After=network.target

[Service]
Type=simple
User=police-bot
WorkingDirectory=/opt/police-bot-runtime
Environment=PATH=/opt/police-bot-runtime/venv/bin
ExecStart=/opt/police-bot-runtime/venv/bin/python web_api.py
Restart=always

[Install]
WantedBy=multi-user.target
```

## 🔒 Security Considerations

1. **API Authentication**: Add API key validation
2. **Rate Limiting**: Implement request rate limiting
3. **Input Validation**: Sanitize all user inputs
4. **HTTPS**: Use SSL/TLS in production
5. **Firewall**: Restrict access to necessary ports only

## 📊 Monitoring and Logging

```python
# Add to web_api.py
import logging
from logging.handlers import RotatingFileHandler

# Configure logging
if not app.debug:
    file_handler = RotatingFileHandler('logs/police_bot.log', maxBytes=10240, backupCount=10)
    file_handler.setFormatter(logging.Formatter(
        '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
    ))
    file_handler.setLevel(logging.INFO)
    app.logger.addHandler(file_handler)
    app.logger.setLevel(logging.INFO)
    app.logger.info('Police Bot startup')
```

## 🧪 Testing

### API Testing

```bash
# Test chat endpoint
curl -X POST http://localhost:5000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "I am feeling stressed today"}'

# Test health endpoint
curl http://localhost:5000/health

# Test status endpoint
curl http://localhost:5000/api/status
```

### Load Testing

```python
import requests
import time
import threading

def test_load():
    for i in range(10):
        response = requests.post('http://localhost:5000/api/chat', 
                               json={'message': f'Test message {i}'})
        print(f'Request {i}: {response.status_code}')

# Run multiple threads
threads = [threading.Thread(target=test_load) for _ in range(5)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()
```

## 🎯 Next Steps

1. **Voice Avatar**: Add a visual avatar that speaks
2. **Multi-language**: Implement Kannada language support
3. **Session Management**: Add user session tracking
4. **Analytics**: Track usage patterns and wellness trends
5. **Mobile App**: Create a mobile companion app
6. **Integration**: Connect with existing police systems

## 📞 Support

For technical support or questions:
- Check the logs in the `logs/` directory
- Verify all services are running: `python setup.py`
- Test individual components: `python police_runtime.py`
- Check API health: `curl http://localhost:5000/health`

---

**Remember**: This system is designed to support the mental wellness of police personnel. Always prioritize their privacy and well-being in any modifications or deployments.