Machine translation using traditional neural architecture (seq2seq models) had various issues due to rare-words, low accuracy and slow translation . Even after using various mechanisms like attention and residual connections the performance was only comparable (not better than) statistical phrase-based machine translations .
I can only think of this paper as a successful attempt to use LSTMs in the encoder, decoder setting (8 encoder and 8 decoder layers) to get comparable results (there might be other attempts too). AWD-LSTMs  perform remarkably better than other models.
In the machine translation task, the model should understand proper relation between translated words and the words being translated and their positioning. This can only be achieved by using knowledge representation (word embeddings/encoding) from both the languages.
That's why we need to use both encoder and decoder layers.
If you ask me, I would say the following code (taken from link) is the simplest model structure possible using a simple LSTM/seq2seq model.
from keras.models import Model
from keras.layers import Input, LSTM, Dense
# Define an input sequence and process it.
encoder_inputs = Input(shape=(None, num_encoder_tokens))
encoder = LSTM(latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs)
# We discard `encoder_outputs` and only keep the states.
encoder_states = [state_h, state_c]
# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(None, num_decoder_tokens))
# We set up our decoder to return full output sequences,
# and to return internal states as well. We don't use the
# return states in the training model, but we will use them in inference.
decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs,
decoder_dense = Dense(num_decoder_tokens, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
From your question, it seems you only want to define the model using only Keras's sequential layer. If that is the case then you must know that variable
encoder_states plays an important role in the aforementioned model's definition.
LSTMs are sequential models which means it works on a single word at a time and calculates hidden state for the next word in one iteration. The process is followed for all words in the input sequence (source language). Then the final hidden state is used in the decoder layer to compute the context for output sequence (destination language). That's why there is
initial_state=encoder_states in decoder LSTM layer definition. Without
encoder_states decoder LSTM won't know the context and your model will only give jibberish output.
are there successful attempts of doing sentence language translation with classic
Sadly the answer is No.
You can only try to understand how machine translation works and get comfortable with the complexity of the machine translation model definition. As this is the simplest model possible.
For more information, you can go through these papers. 1 2 3
I hope it helps.