Building Grammar Analyzer using Lyzr SDK
Tags: ai, lyzr, grammar, analysis
Published: 2024-04-03 09:34:48

Are you tired of spending countless hours perfecting your documents, only to find pesky **grammar errors** and typos lingering within?

Look no further! We’re thrilled to introduce **Grammar Analyzer**, a revolutionary tool powered by **Lyzr’s cutting-edge SDK**, designed to streamline your proofreading process and elevate your writing to new heights.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9cb27u921cnys7cw1soh.png)

**Grammar Analyzer** simplifies the daunting task of proofreading by leveraging the advanced capabilities of **Lyzr’s QABot**. With just a few clicks, you can upload your document and let Grammar Analyzer do the heavy lifting. Gone are the days of manual line-by-line scrutiny; our intelligent bot swiftly identifies **grammar**, **spelling**, and **punctuation errors**, allowing you to focus on crafting flawless prose.

**Why use Lyzr SDK’s?**

With **Lyzr SDKs**, crafting your own **GenAI** application is a breeze, requiring only a few lines of code to get up and running swiftly.

[Checkout the Lyzr SDK’s](https://docs.lyzr.ai/homepage)

**Lets get Started!**
Create a new file **app.py** and use that

```
import os
import streamlit as st
import shutil
from lyzr import QABot
```
The provided code imports necessary Python libraries for file manipulation (**os** and **shutil**) and web application development (**streamlit**). Additionally, it imports the **QABot** class from the **lyzr** module, indicating involvement with language processing tasks. The lyzr module presumably offers functionalities related to **text analysis** or **natural language understanding**.

Next Set Up **OpenAI API Key** and using Streamlit’s secrets management, set up the OpenAI API key within your Streamlit application. Replace "OPENAI_API_KEY" with the actual key name defined in your Streamlit secrets where your OpenAI API key is stored.

```
os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]
```

```
def remove_existing_files(directory):
    for filename in os.listdir(directory):
        file_path = os.path.join(directory, filename)
        try:
            if os.path.isfile(file_path) or os.path.islink(file_path):
                os.unlink(file_path)
            elif os.path.isdir(file_path):
                shutil.rmtree(file_path)
        except Exception as e:
            st.error(f"Error while removing existing files: {e}")
```
This function, **remove_existing_files(directory)**, is designed to delete all existing files and directories within a specified directory. It iterates through each item in the specified directory using **os.listdir(directory)**. For each item, it constructs the full file path by joining the directory path with the item's filename. Then, it attempts to remove the item using **os.unlink()** if it's a file or **shutil.rmtree()** if it's a directory. If any errors occur during the removal process, it catches them and displays an error message using Streamlit's **st.error() function**.

```
# Set the local directory
data_directory = "data"

# Create the data directory if it doesn't exist
os.makedirs(data_directory, exist_ok=True)

# Remove existing files in the data directory
remove_existing_files(data_directory)
```
These lines of code are responsible for managing a local directory named “data” within the file system. Initially, it sets the variable data_directory to the string "data", representing the name of the directory to be used. Next, it creates the "data" directory using **os.makedirs(data_directory, exist_ok=True)**. The **exist_ok=True** parameter ensures that the directory is created only if it doesn't already exist. Following this, it calls the **remove_existing_files(data_directory)** function to clear out any existing files or subdirectories within the "data" directory, ensuring it's empty and ready for use.


```
# File upload widget
uploaded_file = st.file_uploader("Choose Word file", type=["docx"])

if uploaded_file is not None:
    # Save the uploaded Word file to the data directory
    file_path = os.path.join(data_directory, uploaded_file.name)
    with open(file_path, "wb") as file:
        file.write(uploaded_file.getvalue())
    
    # Display the path of the stored file
    st.success(f"File successfully saved")
```
This code snippet creates a file upload widget using Streamlit, allowing users to select Word files (**“docx” format**). Upon file selection, it saves the uploaded Word file to a local directory named “data”. The code then displays a success message confirming the file’s successful saving.

```
def get_files_in_directory(directory="data"):
    # This function helps us get the file path along with the filename.
    files_list = []

    # Ensure the directory exists
    if os.path.exists(directory) and os.path.isdir(directory):
        # Iterate through all files in the directory
        for filename in os.listdir(directory):
            file_path = os.path.join(directory, filename)
            
            # Check if the path points to a file (not a directory)
            if os.path.isfile(file_path):
                files_list.append(file_path)

    return files_list
```
This function, **get_files_in_directory(directory="data")**, retrieves a list of file paths from the specified directory. It checks if the directory exists and is valid, then iterates through its contents. For each file found, it appends the file path to a list. Finally, it returns the list of file paths, excluding directories.

```
def rag_implementation():
    # This function will implement RAG Lyzr QA bot
    path = get_files_in_directory()
    path = path[0]

    rag = QABot.docx_qa(
        input_files=[str(path)],
        llm_params={"model": "gpt-3.5-turbo"},
        # vector_store_params=vector_store_params
    )

    return rag
```
This function, **rag_implementation()**, implements the **RAG Lyzr QA bot**. It begins by retrieving the file path from the **get_files_in_directory()** function, then selects the first file path from the list. Subsequently, it initializes an instance of the **QABot class**, specifically designed for document question answering. It configures the bot with the selected file path and specifies the model to use. Finally, it returns the configured **QA bot instance**.

```
def resume_response():
    rag = rag_implementation()
    prompt = """  Follow the intructions as given below ,
                    - Run spell check to identify misspelled words. Correct each flagged word, ensuring accurate spelling and context.
                    - Carefully review for grammar and sentence structure errors. Correct subject-verb agreement, tense misuse, and punctuation errors.
                    - Proofread line by line, focusing on syntax, coherence, and clarity. Rectify awkward phrasing, unclear language, and inconsistencies in writing style. Rewrite or rephrase sentences for enhanced readability.
                    - Keep the corrected document and print it. Start printing the corrected version from the next line after this statement: "Correct version:".
                    - Errors : Show the errors in the document and it has been changed."""

    
    response = rag.query(prompt)
    return response.response
```

This **resume_response()** function orchestrates the response generation process using the RAG Lyzr QA bot. It first initializes the RAG QA bot using the **rag_implementation() **function. Then, it defines a prompt containing instructions for reviewing and correcting a document for spelling, grammar, and coherence. Next, it queries the RAG bot with the prompt, prompting it to generate a response. Finally, it returns the response generated by the bot.

At **Lyzr**, we’re committed to empowering writers of all skill levels to express themselves with confidence. Whether you’re drafting a business proposal, crafting a creative masterpiece, or polishing your resume, **Grammar Analyzer** equips you with the tools you need to shine.

Ready to elevate your writing? Experience the power of **Grammar Analyzer** today!

**Youtube Link**: https://www.youtube.com/watch?v=XZqs0Y9Z5DE

**App link**: https://grammar-analyzer-lyzr.streamlit.app/

**Source Code**: https://github.com/isakshay007/Grammer-Checker

**Connect with Lyzr**
To learn more about Lyzr and its SDK’s, visit our website or get in touch with our team:

**Website**: [Lyzr.ai](https://www.lyzr.ai/)
**Book a Demo**: [Book a Demo](https://www.lyzr.ai/book-demo/)
**Discord**: [Join our Discord community](https://discord.com/invite/nm7zSyEFA2)
**Slack**: [Join our Slack channel](https://anybodycanai.slack.com/join/shared_invite/zt-2a7fr38f7-_QDOY1W1WSlSiYNAEncLGw#/shared-invite/email)