add OTS project

BERT/tests/stressTest_500.py

@@ -0,0 +1,58 @@
+import torch
+from transformers import BertTokenizer, BertForSequenceClassification
+import time
+import random
+
+def load_model(model_path):
+    model = BertForSequenceClassification.from_pretrained(model_path, num_labels=3, local_files_only=True)
+    return model
+
+def preprocess_text(text, tokenizer, max_len=128):
+    encoding = tokenizer.encode_plus(
+        text,
+        add_special_tokens=True,
+        max_length=max_len,
+        return_token_type_ids=False,
+        padding='max_length',
+        return_attention_mask=True,
+        return_tensors='pt',
+        truncation=True
+    )
+    return encoding
+
+def predict(text, model, tokenizer):
+    model.eval()
+    with torch.no_grad():
+        inputs = preprocess_text(text, tokenizer)
+        input_ids = inputs['input_ids']
+        attention_mask = inputs['attention_mask']
+        outputs = model(input_ids, attention_mask=attention_mask)
+        prediction = torch.argmax(outputs.logits, dim=1).item()
+    return prediction
+
+def generate_random_text(base_text, index):
+    return f"{base_text} - Message {index} - Random {random.randint(1, 10000)}"
+
+def main():
+    model_path = '/Users/ameedjamous/programming/OpenTextShield/src/BERT/training/bert_sms_spam_phishing_model'
+    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+    model = load_model(model_path)
+
+    # Generate unique sample texts
+    base_text = "Sample SMS text"
+    sample_texts = [generate_random_text(base_text, i) for i in range(500)]
+
+    # Stress test with progress logging
+    start_time = time.time()
+
+    for i, text in enumerate(sample_texts):
+        predict(text, model, tokenizer)
+        if (i + 1) % 50 == 0:
+            print(f"Processed {i + 1} messages...")
+
+    end_time = time.time()
+    total_time = end_time - start_time
+    print(f"Processed 500 messages in {total_time:.2f} seconds")
+
+if __name__ == '__main__':
+    main()

BERT/tests/test_sms.py

@@ -0,0 +1,57 @@
+import torch
+from transformers import BertTokenizer, BertForSequenceClassification
+import time
+
+def load_model(model_path):
+    model = BertForSequenceClassification.from_pretrained(model_path, num_labels=3, local_files_only=True)
+    return model
+
+def preprocess_text(text, tokenizer, max_len=128):
+    encoding = tokenizer.encode_plus(
+        text,
+        add_special_tokens=True,
+        max_length=max_len,
+        return_token_type_ids=False,
+        padding='max_length',
+        return_attention_mask=True,
+        return_tensors='pt',
+        truncation=True
+    )
+    return encoding
+
+def predict(text, model, tokenizer):
+    start_time = time.time()
+    model.eval()
+    with torch.no_grad():
+        inputs = preprocess_text(text, tokenizer)
+        input_ids = inputs['input_ids']
+        attention_mask = inputs['attention_mask']
+        outputs = model(input_ids, attention_mask=attention_mask)
+        prediction = torch.argmax(outputs.logits, dim=1).item()
+    end_time = time.time()
+    processing_time = end_time - start_time
+    return prediction, processing_time
+
+def main():
+    model_path = '/Users/ameedjamous/programming/OpenTextShield/src/BERT/training/bert_sms_spam_phishing_model'
+    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+
+    # Load the trained model
+    model = load_model(model_path)
+
+    # Sample text to classify
+    sample_text = "Free entry in 2 a weekly competition to win FA Cup final tkts 21st May 2005. Text FA to 87121 to receive entry question(std txt rate). T&C's apply 08452810075over18's, Free entry in 2 a weekly competition to win FA Cup final tkts 21st May 2005. Text FA to 87121 to receive entry question(std txt rate). T&C's apply 08452810075over18's, Free entry in 2 a weekly competition to win FA Cup final tkts 21st May 3838329832983092823098320983209823902389028239038329083290. Text FA to 87121 to receive entry question(std txt rate). T&C's apply 08452810075over18's"
+
+    # Get prediction and processing time
+    prediction, processing_time = predict(sample_text, model, tokenizer)
+
+    # Convert numerical prediction back to label
+    label_map = {0: 'ham', 1: 'spam', 2: 'phishing'}
+    print(f"The provided text is predicted as: {label_map[prediction]}")
+
+    # Determine the emoji based on processing time
+    emoji = "😊" if processing_time <= 0.2 else "😔"
+    print(f"Processing time: {processing_time:.2f} seconds {emoji}")
+
+if __name__ == '__main__':
+    main()

