Serving Your Chatbot with a RESTful API Using Flask

Welcome to the next step in our journey of building a chatbot service with Flask . In the previous lesson, we focused on the ChatController, which manages chat sessions and handles messages by interacting with both the model and service layers. Now, we will take a significant step forward by creating a RESTful API for our chatbot service using Flask. We'll start by setting up the main Flask application, then adapt the ChatController to integrate with Flask's session management.

Understanding RESTful APIs and Flask

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Defining Routes for the Chatbot Service

Next, we define the routes for our chatbot service. These routes will handle requests for creating a new chat session and sending messages.

Python

# Define a route for the index page that ensures a user session
@app.route('/')
def index():
    chat_controller.ensure_user_session()
    return "Welcome to the Chatbot Service!"

# Define a route for creating a new chat session
@app.route('/api/create_chat', methods=['POST'])
def create_chat():
    # Delegate the creation of a chat session to the chat controller
    return chat_controller.create_chat()

# Define a route for sending a message in an existing chat session
@app.route('/api/send_message', methods=['POST'])
def send_message():
    # Delegate the handling of a message to the chat controller
    return chat_controller.send_message()

# Define a route for the index page that ensures a user session
@app.route('/')
def index():
    chat_controller.ensure_user_session()
    return "Welcome to the Chatbot Service!"

# Define a route for creating a new chat session
@app.route('/api/create_chat', methods=['POST'])
def create_chat():
    # Delegate the creation of a chat session to the chat controller
    return chat_controller.create_chat()

# Define a route for sending a message in an existing chat session
@app.route('/api/send_message', methods=['POST'])
def send_message():
    # Delegate the handling of a message to the chat controller
    return chat_controller.send_message()

Here's how each route functions within our chatbot service:

Index Route (/): This route acts as the entry point to our chatbot service. When a user accesses this route, it ensures that a user session is established by invoking the ensure_user_session method of the ChatController. After setting up the session, it returns a welcome message to the user, indicating that the service is ready for interaction.
Create Chat Route (/api/create_chat): This route is designed to initiate a new chat session. It listens for POST requests and delegates the task of creating a chat session to the ChatController by calling its create_chat method. The controller handles the session creation and returns a response, which is then sent back to the client.
Send Message Route (/api/send_message): This route facilitates sending messages within an existing chat session. It also listens for POST requests and delegates the message processing to the ChatController by invoking its send_message method. The controller processes the message and returns the AI's response, which is then delivered to the client.

Finally, we set up the Flask application to run on a specified port when executed directly.

Python

# Run the Flask application if this script is executed directly
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=3000)

# Run the Flask application if this script is executed directly
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=3000)

The if __name__ == '__main__': construct ensures that the Flask application runs only when the script is executed directly, rather than being imported as a module in another script. This is a common Python idiom for making code both importable as a module and executable as a standalone script. The app.run() method is then called to start the Flask development server with the following parameters:

debug=True: Enables debug mode, which provides helpful error messages and automatic reloading of the server when code changes are detected.
host='0.0.0.0': Makes the server accessible externally by listening on all available network interfaces, allowing connections from other devices on the network.
port=3000: Specifies the port on which the server will listen for incoming requests, allowing users to access the application via http://localhost:3000.

To integrate the ChatController with Flask, we need to update it to use Flask's session management. We start by importing necessary Flask modules and updating the constructor to remove the test session.

Python

import uuid
from flask import session, request
from services.chat_service import ChatService

class ChatController:
    def __init__(self):
        self.chat_service = ChatService()

import uuid
from flask import session, request
from services.chat_service import ChatService

class ChatController:
    def __init__(self):
        self.chat_service = ChatService()

Next, let's break down how to update the ChatController methods to utilize Flask's session management.

In the ensure_user_session method, we update the way user sessions are managed by leveraging Flask's built-in session object. Previously, we used a test session dictionary to store user IDs. Now, we check if a user_id exists in the Flask session. If it doesn't, we generate a new UUID and store it in the session.

Python

def ensure_user_session(self):
    """Ensure user has a session ID."""
    # Check if 'user_id' is already in the session
    if 'user_id' not in session:
        # Generate a new UUID and store it in the session if not present
        session['user_id'] = str(uuid.uuid4())
    # Return the user_id from the session
    return session['user_id']

def ensure_user_session(self):
    """Ensure user has a session ID."""
    # Check if 'user_id' is already in the session
    if 'user_id' not in session:
        # Generate a new UUID and store it in the session if not present
        session['user_id'] = str(uuid.uuid4())
    # Return the user_id from the session
    return session['user_id']

This change allows us to utilize Flask's session management capabilities, providing a more robust and scalable solution for maintaining user sessions.

In the create_chat method, we update the code to now retrieve the user_id directly from the Flask session, ensuring that the request is associated with a valid user session.

Python

