Building a RESTful API for Your Chatbot Service Using FastAPI

Serving Your Chatbot with a RESTful API Using FastAPI

Welcome to the next step in our journey of building a chatbot service with FastAPI . 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 FastAPI. We'll start by setting up the main FastAPI application, then adapt the ChatController to integrate with FastAPI's session management.

Understanding RESTful APIs and FastAPI

RESTful APIs are a way for different software systems to communicate over the internet. They provide a set of rules that allow programs to exchange data. FastAPI is a modern, fast (high-performance) web framework for building APIs with Python 3.7+ based on standard Python type hints. It is designed to be easy to use and to provide automatic interactive API documentation. To get started with FastAPI, you can install it using pip by running the following command in your terminal or command prompt: Shell pip install fastapi Additionally, to run the FastAPI application, you'll need to install Uvicorn, an ASGI server: Shell pip install uvicorn Now, we can use FastAPI to connect the components we've already built, allowing users to interact with our chatbot service through a web interface. This will enable seamless communication between users and our chatbot service.

Initializing a FastAPI App

First, we need to initialize the FastAPI application: Python from fastapi import FastAPI, Request # Initialize FastAPI app app = FastAPI()) Here, we import the FastAPI module and instantiate the FastAPI class to create our application object, app . This object will be used to configure and run our web application.

Adding Session Management with Starlette Middleware

FastAPI does not have built-in session management, but it's built on top of Starlette, which provides session handling capabilities. When you install FastAPI, Starlette comes bundled with it, giving you access to its middleware components. A middleware is a function that works with every request before it's processed by any specific route handler. It sits between the server receiving the request and your route functions, allowing you to modify requests or responses globally. We can add Starlette's SessionMiddleware to our FastAPI application to enable session management: Python from starlette.middleware.sessions import SessionMiddleware # Add session middleware app.add_middleware(SessionMiddleware, secret_key="your_secret_key_here") The SessionMiddleware handles creating, reading, and updating session data stored in cookies. The secret_key parameter is crucial for securing session data, as it's used to sign the session cookies to prevent tampering.

Join the 1M+ learners on CodeSignal

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

Running the FastAPI Server

Now that we've defined our routes and prepared our controller for integration with FastAPI, the final step is to set up the server to run our application. We'll use Uvicorn, an ASGI server, to serve our FastAPI application.

Python

import uvicorn

# Start the ASGI server to run the FastAPI application
if __name__ == "__main__":
    uvicorn.run(
        "main:app",
        host="0.0.0.0",
        port=3000,
        reload=True
    )

import uvicorn

# Start the ASGI server to run the FastAPI application
if __name__ == "__main__":
    uvicorn.run(
        "main:app",
        host="0.0.0.0",
        port=3000,
        reload=True
    )

This code block does several important things:

The if __name__ == "__main__": condition ensures that the server only starts when we run this file directly, not when it's imported by another module.
The uvicorn.run() function launches the ASGI server with our FastAPI application. The first argument, "main:app", tells Uvicorn where to find our application - in this case, the app variable in the main.py file. This syntax allows us to run the main file directly with a command like python main.py instead of having to use the uvicorn command-line interface.
We set the host to "0.0.0.0" to make the server accessible from any network interface, not just localhost. This is useful if you want to access the server from other devices on your network.
The port is set to 3000, so our application will be available at http://localhost:3000.
The reload=True parameter enables hot reloading, which automatically restarts the server when you make changes to your code. This is extremely helpful during development.

However, before we can actually run our API and have it work correctly, we need to adapt our ChatController to work with FastAPI's session management and request handling. Our current controller implementation uses an internal test session and expects different parameters than what our routes are configured to provide. In the next section, we'll explore how to modify the ChatController to seamlessly integrate with our FastAPI routes.

ChatController: Sending a Message

The send_message method has undergone the most significant changes to accommodate FastAPI's request handling:

Python

def send_message(self, session, data):  # Changed: Method signature now accepts session and data
    """Handle message sending request."""
    user_id = session.get('user_id')  # Changed: Using passed session instead of self.test_session
    if not user_id:
        return {'error': 'Session expired'}, 401
    
    chat_id = data.get('chat_id')  # Changed: Extracting chat_id from data object
    user_message = data.get('message')  # Changed: Extracting message from data object
    
    if not chat_id or not user_message:
        return {'error': 'Missing chat_id or message'}, 400
        
    try:
        ai_response = self.chat_service.process_message(user_id, chat_id, user_message)
        return {'message': ai_response}
    except ValueError as e:
        return {'error': str(e)}, 404
    except RuntimeError as e:
        return {'error': str(e)}, 500

def send_message(self, session, data):  # Changed: Method signature now accepts session and data
    """Handle message sending request."""
    user_id = session.get('user_id')  # Changed: Using passed session instead of self.test_session
    if not user_id:
        return {'error': 'Session expired'}, 401
    
    chat_id = data.get('chat_id')  # Changed: Extracting chat_id from data object
    user_message = data.get('message')  # Changed: Extracting message from data object
    
    if not chat_id or not user_message:
        return {'error': 'Missing chat_id or message'}, 400
        
    try:
        ai_response = self.chat_service.process_message(user_id, chat_id, user_message)
        return {'message': ai_response}
    except ValueError as e:
        return {'error': str(e)}, 404
    except RuntimeError as e:
        return {'error': str(e)}, 500

This method now accepts two parameters:

The session object from FastAPI for retrieving the user ID
The data object containing the request payload

Instead of receiving chat_id and user_message as direct parameters, it extracts them from the data object. This change accommodates FastAPI's JSON request handling, where the request body is parsed and passed to the controller. The error handling and core functionality remain consistent with the previous implementation.

Serving Your Chatbot with a RESTful API Using FastAPI

Understanding RESTful APIs and FastAPI

Initializing a FastAPI App

Adding Session Management with Starlette Middleware

Join the 1M+ learners on CodeSignal

Creating the Controller Instance

Ensuring a User Session with the Index Route

Creating New Chats with the Create Chat Route

Handling Message Exchange with the Send Message Route

Running the FastAPI Server

Adapting the ChatController

ChatController: Ensuring User Session

ChatController: Creating a Chat

ChatController: Sending a Message

How Clients Interact with the Chatbot API

Summary and Next Steps