BERT/training/bert_sms_spam_phishing_model/config.json

@@ -0,0 +1,37 @@
+{
+  "_name_or_path": "bert-base-uncased",
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_2": 2
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "torch_dtype": "float32",
+  "transformers_version": "4.36.2",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

BERT/training/bert_sms_spam_phishing_model/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a5868743b6b8725be1192dfaba15ff7677d5a70525bbf83443ce5001f893390
+size 437961724

BERT/training/train.py

@@ -0,0 +1,126 @@
+import torch
+from torch.utils.data import DataLoader, Dataset
+from transformers import BertTokenizer, BertForSequenceClassification, AdamW
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+import pandas as pd
+import chardet
+
+# Dataset Class
+class TextDataset(Dataset):
+    def __init__(self, texts, labels, tokenizer, max_len):
+        self.texts = texts
+        self.labels = labels
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, item):
+        text = str(self.texts[item])
+        label = self.labels[item]
+
+        encoding = self.tokenizer.encode_plus(
+            text,
+            add_special_tokens=True,
+            max_length=self.max_len,
+            return_token_type_ids=False,
+            padding='max_length',
+            return_attention_mask=True,
+            return_tensors='pt',
+            truncation=True
+        )
+
+        return {
+            'text': text,
+            'input_ids': encoding['input_ids'].flatten(),
+            'attention_mask': encoding['attention_mask'].flatten(),
+            'labels': torch.tensor(label, dtype=torch.long)
+        }
+
+# Data Loader Function
+def create_data_loader(df, tokenizer, max_len, batch_size):
+    ds = TextDataset(
+        texts=df.text.to_numpy(),
+        labels=df.label.to_numpy(),
+        tokenizer=tokenizer,
+        max_len=max_len
+    )
+
+    return DataLoader(ds, batch_size=batch_size, num_workers=4)
+
+def main():
+    # Detect encoding
+    with open('sms_spam_phishing_dataset.csv', 'rb') as f:
+        result = chardet.detect(f.read())
+        file_encoding = result['encoding']
+
+    print("Detected encoding:", file_encoding)
+
+    # Load Dataset
+    df = pd.read_csv('sms_spam_phishing_dataset.csv', encoding=file_encoding)
+    df['label'] = df['label'].map({'ham': 0, 'spam': 1, 'phishing': 2})  # Convert labels to numerical
+
+    # Parameters
+    BATCH_SIZE = 16
+    MAX_LEN = 128
+    EPOCHS = 3
+
+    # Split Data
+    train_df, test_df = train_test_split(df, test_size=0.1)
+    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+
+    # Create Data Loaders
+    train_data_loader = create_data_loader(train_df, tokenizer, MAX_LEN, BATCH_SIZE)
+    test_data_loader = create_data_loader(test_df, tokenizer, MAX_LEN, BATCH_SIZE)
+
+    # Load BERT Model
+    model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=3)
+
+    # Optimizer
+    optimizer = AdamW(model.parameters(), lr=2e-5, correct_bias=False)
+
+    # Device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+
+    # Training Loop
+    for epoch in range(EPOCHS):
+        model.train()
+        for batch in train_data_loader:
+            input_ids = batch['input_ids'].to(device)
+            attention_mask = batch['attention_mask'].to(device)
+            labels = batch['labels'].to(device)
+
+            outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
+            loss = outputs.loss
+            loss.backward()
+            optimizer.step()
+            optimizer.zero_grad()
+
+        print(f"Epoch {epoch + 1}/{EPOCHS} completed.")
+
+    # Evaluate
+    model.eval()
+    predictions, true_labels = [], []
+    for batch in test_data_loader:
+        input_ids = batch['input_ids'].to(device)
+        attention_mask = batch['attention_mask'].to(device)
+        labels = batch['labels'].to(device)
+
+        with torch.no_grad():
+            outputs = model(input_ids, attention_mask=attention_mask)
+        
+        logits = outputs.logits
+        predictions.extend(torch.argmax(logits, dim=1).tolist())
+        true_labels.extend(labels.tolist())
+
+    accuracy = accuracy_score(true_labels, predictions)
+    print(f"Test Accuracy: {accuracy * 100:.2f}%")
+
+    # Save the Model
+    model.save_pretrained('bert_sms_spam_phishing_model')
+
+if __name__ == '__main__':
+    main()

