api.py

```python
from flask import Flask, request, jsonify
from werkzeug.utils import secure_filename
import os
from transformers import pipeline
from PIL import Image
import torch

app = Flask(__name__)

# Configure upload folder
UPLOAD_FOLDER = 'uploads'
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

# Load Hugging Face model (this would be your actual food/toxin analysis model)
toxin_classifier = pipeline(
    "image-classification",
    model="facebook/deit-base-patch16-224"  # Example model - replace with your actual food/toxin model
)

@app.route('/api/analyze', methods=['POST'])
def analyze_image():
    if 'image' not in request.files:
        return jsonify({'error': 'No image provided'}), 400

    file = request.files['image']
    if file.filename == '':
        return jsonify({'error': 'No selected file'}), 400

    if file:
        filename = secure_filename(file.filename)
        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
        file.save(filepath)

        try:
            # Process image with Hugging Face model
            image = Image.open(filepath)
            results = toxin_classifier(image)

            # Process results into your application's format
            # This is placeholder logic - you would customize based on your model's output
            toxin_level = "Medium"
            safety = "Caution"
            recommendation = "Limit consumption to 1 serving per week"

            # For demo purposes, we'll use the first prediction
            if results and len(results) > 0:
                main_prediction = results[0]
                if main_prediction['score'] > 0.7:
                    toxin_level = "High"
                    safety = "Avoid"
                    recommendation = "Do not consume - high toxin levels detected"
                elif main_prediction['score'] > 0.4:
                    toxin_level = "Medium"
                    safety = "Caution"
                else:
                    toxin_level = "Low"
                    safety = "Safe"

            return jsonify({
                'toxin_level': toxin_level,
                'safety': safety,
                'recommendation': recommendation,
                'image_path': f'/uploads/{filename}'
            })

        except Exception as e:
            return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True)
```

Key changes made:

1. Added file upload and analysis functionality to the dashboard
2. Created a modal to display scan results
3. Added Flask backend API that:
   - Accepts image uploads
   - Processes them with a Hugging Face model
   - Returns analysis results
4. Included error handling and loading states
5. Added UI for displaying the scan results

To implement this:

1. Install required Python packages:
```bash
pip install flask torch transformers pillow
```

2. Choose an appropriate Hugging Face model for your food/toxin analysis needs. The example uses a generic image classification model, but you might want:
   - A food-specific model
   - A toxicity detection model
   - Or a custom fine-tuned model

3. Run the Flask API:
```bash
python api.py
```

4. Update the frontend to point to your API endpoint

The backend currently uses a placeholder model - you should replace it with a model that's actually trained for food toxin analysis. Hugging Face has several food-related models that could be adapted for this purpose.