def create_chat(self):
    """Handle chat creation request."""
    # Retrieve the user_id from the session
    user_id = session.get('user_id')

    # Check if the session has expired (user_id is not present)
    if not user_id:
        return {'error': 'Session expired'}, 401
    
    # Create a new chat session using the ChatService
    chat_id = self.chat_service.create_chat(user_id)

    # Return a JSON response with the chat ID and success message
    return {
        'chat_id': chat_id,
        'message': 'Chat created successfully'
    }

def create_chat(self):
    """Handle chat creation request."""
    # Retrieve the user_id from the session
    user_id = session.get('user_id')

    # Check if the session has expired (user_id is not present)
    if not user_id:
        return {'error': 'Session expired'}, 401
    
    # Create a new chat session using the ChatService
    chat_id = self.chat_service.create_chat(user_id)

    # Return a JSON response with the chat ID and success message
    return {
        'chat_id': chat_id,
        'message': 'Chat created successfully'
    }

If the session is expired, it returns an error response. Otherwise, it creates a new chat session using the ChatService and returns a JSON response with the chat ID and a success message.

ChatController: Sending a Message

The send_message method is updated to handle requests using Flask's request and session objects. We now extract chat_id and user_message from the incoming request using the request object.

Python

def send_message(self):
    """Handle message sending request."""
    # Retrieve the user_id from the session
    user_id = session.get('user_id')

    # Check if the session has expired (user_id is not present)
    if not user_id:
        return {'error': 'Session expired'}, 401
    
    # Extract chat_id and user_message from the incoming JSON request
    chat_id = request.json.get('chat_id')
    user_message = request.json.get('message')
    
    # Check if chat_id or user_message is missing
    if not chat_id or not user_message:
        return {'error': 'Missing chat_id or message'}, 400
        
    try:
        # Process the message using the ChatService and get the AI's response
        ai_response = self.chat_service.process_message(user_id, chat_id, user_message)
        # Return the AI's response as a JSON object
        return {'message': ai_response}
    except ValueError as e:
        # Handle specific error scenarios and return appropriate JSON responses
        return {'error': str(e)}, 404
    except RuntimeError as e:
        return {'error': str(e)}, 500

def send_message(self):
    """Handle message sending request."""
    # Retrieve the user_id from the session
    user_id = session.get('user_id')

    # Check if the session has expired (user_id is not present)
    if not user_id:
        return {'error': 'Session expired'}, 401
    
    # Extract chat_id and user_message from the incoming JSON request
    chat_id = request.json.get('chat_id')
    user_message = request.json.get('message')
    
    # Check if chat_id or user_message is missing
    if not chat_id or not user_message:
        return {'error': 'Missing chat_id or message'}, 400
        
    try:
        # Process the message using the ChatService and get the AI's response
        ai_response = self.chat_service.process_message(user_id, chat_id, user_message)
        # Return the AI's response as a JSON object
        return {'message': ai_response}
    except ValueError as e:
        # Handle specific error scenarios and return appropriate JSON responses
        return {'error': str(e)}, 404
    except RuntimeError as e:
        return {'error': str(e)}, 500

If any required data is missing, the method returns an error response. The message is processed using the ChatService, and the AI's response is returned as a JSON object. We've also implemented error handling to provide appropriate JSON responses for different scenarios, ensuring that all interactions with the API are consistent and informative.

To interact with our chatbot service, a client can follow these steps to send a message using the API:

Access the Index Route (/): The client begins by accessing the index route of the API. This step ensures that a user session is established. A user session is a way to keep track of the user's interactions with the service. It is stored using Flask's session management, which utilizes cookies to maintain session data on the client side. The server responds with a welcome message, indicating that the service is ready for interaction.
Create a Chat Session (/api/create_chat): Before sending a message, the client needs to create a new chat session. This is done by sending a request to the /api/create_chat route. The server will respond with a unique chat ID, which is essential for identifying the chat session in subsequent interactions. The user session ensures that the chat session is associated with the correct user, allowing for personalized interactions.
Send a Message (/api/send_message): With the chat session established, the client can now send a message to the chatbot. This involves sending a request to the /api/send_message route, including the chat ID and the message content. The server processes the message and responds with the AI's reply, allowing the client to continue the conversation. The user session helps maintain continuity in the conversation by linking the messages to the correct user and chat session.

By following these steps, a client can effectively communicate with the chatbot service, leveraging the RESTful API to manage chat sessions and exchange messages while utilizing user sessions for a seamless experience.

In this lesson, we successfully built a RESTful API for our chatbot service using Flask. We set up a Flask application, defined routes for chat operations and updated the ChatController to utilize Flask's session management. This lesson marks a significant milestone in our course, as it brings together all the components we've developed so far into a functional web application.

As you move on to the practice exercises, take the opportunity to experiment with the Flask API and reinforce the concepts covered in this lesson. This hands-on practice will prepare you for further development and exploration of additional Flask features and RESTful API concepts. Keep up the great work, and I look forward to seeing your progress!