Spaces:

IamSamkk
/

mindfull

Configuration error

mindfull / INTEGRATION_GUIDE.md

IamSamk

Mindfull Gradio Space deploy

27caffe 4 months ago

13.9 kB

# 🛡️ 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. 

	# 🛡️ 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.