What this tutorial covers

FastAPI is described in the verified material as a modern Python framework for building APIs. The referenced reviews highlight its asynchronous capabilities, Pydantic validation, and automatic interactive API documentation. Those are the capabilities this example uses: a route receives a typed request, validates it through a Pydantic model, and returns a typed response documented by the framework.

The example uses a support-ticket classification-shaped contract, but it deliberately does not call a language model. That distinction matters. A validated HTTP API is not, by itself, an AI router. To route requests to OpenAI or Anthropic, an implementation also needs provider-specific clients and verified configuration, response handling, error behavior, and policy decisions. Those details cannot be responsibly supplied from the available sources here.

The verified context also describes a wider architectural distinction. FastAPI is route-first: an HTTP route declaration is central to registering an endpoint and its schema. If the same capability must also be exposed as an MCP tool, the context says a separate registration may be needed, with independently maintained declarations. HarnessAPI’s research describes a skill-first alternative that projects a skill and its type contracts onto transports. This tutorial stays with ordinary FastAPI routes and does not implement MCP or HarnessAPI.

Prerequisites

• Python and familiarity with functions, type annotations, and JSON.
• A terminal where you can install Python packages and run a local development server.
• Basic understanding of HTTP requests and responses.

No model API key is required because the sample does not make provider calls. Package versions and provider model identifiers are not specified by the verified context, so this guide avoids claiming specific compatible version floors.

Step 1: Create a project and install the framework

Create a project directory and a virtual environment. Install FastAPI and an ASGI server using your normal Python package workflow. For a shared or deployed project, choose and lock versions that your team has tested; the supplied sources do not verify particular current version numbers.

mkdir typed-fastapi-service
cd typed-fastapi-service
python -m venv .venv

# macOS or Linux
source .venv/bin/activate

# Windows PowerShell
# .venv\Scripts\Activate.ps1

python -m pip install fastapi uvicorn

Create a file named main.py in the project directory. FastAPI uses route declarations to associate HTTP methods and paths with Python endpoint functions. The function’s type annotations and Pydantic models can describe the data expected by the endpoint.

Step 2: Define typed request and response models

Define the data contract before writing the route. In this example, the request includes a subject and message. The response is a simple acknowledgement. The sample intentionally avoids claiming that a model has classified the ticket: the endpoint has not called a model and should not misrepresent its output as AI-generated analysis.

from pydantic import BaseModel, Field


class TicketRequest(BaseModel):
    subject: str = Field(min_length=3, max_length=200)
    body: str = Field(min_length=10, max_length=8000)


class TicketAccepted(BaseModel):
    status: str
    subject: str

The model declarations make the intended input and output shapes visible in Python. The constraints define minimum and maximum lengths for the two request fields. Pydantic validation is the part of this pattern supported by the provided context: the HarnessAPI description specifically discusses using Pydantic input-model validation and returning an HTTP 422 response when validation fails.

These models are application contracts, not instructions to a language model. They do not ensure that external model output is safe or correct. If a later implementation calls...