diff --git a/NLTK-Tutorial.mdx b/NLTK-Tutorial.mdx
new file mode 100644
index 0000000..65d8a63
--- /dev/null
+++ b/NLTK-Tutorial.mdx
@@ -0,0 +1,184 @@
+---
+title: "NLTK Tutorial: A Beginner's Guide to Natural Language Processing with NLTK in Python"
+description: This tutorial is a beginner's guide to using NLTK (Natural Language Toolkit), a popular Python library for natural language processing. NLTK can be used for a wide range of tasks, such as text preprocessing, part-of-speech tagging, named entity recognition, and sentiment analysis. By following this tutorial, you will learn the basics of NLTK and be able to apply them to your own projects. Whether you are building a chatbot, a language translator, or a sentiment analysis tool, NLTK is a powerful tool that can help you get the job done. So, whether you are new to natural language processing or looking to expand your knowledge, this tutorial is a great place to start.
+image: "https://data-flair.training/blogs/wp-content/uploads/sites/2/2018/08/NLTK-NLP-with-Python.jpg"
+authorUsername: "d3wyan304"
+---
+
+## What is NLTK?
+
+NLTK (Natural Language Toolkit) is a popular Python library that provides tools and resources for working with human language data. It's a powerful tool for processing and analyzing text, and it's used by researchers, students, and developers in a variety of fields.
+
+In this tutorial, we'll cover the basics of NLTK, including how to install it, how to use it for text preprocessing, part-of-speech tagging, named entity recognition, and sentiment analysis.
+
+## Installing NLTK
+
+Before we get started with NLTK, we need to install it. You can install NLTK using pip, the Python package manager. 
+
+Open your command prompt or terminal and type the following command:
+
+```python
+pip install nltk
+```
+
+## Text Preprocessing
+
+Text preprocessing is the process of cleaning and preparing text data for analysis. NLTK provides several tools for text preprocessing, including:
+
+Tokenization: Breaking up text into individual words or phrases.
+Stopword Removal: Removing common words like "a", "an", "the", etc.
+Stemming: Reducing words to their root form (e.g. "running" becomes "run").
+Lemmatization: Reducing words to their base form (e.g. "running" becomes "run").
+Let's take a look at an example of how to use NLTK for text preprocessing:
+
+```python
+import nltk
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+from nltk.stem import PorterStemmer
+
+nltk.download('punkt')
+nltk.download('stopwords')
+
+# Example text
+text = "NLTK (Natural Language Toolkit) is a popular Python library for working with human language data. It's a powerful tool for processing and analyzing text."
+
+# Tokenize the text
+tokens = word_tokenize(text)
+
+# Remove stop words
+stop_words = set(stopwords.words('english'))
+filtered_tokens = [token for token in tokens if token.lower() not in stop_words]
+
+# Stem the tokens
+porter = PorterStemmer()
+stemmed_tokens = [porter.stem(token) for token in filtered_tokens]
+
+print(stemmed_tokens)
+```
+
+In this example, we first import the necessary NLTK modules and download the necessary resources (the 'punkt' resource for tokenization and the 'stopwords' resource for stopword removal).
+
+We then define some example text and tokenize it using word_tokenize(). We remove the stop words using a list comprehension, and then stem the remaining tokens using the PorterStemmer algorithm.
+
+The output of this script will be a list of stemmed tokens:
+
+```python
+['nltk', '(', 'natur', 'languag', 'toolkit', ')', 'popular', 'python', 'librari', 'work', 'human', 'languag', 'data', '.', 'power', 'tool', 'process', 'analyz', 'text', '.']
+```
+
+## Part-of-Speech Tagging
+
+Part-of-speech tagging is the process of identifying the part of speech of each word in a text (e.g. noun, verb, adjective, etc.). NLTK provides several tools for part-of-speech tagging, including the pos_tag() function.
+
+```python
+import nltk
+from nltk.tokenize import word_tokenize
+
+nltk.download('punkt')
+nltk.download('averaged_perceptron_tagger')
+
+# Example text
+text = "John saw the cat on the roof."
+
+# Tokenize the text
+tokens = word_tokenize(text)
+
+# Part-of-speech tagging
+pos_tags = nltk.pos_tag(tokens)
+
+print(pos_tags)
+```
+
+n this example, we first import the necessary NLTK modules and download the necessary resources (the 'punkt' resource for tokenization and the 'averaged_perceptron_tagger' resource for part-of-speech tagging).
+
+We then define some example text and tokenize it using word_tokenize(). We then use the pos_tag() function to perform part-of-speech tagging on the tokens.
+
+The output of this script will be a list of tuples, where each tuple contains a token and its corresponding part-of-speech tag:
+
+```python
+[('John', 'NNP'), ('saw', 'VBD'), ('the', 'DT'), ('cat', 'NN'), ('on', 'IN'), ('the', 'DT'), ('roof', 'NN'), ('.', '.')]
+```
+
+## Named Entity Recognition
+
+Named Entity Recognition (NER) is the process of identifying named entities (e.g. people, organizations, locations, etc.) in text. NLTK provides several tools for NER, including the ne_chunk() function.
+
+```python
+import nltk
+from nltk.tokenize import word_tokenize
+
+nltk.download('punkt')
+nltk.download('averaged_perceptron_tagger')
+nltk.download('maxent_ne_chunker')
+nltk.download('words')
+
+# Example text
+text = "John saw the Statue of Liberty in New York City."
+
+# Tokenize the text
+tokens = word_tokenize(text)
+
+# Part-of-speech tagging
+pos_tags = nltk.pos_tag(tokens)
+
+# Named entity recognition
+chunks = nltk.ne_chunk(pos_tags)
+
+print(chunks)
+```
+
+In this example, we first import the necessary NLTK modules and download the necessary resources (the 'punkt' resource for tokenization, the 'averaged_perceptron_tagger' resource for part-of-speech tagging, the 'maxent_ne_chunker' resource for NER, and the 'words' resource for NER).
+
+We then define some example text and tokenize it using word_tokenize(). We then use the pos_tag() function to perform part-of-speech tagging on the tokens, and then use the ne_chunk() function to perform NER on the part-of-speech tags.
+
+The output of this script will be a nested tree structure representing the named entities in the text:
+
+```text
+(S
+  (PERSON John/NNP)
+  saw/VBD
+  the/DT
+  (FACILITY Statue/NNP of/IN Liberty/NNP)
+  in/IN
+  (GPE New/NNP York/NNP City/NNP)
+  ./.
+)
+```
+## Sentiment Analysis
+
+Sentiment analysis is the process of determining the emotional tone of a piece of text (e.g. positive, negative, neutral, etc.). NLTK provides several tools for sentiment analysis, including the SentimentIntensityAnalyzer class.
+
+```python
+import nltk
+from nltk.sentiment import SentimentIntensityAnalyzer
+
+nltk.download('vader_lexicon')
+
+# Example text
+text = "I love NLTK. It's the best library for natural language processing!"
+
+# Sentiment analysis
+analyzer = SentimentIntensityAnalyzer()
+scores = analyzer.polarity_scores(text)
+
+print(scores)
+```
+
+In this example, we first import the necessary NLTK modules and download the necessary resources (the 'vader_lexicon' resource for sentiment analysis).
+
+We then define some example text and create a SentimentIntensityAnalyzer object. We then use the polarity_scores() method of the SentimentIntensityAnalyzer class to perform sentiment analysis on the text.
+
+The output of this script will be a dictionary containing the sentiment scores for the text:
+
+```text
+{'neg': 0.0, 'neu': 0.393, 'pos': 0.607, 'compound': 0.7351}
+```
+
+The neg, neu,and pos values represent the negative, neutral, and positive sentiment scores, respectively. These values range from 0 to 1, with higher values indicating higher sentiment intensity. The compound value represents an overall sentiment score, ranging from -1 (most negative) to 1 (most positive).
+
+## Conclusion
+
+In this tutorial, we have covered some of the basic functionality provided by the NLTK library for natural language processing. We have demonstrated how to perform text preprocessing, part-of-speech tagging, named entity recognition, and sentiment analysis using NLTK. These are just a few examples of the many tasks that NLTK can be used for, and the library provides a wide range of tools for working with human language data.
+
+NLTK is a powerful tool for natural language processing in Python, and can be used to build a wide range of applications, from chatbots and language translators to sentiment analysis tools and more. By learning the basics of NLTK, you will be well on your way to building your own applications for working with human language data.