Bird
Raised Fist0
MLOpsdevops~5 mins

REST API serving with FastAPI in MLOps - Commands & Configuration

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallTime

Start learning this pattern below

Jump into concepts and practice - no test required

or
Recommended
Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong
Introduction
When you want to share your machine learning model or data processing logic with other programs or users, you need a way to communicate over the internet. FastAPI helps you create a REST API quickly and easily so others can send requests and get responses from your code.
When you want to let other applications send data to your model and get predictions back instantly.
When you need a simple web service to expose your data processing functions to a team.
When you want to test your machine learning model with real inputs from a web client.
When you want to build a backend for a web or mobile app that uses your ML model.
When you want to deploy your model as a service without writing complex server code.
Config File - main.py
main.py
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    feature1: float
    feature2: float

@app.post("/predict")
async def predict(item: Item):
    # Simple example: sum features as prediction
    prediction = item.feature1 + item.feature2
    return {"prediction": prediction}

This Python file creates a FastAPI app that listens for POST requests at the /predict endpoint.

The Item class defines the expected input data with two features.

The predict function receives the input, calculates a simple prediction by adding the features, and returns the result as JSON.

Commands
This command starts the FastAPI server using Uvicorn. The --reload flag restarts the server automatically when you change the code, making development easier.
Terminal
uvicorn main:app --reload
Expected OutputExpected
INFO: Will watch for changes in these directories: ['.'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [12345] using statreload INFO: Started server process [12346] INFO: Waiting for application startup.
→
--reload - Automatically reload server on code changes
This command sends a POST request to the /predict endpoint with JSON data containing feature1 and feature2. It tests if the API returns the correct prediction.
Terminal
curl -X POST http://127.0.0.1:8000/predict -H "Content-Type: application/json" -d '{"feature1": 3.5, "feature2": 2.5}'
Expected OutputExpected
{"prediction":6.0}
→
-X POST - Specify POST request method
→
-H "Content-Type: application/json" - Set request content type to JSON
→
-d '{"feature1": 3.5, "feature2": 2.5}' - Send JSON data as request body
This command opens the automatic interactive API documentation generated by FastAPI. It helps you explore and test the API endpoints in a web browser.
Terminal
curl http://127.0.0.1:8000/docs
Expected OutputExpected
<!DOCTYPE html>... (HTML content of Swagger UI page)
Key Concept

If you remember nothing else from this pattern, remember: FastAPI lets you quickly turn Python functions into web APIs that accept JSON input and return JSON output.

Code Example
MLOps
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    feature1: float
    feature2: float

@app.post("/predict")
async def predict(item: Item):
    prediction = item.feature1 + item.feature2
    return {"prediction": prediction}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="127.0.0.1", port=8000, reload=True)
OutputSuccess
Common Mistakes
Not specifying the correct Content-Type header when sending JSON data.
The server won't parse the input correctly and may return an error or unexpected results.
Always include -H "Content-Type: application/json" when sending JSON in curl or other clients.
Forgetting to run the server with the correct module and app name in uvicorn.
Uvicorn will fail to find the app and won't start the server.
Use the format uvicorn main:app where 'main' is the Python filename and 'app' is the FastAPI instance.
Not using async def for endpoint functions in FastAPI.
FastAPI supports async for better performance; using regular def can work but misses async benefits.
Define endpoint functions with async def to enable asynchronous handling.
Summary
Create a FastAPI app with Python functions that accept and return JSON data.
Run the app using uvicorn to start a local web server.
Test the API by sending POST requests with JSON payloads and check the JSON responses.
Use the built-in /docs endpoint to explore and interact with the API easily.

Practice

(1/5)
1. What is the main purpose of using FastAPI in serving machine learning models?
easy
A. To train machine learning models faster
B. To create fast and simple REST APIs for model serving
C. To store large datasets efficiently
D. To visualize model performance graphs

Solution

  1. Step 1: Understand FastAPI's role

    FastAPI is a web framework used to build APIs quickly and simply.

  2. Step 2: Connect to model serving

    It is commonly used to serve machine learning models via REST APIs for easy access.

  3. Final Answer:

    To create fast and simple REST APIs for model serving -> Option B

  4. Quick Check:

    FastAPI = REST API serving [OK]
