Setting Up Your First Flask App

What is a Backend and Why Flask?

The backend is where your core application logic lives. While JavaScript in the browser can handle animations and user input, it can't securely manage API keys or perform the kind of large-scale processing we need for our AI tool. That's the job of our Python-based server.

We're using Flask to build this server. Flask is known as a "microframework" because it's small, lightweight, and easy to learn. It gives you the essential tools to build a web application without forcing you into a rigid structure, making it a perfect choice for your first project.

To learn a bit more about what Flask is, let's look at a quick introduction.

Step 1: Preparing Your Project Environment

Before we install Flask, we must set up our project correctly. A critical best practice in Python development is to use a virtual environment. A virtual environment is an isolated copy of Python for a specific project. This means any packages you install for this project (like Flask) won't interfere with other Python projects on your computer.

This is an essential skill for any serious Python developer. The following tutorial is one of the most respected guides for learning Flask and explains this concept perfectly.

Step 2: Installing Flask

Great! Now that your virtual environment is active, any package you install with pip will be placed inside it, keeping your project self-contained. Installing Flask is now just a single command.

Step 3: Writing Your First Web Server

With Flask installed, it's time to write some code. The amount of code needed for a basic web server is remarkably small.

In your project directory, create a new file named app.py. We'll now watch a short video that walks through the essential lines of code and explains what each one does.

Here is the complete code for your app.py file. This includes a small addition at the end that makes running the server easy.

from flask import Flask

# Create an instance of the Flask application
app = Flask(__name__)

# Define a route for the home page URL ('/')
# This decorator tells Flask which URL should trigger our function.
@app.route('/')
def home():
    # This is the view function. It returns the response for this route.
    return "Hello, World!"

# This block allows you to run the app by executing this file directly.
# It's a standard convention in Python scripts.
if __name__ == '__main__':
    # app.run() starts the development server.
    # debug=True enables debug mode, which automatically reloads the server
    # when you save changes to the file. This is very useful for development.
    app.run(debug=True)

Let's quickly break this down:

1. from flask import Flask: We import the main Flask class from the flask library.
2. app = Flask(__name__): We create an "instance" of our web application. __name__ is a special Python variable that helps Flask know where to find resources.
3. @app.route('/'): This is a decorator. It links the URL / (the root or home page of our site) to the function defined right below it.
4. def home():: This is our "view function." It contains the logic that runs when a user visits the / route.
5. return "Hello, World!": The view function returns the content that will be displayed in the user's browser. Right now, it's just plain text.
6. if __name__ == '__main__':: This standard Python construct ensures that the server only runs when the script is executed directly (not when it's imported by another script).
7. app.run(debug=True): This command starts Flask's built-in development web server.

Step 4: Running Your Server

This is the moment of truth! Let's run the server and see it in action.

1. Open your terminal.
2. Make sure you are in your project directory (my-ai-app or whatever you named it).
3. Make sure your virtual environment is still active (you should see (venv)).
4. Run the application with the following command:

   python app.py
   

You should see output in your terminal indicating that a server is running, usually on http://127.0.0.1:5000/. Now, open your web browser and navigate to that address. You should see the text "Hello, World!" on the page.

Congratulations, you've just built and run your first web server!

@app.route('/welcome')
def welcome_page():
    return "Welcome to my AI Assistant"

Conclusion

You've taken a huge step today, bridging the gap between standalone Python scripts and a live web application. This is the starting point for the entire backend of your AI-powered tool.

Key Takeaways:

• A web server is a program that listens for requests from browsers and sends back responses.
• Flask is a Python microframework that makes building web servers simple and flexible.
• Virtual environments are essential for managing project-specific dependencies and are a professional standard in Python development.
• A basic Flask app requires an app instance, a route (@app.route()), and a view function that returns a response.
• You can run the development server using app.run(debug=True) inside your script.

In our next lesson, we will explore routes more deeply. You will learn how to define routes that can handle different types of requests from the browser, specifically GET and POST requests. This will be crucial for receiving user input from your frontend form.