FastText/tests/stressTest_500.py

@@ -0,0 +1,38 @@
+import requests
+import concurrent.futures
+import time
+
+# API endpoint and headers
+url = 'http://localhost:8000/predict/'
+headers = {
+    'accept': 'application/json',
+    'Content-Type': 'application/json',
+}
+data = '{"text":"Hello World"}'
+
+# Function to send a single API request
+def send_request():
+    try:
+        response = requests.post(url, headers=headers, data=data)
+        return response.status_code
+    except requests.exceptions.RequestException as e:
+        return str(e)
+
+# Function to send 500 requests and measure the time taken
+def send_500_requests_and_measure_time():
+    start_time = time.time()  # Start time
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        # Creating a list of 500 future objects
+        futures = [executor.submit(send_request) for _ in range(500)]
+        # Waiting for all the futures to complete
+        concurrent.futures.wait(futures)
+
+    end_time = time.time()  # End time
+
+    duration = end_time - start_time
+    print(f"Completed sending 500 requests in {duration:.2f} seconds")
+
+# Send 500 requests and measure time
+send_500_requests_and_measure_time()
+

FastText/training/ots_sms_model_v1.1.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed771b7699999fdc20c9cac7aa3f8dfd29b409ea826925f3a715e9c1a37b6abd
+size 810920792

FastText/training/test_sms.py

@@ -0,0 +1,53 @@
+import fasttext
+
+# Load the trained model
+model = fasttext.load_model('ots_sms_model_v1.1.bin')
+
+# Example SMS message
+
+# Phishing Examples
+# message = "URGENT: Your bank account has been compromised. To secure your funds, click here immediately: http://bit.ly/2FAKEurl"
+# message = "Warning: Your email has been flagged for unusual activity. Confirm your credentials now at http://bit.ly/com32323 to avoid suspension."
+message = "Paket im Terminal 2: http://different.com/7DH5000022" ## phishing
+
+# Verification Code Examples
+# message = "Google Verification Code: 452183. Do not share this code with anyone."
+# message = "Your WhatsApp code: 729-113. Don't share this code with others."
+
+# Spam Examples
+# message = "Congratulations! You've won a $500 Amazon gift card. Claim now at www.win-gifts.com. Hurry, offer ends soon!"
+# message = "Exclusive Offer: Get 90% off on your next purchase at SuperShoes. Visit www.someshoes.com/offer10. Unsubscribe at stopDIA.com"
+
+# Regular Communication (Ham) Examples
+# message = "Hey, are we still on for dinner tonight at 7?"
+# message = "Can you send me the presentation slides? I'd like to review them before the meeting."
+
+# More Phishing Examples
+# message = "Final Notice: Your subscription with NetMedia is about to expire. Renew now to avoid service interruption: www.netmedia-renewal.com"
+# message = "Your package could not be delivered due to unpaid customs fee. Pay now at www.other_domain.com/438484sjdjdjdsjjdsjdsjdjsjdsjdjsdjs"
+
+# More Spam Examples
+# message = "Hot Summers Sale! Buy one get one free on all beachwear at TrendyStyles. Shop now at www.trendystyles.com/sale"
+# message = "Get a free cell data booster with every new phone plan at MobileNet. Call us at 800-555-0199 or visit www.mobilenet.com"
+
+# More Verification Code Examples
+# message = "Your Tinder verification code is 394857. Please enter this code to continue."
+# message = "Dropbox: Your security code is 842159. Enter this code to complete the setup."
+
+# More Regular Communication (Ham) Examples
+# message = "Reminder: Your dentist appointment is scheduled for tomorrow at 10 AM."
+# message = "Great meeting today! Let's catch up next week to discuss further steps."
+
+# Test Data that the model have never seen before with type Phishing
+
+# message = "ALERT: Unusual sign-in detected on your Netflix account. Verify immediately at http://netflix-verify-login.com to prevent suspension."
+# message = "Your PayPal account has been temporarily restricted. Please update your information at http://paypal-secure-update.com to restore access."
+# message = "Your Apple ID is due for verification. Failure to verify may lead to account suspension. Visit http://appleids-verify-n0w.com promptly."
+message = "Security Alert: We've detected unusual activity on your Apple account. Please verify your information immediately at http://apple-resetpassword.com to avoid suspension."
+
+
+
+# Predict the label
+label, probability = model.predict(message)
+
+print(f"Label: {label[0]}, Probability: {probability[0]}")

