Building a Grammar-Checking Flask Endpoint with Gemini

1. Setting Up the Gemini Python Library

To communicate with the Gemini API from our Python code, we need to install Google's official library. Just like you did with textstat in the last lesson, we'll use pip. We also need to make sure our secret API key is handled securely.

This short video will walk you through the essential setup steps.

As the video showed, there are two main tasks:

A. Install the Library
Open your terminal (with your virtual environment activated) and run:

pip install google-generativeai

B. Secure Your API Key
Hardcoding your API key directly in your script is a major security risk. The video shows using export to set it as an environment variable for a single terminal session. A more permanent and project-friendly method is to use a .env file. This approach is demonstrated in the following article.

To follow this best practice:

1. Install the python-dotenv package: pip install python-dotenv
2. In the main folder of your project (the same level as app.py), create a new file named .env.
3. Inside the .env file, add this line, replacing <YOUR_API_KEY> with the key you got from Google AI Studio:

   GEMINI_API_KEY=<YOUR_API_KEY>
   

This .env file will be loaded by our application to securely access the key.

2. The Art of the Prompt: Instructing the AI

The key to making a large language model perform a specific task is giving it clear, precise instructions. This is often called "prompt engineering." We don't want a long conversation or a creative story; we want a simple grammar and spelling correction.

To do this, we'll provide a system_instruction that tells the model its role before it even sees the user's text.

As the article shows, a good instruction for our task would be:
"You are an expert editor specializing in English. Correct the grammar and spelling of the text I provide. Only return the corrected text, without any additional comments or explanations."

This prompt is effective because it:

• Defines a role: "You are an expert editor..."
• Specifies the task: "Correct the grammar and spelling..."
• Constrains the output: "Only return the corrected text..."

3. Creating the Grammar Correction Endpoint

Now, let's put it all together in a new Flask endpoint. We will add a route, /api/correct-grammar, to your app.py file. This endpoint will receive text, use the Gemini API with our special instruction, and return the corrected version.

Here is the code to add to your app.py. Read through it carefully, paying attention to the comments that explain each new part.

# In app.py

# 1. Add these new imports at the top of your file
import os
import google.generativeai as genai
from dotenv import load_dotenv

# 2. Load the environment variables from the .env file
load_dotenv()

# 3. Configure the Gemini API with your key
genai.configure(api_key=os.environ["GEMINI_API_KEY"])

# Initialize the Gemini model
model = genai.GenerativeModel('gemini-1.5-flash')

# ... your existing Flask app and other endpoints ...

# 4. Define the new endpoint for grammar correction
@app.route('/api/correct-grammar', methods=['POST'])
def correct_grammar_endpoint():
    # Get the text from the request
    user_text = request.json.get('text')

    if not user_text:
        return jsonify({'error': 'No text provided'}), 400

    # The specific instruction for the AI
    prompt = (
        "You are an expert editor specializing in English. "
        "Correct the grammar and spelling of the following text. "
        "Only return the corrected text, without any additional comments or explanations.\n\n"
        "Text: " + user_text
    )

    try:
        # 5. Call the Gemini API
        response = model.generate_content(prompt)

        # 6. Create the JSON response with the corrected text
        corrected_text = response.text
        return jsonify({'corrected_text': corrected_text.strip()})

    except Exception as e:
        # Handle potential API errors
        print(f"An error occurred: {e}")
        return jsonify({'error': 'Failed to communicate with the AI model.'}), 500

Code Breakdown:

1. We import the necessary libraries: os to interact with the operating system, genai for the Gemini API, and load_dotenv to read our .env file.
2. load_dotenv() reads the GEMINI_API_KEY from your .env file and makes it available to the application.
3. genai.configure() sets up the library with your key.
4. We define a new route /api/correct-grammar that accepts POST requests.
5. Inside the function, we construct our detailed prompt and call model.generate_content(). We also wrap this in a try...except block, which is good practice for handling potential network or API errors.
6. We extract the text from the response and send it back to the client in a JSON object.

4. Testing Your New AI Endpoint

It's time to see your AI corrector in action!

1. Save your updated app.py file.
2. Run your Flask application from the terminal: python app.py.
3. Open a tool like Postman or Insomnia.
4. Create a new POST request to http://127.0.0.1:5000/api/correct-grammar.
5. In the Body tab, select JSON and enter the following:

   {
       "text": "i is a programer and i luv to code."
   }
   

6. Send the request.

If everything is set up correctly, you should receive a JSON response from your server like this:

{
    "corrected_text": "I am a programmer and I love to code."
}

Congratulations! You have successfully integrated a powerful AI feature into your web application's backend.

Conclusion

In this lesson, you moved beyond simple statistics and connected your application to a state-of-the-art AI model. This is a huge milestone in building your writing assistant.

Key Takeaways:

• You learned how to install the google-generativeai library and securely configure it using a .env file and environment variables.
• You saw the power of prompt engineering—crafting specific instructions to guide an AI model's behavior.
• You built a new Flask endpoint that takes user input, communicates with an external API (Gemini), and returns the processed result.
• You implemented a try...except block to make your API call more robust.

The structure you built today—an endpoint that takes text and a prompt—is incredibly versatile. In the next lesson, we will leverage this exact same pattern to create another endpoint for text summarization, showing just how quickly you can add new AI features once the foundation is in place.