Hint: FastAPI is for building APIs, not training or storage [OK]
Common Mistakes:
  • Confusing API serving with model training
  • Thinking FastAPI handles data storage
  • Assuming FastAPI is for visualization
2. Which of the following is the correct way to define a GET endpoint in FastAPI?
easy
A. @app.route('/items', method='GET') def read_items(): return {'items': []}
B. @app.post('/items') def read_items(): return {'items': []}
C. @app.get('/items') def read_items(): print('items')
D. @app.get('/items') def read_items(): return {'items': []}

Solution

  1. Step 1: Identify correct decorator for GET

    FastAPI uses @app.get() to define GET endpoints.

  2. Step 2: Check function returns JSON response

    The function should return a dictionary to send JSON; print statement does not return data.

  3. Final Answer:

    @app.get('/items')\ndef read_items():\n return {'items': []} -> Option D

  4. Quick Check:

    @app.get() + return dict = correct GET endpoint [OK]
Hint: Use @app.get() and return dict for GET endpoints [OK]
Common Mistakes:
  • Using @app.post() for GET endpoints
  • Using print instead of return
  • Using Flask-style @app.route() syntax
3. What will be the output when you call the following FastAPI endpoint?
@app.get('/hello')
def say_hello():
    return {'message': 'Hello, FastAPI!'}
medium
A. {\"message\": \"Hello, FastAPI!\"}
B. Hello, FastAPI!
C. Error: Missing return type
D. 404 Not Found

Solution

  1. Step 1: Analyze endpoint return value

    The function returns a dictionary with key 'message' and value 'Hello, FastAPI!'.

  2. Step 2: Understand FastAPI response format

    FastAPI automatically converts dict to JSON response with the same structure.

  3. Final Answer:

    {"message": "Hello, FastAPI!"} -> Option A

  4. Quick Check:

    Return dict = JSON response with same keys [OK]
Hint: Return dict from endpoint gives JSON response [OK]
Common Mistakes:
  • Expecting plain string instead of JSON
  • Thinking missing return type causes error
  • Assuming endpoint path is incorrect
4. Identify the error in this FastAPI POST endpoint code:
@app.post('/predict')
def predict(data: dict):
    return {'result': data['value'] * 2}
medium
A. Missing request body declaration with Pydantic model
B. Incorrect HTTP method, should be GET
C. Function missing return statement
D. Syntax error in decorator

Solution

  1. Step 1: Check parameter type for POST data

    FastAPI requires request body to be declared with Pydantic models or Body for parsing JSON.

  2. Step 2: Understand why dict alone is insufficient

    Using plain dict as parameter does not parse JSON body automatically, causing validation error.

  3. Final Answer:

    Missing request body declaration with Pydantic model -> Option A

  4. Quick Check:

    POST body needs Pydantic model or Body [OK]
Hint: Use Pydantic models for POST request bodies [OK]
Common Mistakes:
  • Using plain dict instead of Pydantic model
  • Confusing POST with GET method
  • Forgetting to return a response
5. You want to serve a machine learning model prediction via FastAPI. Which approach correctly handles input validation and prediction?
from pydantic import BaseModel

class InputData(BaseModel):
    feature1: float
    feature2: float

@app.post('/predict')
def predict(data: InputData):
    result = model.predict([[data.feature1, data.feature2]])
    return {'prediction': result[0]}

What is the main advantage of this design?
hard
A. It skips input validation for faster response
B. It trains the model on each request
C. It validates input data types automatically before prediction
D. It returns raw model object instead of prediction

Solution

  1. Step 1: Understand Pydantic model role

    InputData class validates that feature1 and feature2 are floats before function runs.

  2. Step 2: Connect validation to prediction safety

    This prevents invalid data from reaching model.predict, avoiding runtime errors.

  3. Final Answer:

    It validates input data types automatically before prediction -> Option C

  4. Quick Check:

    Pydantic = automatic input validation [OK]
Hint: Use Pydantic models to validate inputs before prediction [OK]
Common Mistakes:
  • Thinking model retrains on each request
  • Skipping validation causes errors
  • Returning model object instead of prediction