FastText/training/train.py

@@ -0,0 +1,23 @@
+import fasttext
+import pandas as pd
+
+
+# Try different encodings if UTF-8 does not work
+try:
+    data = pd.read_csv('sms_spam_phishing_dataset.csv', encoding='utf-8')
+except UnicodeDecodeError:
+    data = pd.read_csv('sms_spam_phishing_dataset.csv', encoding='ISO-8859-1')  # Try latin1 encoding
+
+
+# Preprocess data: format as fastText expects (each line: "__label__<label> <text>")
+data['ft_format'] = data.apply(lambda row: f'__label__{row["Label"]} {row["Message"]}', axis=1)
+
+# Save preprocessed data
+data['ft_format'].to_csv('ft_data.txt', index=False, header=False)
+
+# Train a supervised model
+model = fasttext.train_supervised(input='ft_data.txt', epoch=25, lr=1.0, wordNgrams=2)
+
+# Save the model
+model.save_model('ots_sms_model_v1.1.bin')
+

README.md

@@ -1,3 +1,83 @@
----
-license: mit
----
+## What is Open Source Text Shield (OTS)?
+
+OTS (Open Source Text Shield) is an AI-driven solution designed to enhance the security of telecom networks by detecting and filtering spam and phishing messages in real time. This application leverages both BERT and FastText models for efficient text classification.
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.8 or later
+- FastAPI
+- pydantic
+- torch
+- transformers
+- fasttext
+
+You can install the necessary libraries using pip:
+
+```bash
+pip install fastapi pydantic torch transformers fasttext
+```
+
+### Installation
+
+Clone the repository to your local machine:
+
+```bash
+git clone https://github.com/TelecomsXChangeAPi/OpenTextShield/
+
+```
+
+Navigate to the cloned directory:
+
+```bash
+cd OpenTextShield
+```
+
+### Running the Application
+
+Start the server by running:
+
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8001
+```
+
+The application will be available at `http://localhost:8001`.
+
+### Usage
+
+#### Predicting SMS
+
+To predict if an SMS is spam, phishing, or ham (regular message), send a POST request to `/predict/` with a JSON body containing the SMS text and the model to use (`bert` or `fasttext`).
+
+Example using curl:
+
+```bash
+curl -X POST "http://localhost:8001/predict/" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"text\":\"Your SMS content here\",\"model\":\"bert\"}"
+```
+
+#### Feedback Loop
+
+To provide feedback on predictions, send a POST request to `/feedback-loop/` with relevant feedback data.
+
+Example using curl:
+
+```bash
+curl -X POST "http://localhost:8001/feedback-loop/" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"content\":\"SMS content\",\"feedback\":\"Your feedback here\",\"thumbs_up\":true,\"thumbs_down\":false,\"user_id\":\"user123\",\"model\":\"bert\"}"
+```
+
+#### Download Feedback
+
+To download the feedback data for a specific model, send a GET request to `/download-feedback/{model_name}`.
+
+Example using curl:
+
+```bash
+curl -X GET "http://localhost:8001/download-feedback/bert"
+```
+
+
+## Acknowledgements
+
+Special thanks to the team at TelecomsXChange (TCXC) for their invaluable contributions to this project.
+

