The source code used for this example is available in our GitHub repository.

FastAPI is a web framework for building APIs with Python. It is designed to be fast, simple, and easy to use. It is also designed to be flexible for a wide variety of use cases.

A web framework is a set of tools and libraries that simplify the process of building web applications. It provides a high-level interface that allows developers to build web applications without having to worry about low-level details such as network protocols and data storage.

Developing with FastAPI has many benefits, but the major one is as advertised in its name – it is fast. It's both fast in performance (on par with NodeJS and Go) and in development time (increasing the speed to develop features by about 200% to 300%). You can read more about these in its documentation.

In this chapter, we'll build a simple sentiment analysis API with FastAPI and Cohere's Chat endpoint, leveraging the Structured Outputs feature. The API will return the predicted sentiment of a user's product review.

It involves the following steps.

Step 1: Setup
Step 2: Create a sentiment classifier
Step 3: Create a FastAPI endpoint
Step 4: Call the endpoint

Step 1: Setup

First, we create a Python file. Let's name it main.py.

Next, we import FastAPI and Cohere, as well as Pydantic to structure inputs to the API.

pip install cohere fastapi "uvicorn[standard]"

import cohere
import json
from fastapi import FastAPI
from pydantic import BaseModel, conlist

# Setup the Cohere client
co = cohere.ClientV2("COHERE_API_KEY") # Get your free API key: https://dashboard.cohere.com/api-keys

Uvicorn serves as the default server for FastAPI, providing an asynchronous interface, while Pydantic provides a way to define data schemas using plain Python classes with type hints.

Step 2: Create a Sentiment Classifier

To create a sentiment classifier, we'll use the Structured Outputs feature of the Chat endpoint to generate a class for a given input text. The Structured Outputs feature ensures that the model will generate structured data that follows a desired schema 100% of the time.

First, we create a prompt that contains examples of positive, negative, and neutral product reviews.

We then utilize the Structured Outputs feature to create a response_format JSON schema that defines the output that the endpoint needs to provide. Here, we are instructing it to provide a class field in which the value has to be one of positive, negative, or neutral via the enum parameter.

def classify_sentiment(product_review):
        # Create prompt with examples
        prompt = """Classify this text into positive, negative, or neutral sentiment. Here are some examples:

        Positive examples:
        - "The order came 5 days early"
        - "The item exceeded my expectations" 
        - "I ordered more for my friends"
        - "I would buy this again"
        - "I would recommend this to others"

        Negative examples:
        - "The package was damaged"
        - "The order is 5 days late"
        - "The order was incorrect" 
        - "I want to return my item"
        - "The item's material feels low quality"

        Neutral examples:
        - "The item was nothing special"
        - "I would not buy this again but it wasn't a waste of money"
        - "The item was neither amazing or terrible"
        - "The item was okay"
        - "I have no emotions towards this item"

        Text to classify:
        {}"""

        res = co.chat(
            model="command-a-03-2025",
            messages=[
                {
                    "role": "user",
                    "content": prompt.format(product_review)
                }
            ],
            temperature=0.0,
            response_format={
                "type": "json_object",
                "schema": {
                    "type": "object",
                    "properties": {
                        "class": {
                            "type": "string",
                            "enum": ["positive", "negative", "neutral"]
                        }
                    },
                    "required": ["class"]
                }
            }
        )
        return json.loads(res.message.content[0].text)["class"]

Step 3: Create a FastAPI Endpoint

Now let's create a FastAPI wrapper around that code to extend the model as an API endpoint.

First, we create a ProductReviews class, which is a Pydantic model that defines the structure of the request body expected by the prediction endpoint (which we'll create after this). Specifically, it specifies that the request body must contain a field named reviews, which is a list of strings (conlist(str, min_length=1)). Each string in the list represents a product review. The min_length=1 constraint ensures that the list contains at least one review.

Next, we create an endpoint that we call predictiontogether with a function that callspredict_sentiment. This endpoint will receive the user’s inputted list of strings and invoke the function.

We take the code to call the Chat endpoint from the previous step and put it inside the function.

app = FastAPI()

class ProductReviews(BaseModel):
    reviews: conlist(str, min_length=1)

@app.post("/prediction")
def predict_sentiment(product_reviews: ProductReviews):
    sentiments = []
    for review in product_reviews.reviews:
        sentiments.append(classify_sentiment(review))
    return sentiments

Step 4: Call the Endpoint

We can now test the endpoint locally. Switch your terminal working directory to the location of your saved Python file, then input the following shell command. This brings up a server on your localhost.

uvicorn main:app

Let's test with these two text inputs and get the predicted classes from the model.

 The product was faulty
 Customer support was very responsive

There are a couple of options to call the endpoint. One way is to run a cURL command on your terminal.

curl -X 'POST' \
  'http://127.0.0.1:8000/prediction' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "reviews": [
    "The product was faulty",
    "Customer support was very responsive"
  ]
}'

# Example response
["negative","positive"]

Another way is to use FastAPI's built-in documentation feature. It offers easy documentation based on OpenAPI standards showcasing API endpoints, sample values, responses, and their types.

For this, go to the URL provided when you run the shell command earlier to bring up the server and add docs as the path (For example, 127.0.0.1:8000/docs).

Click the Try it out button and add comma-separated text to the Request body section.

Click Execute. A sample curl command of your request is shown, along with the API call results.

In this chapter, we built a simple sentiment analysis API with FastAPI and Cohere's Chat endpoint.

Deploying with FastAPI