diff --git a/api/NN_Fakenews_2.py b/api/NN_Fakenews_2.py
deleted file mode 100644
index 6e3d5653..00000000
--- a/api/NN_Fakenews_2.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import pandas as pd
-import pickle
-from Neural_Network2 import create_and_train_model
-
-
-def Neural_Network(texts_train,labels_train):
-    trained_model = create_and_train_model(texts_train, labels_train)
-
-# Saving the model
-    with open("nn_fakenews_model.pkl", "wb") as model_file:
-        pickle.dump(trained_model, model_file)
-
-
-    return trained_model
-
-
-
diff --git a/api/Neural_Network2.py b/api/Neural_Network2.py
index 1e1f0779..d839849b 100644
--- a/api/Neural_Network2.py
+++ b/api/Neural_Network2.py
@@ -1,4 +1,5 @@
 import csv
+import json
 import re
 import string
 import os
@@ -21,46 +22,58 @@ def preprocess_text(text):
     text = re.sub('\w*\d\w*', '', text)
     return text
 
-def create_and_train_model(train_texts, train_labels, epochs=5):
+def create_and_train_model(train_texts, train_labels,name, epochs=5):
+    # Cria um DataFrame do Pandas com os textos e rótulos de treino
     train_df = pd.DataFrame({'text': train_texts, 'label': train_labels})
+    # Aplica o pré-processamento aos textos
     train_df['text'] = train_df['text'].apply(preprocess_text)
 
+    # Cria um diretório para armazenar os textos de treino como arquivos individuais
     output_directory = 'arquivos_texto_treino_nn'
     os.makedirs(output_directory, exist_ok=True)
 
+    # Escreve cada texto em um arquivo separado dentro do diretório criado
     for index, row in train_df.iterrows():
         filename = os.path.join(output_directory, f'texto_{index}.txt')
         with open(filename, 'w', encoding='utf-8') as file:
             file.write(row['text'])
 
+    # Diretório de treino para o modelo
     treino_dir = output_directory
 
+    # Cria um conjunto de dados de texto usando a API de conjuntos de dados do TensorFlow
     train_dataset = tf.keras.utils.text_dataset_from_directory(
         treino_dir,
         batch_size=32,
         shuffle=True,
     )
 
+    # Parâmetros do modelo
     max_features = 20000
     embedding_dim = 128
     sequence_length = 500
 
+    # Cria uma camada de vetorização de texto
     vectorize_layer = TextVectorization(
         max_tokens=max_features,
         output_mode="int",
         output_sequence_length=sequence_length,
     )
 
+    # Adapta a camada de vetorização ao conjunto de dados de texto
     text_ds = train_dataset.map(lambda x, y: x)
     vectorize_layer.adapt(text_ds)
 
+    # Função para vetorizar o texto e manter os rótulos
     def vectorize_text(text, label):
         text = tf.expand_dims(text, -1)
         return vectorize_layer(text), label
 
+    # Aplica a vetorização ao conjunto de dados de treino
     train_ds = train_dataset.map(vectorize_text)
     train_ds = train_ds.cache().prefetch(buffer_size=10)
 
+    # Define a arquitetura do modelo
     inputs = tf.keras.Input(shape=(None,), dtype="int64")
     x = layers.Embedding(max_features, embedding_dim)(inputs)
     x = layers.Dropout(0.5)(x)
@@ -71,9 +84,60 @@ def vectorize_text(text, label):
     x = layers.Dropout(0.5)(x)
     predictions = layers.Dense(1, activation="sigmoid", name="predictions")(x)
 
+    # Cria e compila o modelo
     model = tf.keras.Model(inputs, predictions)
-
     model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"])
-    model.fit(train_ds, epochs=epochs)
 
-    return model
+    # Treina o modelo
+    history = model.fit(train_ds, epochs=epochs)
+    # Nome do arquivo
+    name = f"nn_{name}.pkl"
+    # Saving the model
+    with open(name, "wb") as model_file:
+        pickle.dump(model, model_file)   
+
+    # Obtém estatísticas do treinamento
+    training_stats = {
+        "loss": history.history['loss'],
+        "accuracy": history.history['accuracy']
+    }
+
+    # Retorna estatísticas como JSON
+    return json.dumps(training_stats)
+
+'''
+Com o nome do arquivo podemos fazer por exemplo:
+
+saved_model_filename = Neural_Network(texts_train, labels_train)
+
+Carregar o modelo treinado a partir do arquivo:
+with open(saved_model_filename, "rb") as model_file:
+    loaded_model = pickle.load(model_file)
+
+Agora, podemos usar loaded_model para fazer previsões, por exemplo:
+predictions = loaded_model.predict(new_texts)
+
+'''
+'''
+TESTE:
+
+df_true = pd.read_csv("Linguifai/api/training_df/True.csv")
+df_fake = pd.read_csv("Linguifai/api/training_df/Fake.csv")
+
+
+df_fake = df_fake.drop(['title', 'subject', 'date'], axis=1)
+df_true = df_true.drop(['title', 'subject', 'date'], axis=1)
+
+
+df_fake['text'] = df_fake["text"]
+df_true['text'] = df_true["text"]
+
+df_fake_train = df_fake[:5000]
+df_true_train = df_true[:5000]
+
+textos = df_fake_train['text'].tolist() + df_true_train['text'].tolist()
+labels = [0] * len(df_fake_train) + [1] * len(df_true_train)
+
+create_and_train_model(textos,labels,"Teste")
+
+'''
diff --git a/api/app.py b/api/app.py
index a4750b98..2c1fefe4 100644
--- a/api/app.py
+++ b/api/app.py
@@ -1,8 +1,10 @@
 from flask import Flask, jsonify, request
 from flask_cors import CORS
 from DataProcesser import DataProcesser
+from Neural_Network2 import create_and_train_model
 import os
 import nltk
+import pandas as pd
 import json
 nltk.download('wordnet')
 
@@ -46,5 +48,13 @@ def emotions_model():
     result = data_processer.classify_emotions()
     return jsonify({"result": result.to_json()})
 
+@app.route('/neural-network',methods=["POST"])
+def train_model():
+    received_data = request.get_json()
+    selected_data = received_data.get('data')
+    selected_label = received_data.get('label')
+    name = received_data.get('name')
+    return create_and_train_model(selected_data,selected_label,name) 
+
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=5000, debug=True)
\ No newline at end of file