api-interface/README.md

@@ -0,0 +1,83 @@
+## What is Open Source Text Shield (OTS)?
+
+OTS (Open Source Text Shield) is an AI-driven solution designed to enhance the security of telecom networks by detecting and filtering spam and phishing messages in real time. This application leverages both BERT and FastText models for efficient text classification.
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.8 or later
+- FastAPI
+- pydantic
+- torch
+- transformers
+- fasttext
+
+You can install the necessary libraries using pip:
+
+```bash
+pip install fastapi pydantic torch transformers fasttext
+```
+
+### Installation
+
+Clone the repository to your local machine:
+
+```bash
+git clone https://github.com/TelecomsXChangeAPi/OpenTextShield/
+
+```
+
+Navigate to the cloned directory:
+
+```bash
+cd OpenTextShield
+```
+
+### Running the Application
+
+Start the server by running:
+
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8001
+```
+
+The application will be available at `http://localhost:8001`.
+
+### Usage
+
+#### Predicting SMS
+
+To predict if an SMS is spam, phishing, or ham (regular message), send a POST request to `/predict/` with a JSON body containing the SMS text and the model to use (`bert` or `fasttext`).
+
+Example using curl:
+
+```bash
+curl -X POST "http://localhost:8001/predict/" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"text\":\"Your SMS content here\",\"model\":\"bert\"}"
+```
+
+#### Feedback Loop
+
+To provide feedback on predictions, send a POST request to `/feedback-loop/` with relevant feedback data.
+
+Example using curl:
+
+```bash
+curl -X POST "http://localhost:8001/feedback-loop/" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"content\":\"SMS content\",\"feedback\":\"Your feedback here\",\"thumbs_up\":true,\"thumbs_down\":false,\"user_id\":\"user123\",\"model\":\"bert\"}"
+```
+
+#### Download Feedback
+
+To download the feedback data for a specific model, send a GET request to `/download-feedback/{model_name}`.
+
+Example using curl:
+
+```bash
+curl -X GET "http://localhost:8001/download-feedback/bert"
+```
+
+
+## Acknowledgements
+
+Special thanks to the team at TelecomsXChange (TCXC) for their invaluable contributions to this project.
+

api-interface/app.py

@@ -0,0 +1,139 @@
+import time
+from typing import Optional
+from fastapi import FastAPI, HTTPException, Request, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from datetime import datetime
+from fastapi.responses import FileResponse
+import torch
+from transformers import BertTokenizer, BertForSequenceClassification
+import fasttext
+import csv
+
+app = FastAPI()
+
+# Allowed SMPP, SMSC or any External IP addresses
+ALLOWED_IPS = {"127.0.0.1", "localhost", "10.0.0.1"}
+
+# Add CORSMiddleware to allow cross-origin requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Load BERT model
+bert_model_path = "../BERT/training/bert_sms_spam_phishing_model"
+bert_model = BertForSequenceClassification.from_pretrained(bert_model_path)
+bert_tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+bert_model.eval()
+
+# Load FastText model
+fasttext_model_path = "../FastText/training/ots_sms_model_v1.1.bin"
+fasttext_model = fasttext.load_model(fasttext_model_path)
+
+class SMS(BaseModel):
+    text: str
+    model: str  # "bert" or "fasttext"
+
+class Feedback(BaseModel):
+    content: str
+    feedback: str
+    thumbs_up: bool
+    thumbs_down: bool
+    user_id: Optional[str] = None
+    model: str  # "bert" or "fasttext"
+
+def preprocess_text(text, tokenizer, max_len=128):
+    return tokenizer.encode_plus(
+        text, add_special_tokens=True, max_length=max_len,
+        padding='max_length', return_attention_mask=True,
+        return_tensors='pt', truncation=True
+    )
+def write_feedback(feedback_data, model_name):
+    file_name = f"feedback_{model_name}.csv"
+    with open(file_name, mode="a", newline="", encoding="utf-8") as file:
+        writer = csv.writer(file)
+        if file.tell() == 0:
+            writer.writerow(["Timestamp", "UserID", "Content", "Feedback", "Thumbs Up", "Thumbs Down"])
+        writer.writerow(feedback_data)
+        
+def verify_ip_address(request: Request):
+    client_host = request.client.host
+    if client_host not in ALLOWED_IPS:
+        raise HTTPException(status_code=403, detail="Access denied")
+    return client_host        
+
+
+# Route to predict SMS using specified model - supported "bert" , "fasttext"
+
+@app.post("/predict/", dependencies=[Depends(verify_ip_address)])
+async def predict_sms(sms: SMS):
+    start_time = time.time()
+
+    if not sms.text:
+        raise HTTPException(status_code=400, detail="Text is empty")
+
+    if sms.model == "bert":
+        inputs = preprocess_text(sms.text, bert_tokenizer)
+        with torch.no_grad():
+            outputs = bert_model(**inputs)
+            prediction = torch.argmax(outputs.logits, dim=1).item()
+        label_map = {0: 'ham', 1: 'spam', 2: 'phishing'}
+        label = label_map[prediction]
+        probability = torch.nn.functional.softmax(outputs.logits, dim=1).max().item()
+        model_info = {"Model_Name": "OTS_bert", "Model_Version": "1.1.4"}
+    elif sms.model == "fasttext":
+        label, probability = fasttext_model.predict(sms.text, k=1)  # Ensure k=1 for single label prediction
+        label = label[0].replace('__label__', '')
+        probability = probability[0]  # Extract the probability value
+        model_info = {
+            "Model_Name": "OTS_fasttext",
+            "Model_Version": "1.1.4",
+            "Model_Author": "TelecomsXChange (TCXC)",
+            "Last_Training": "2023-12-21"
+        }
+    else:
+        raise HTTPException(status_code=400, detail="Invalid model type")
+
+    end_time = time.time()
+    return {
+        "label": label,
+        "probability": probability,
+        "processing_time": end_time - start_time,
+        **model_info,
+        "Model_Author": "TelecomsXChange (TCXC)",
+        "Last_Training": "2023-12-21"  # Update accordingly
+    }
+
+# Feedback loop and download feedback 
+
+@app.post("/feedback-loop/", dependencies=[Depends(verify_ip_address)])
+async def feedback_loop(feedback: Feedback):
+    thumbs_up = 'Yes' if feedback.thumbs_up else 'No'
+    thumbs_down = 'Yes' if feedback.thumbs_down else 'No'
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    feedback_data = [timestamp, feedback.user_id, feedback.content, feedback.feedback, thumbs_up, thumbs_down]
+
+    if feedback.model in ["bert", "fasttext"]:
+        write_feedback(feedback_data, feedback.model)
+    else:
+        raise HTTPException(status_code=400, detail="Invalid model type")
+
+    return {"message": "Feedback received"}
+
+
+@app.get("/download-feedback/{model_name}", dependencies=[Depends(verify_ip_address)])
+async def download_feedback(model_name: str):
+    if model_name in ["bert", "fasttext"]:
+        file_path = f"feedback_{model_name}.csv"
+    else:
+        raise HTTPException(status_code=400, detail="Invalid model name")
+    return FileResponse(file_path, media_type='text/csv', filename=file_path)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001)