FastAPI Knowledge Patch (0.112 to 0.135.3) Skill

FastAPI Knowledge Patch (0.112 to 0.135.3)

Claude's baseline knowledge covers FastAPI through 0.111, Pydantic v2.7, Starlette 0.37, Uvicorn 0.29. This skill covers changes from 0.112 through 0.135.3 (2024-09 to 2026-04).

Version Compatibility

| Dependency | Minimum | Notes | |-----------|---------|-------| | Python | 3.10 | Dropped 3.8 in 0.125.0, 3.9 in 0.129.0. Python 3.14 supported | | Pydantic | 2.9.0 | v1 fully dropped (0.126.0-0.128.0). No pydantic.v1 compat | | Starlette | >=0.46.0 | Supports Starlette 1.0.0+ | | fastapi-slim | -- | Dropped in 0.129.2. Use fastapi or fastapi[standard] |

Key Changes Timeline

| Version | Change | Impact | |---------|--------|--------| | 0.135.0 | Native SSE via fastapi.sse | New API | | 0.134.0 | yield streaming (JSON lines, binary) | New pattern | | 0.133.0 | Starlette 1.0 support | on_event removed | | 0.132.0 | strict_content_type=True default | Breaking | | 0.131.0 | ORJSONResponse/UJSONResponse deprecated | Deprecation | | 0.130.0 | Pydantic Rust JSON serializer auto-used | Performance | | 0.129.1 | bytes JSON Schema: contentMediaType | Breaking | | 0.126.0 | Pydantic v1 support fully dropped | Breaking | | 0.122.0 | Security classes return 401, not 403 | Breaking | | 0.121.0 | Dependency scope="request" | New API | | 0.117.0 | -> None return type for no-body responses | New pattern |

Server-Sent Events (0.135.0)

Native SSE via fastapi.sse. No third-party packages needed:

from collections.abc import AsyncIterable
from fastapi import FastAPI
from fastapi.sse import EventSourceResponse, ServerSentEvent
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.get("/items/stream", response_class=EventSourceResponse)
async def stream_items() -> AsyncIterable[Item]:
    for item in items:
        yield item  # auto-serialized as JSON in data: field

For SSE fields (event, id, retry, comment), yield ServerSentEvent objects:

yield ServerSentEvent(data=item, event="item_update", id=str(i), retry=5000)
yield ServerSentEvent(raw_data="[DONE]", event="done")  # raw_data skips JSON encoding
yield ServerSentEvent(comment="keep-alive")  # comment-only event

data and raw_data are mutually exclusive on ServerSentEvent
Works with def (sync) too -- use Iterable[T] return type
Auto keep-alive ping every 15s, Cache-Control: no-cache, X-Accel-Buffering: no set by default
Works with any HTTP method (not just GET) -- relevant for MCP-style POST SSE

See sse.md for Last-Event-ID resumption pattern and advanced usage.

strict_content_type (0.132.0) -- Breaking Change

FastAPI now checks Content-Type header on JSON requests by default. Requests without application/json are rejected with 422. Disable per-route:

@app.post("/legacy", strict_content_type=False)
async def legacy_endpoint(data: MyModel):
    ...

Dependency Scopes (0.121.0)

scope="request" makes yield dependency exit code run before the response is sent:

@app.get("/items/")
async def read_items(db: Annotated[Session, Depends(get_db, scope="request")]):
    ...

Without scope="request" (default), exit code runs after the response is fully sent -- correct for StreamingResponse where the dep must stay alive during streaming.

See dependency-injection.md for functools.partial() support and Response as dependency annotation.

Security Classes Return 401 (0.122.0) -- Breaking Change

HTTPBearer, OAuth2, HTTPBasic etc. now raise 401 (not 403) when credentials are missing. Tests asserting status_code == 403 will break.

ORJSONResponse / UJSONResponse Deprecated (0.131.0)

No longer needed. FastAPI 0.130.0+ uses Pydantic's Rust-based JSON serializer automatically when a Pydantic return type annotation or response_model is declared. Without either, falls back to jsonable_encoder.

Pydantic 2.12 Highlights

MISSING sentinel -- canonical solution for PATCH endpoints (distinguish "not provided" from None):

from pydantic.experimental.missing_sentinel import MISSING

class UpdateItem(BaseModel):
    name: str | None | MISSING = MISSING
    price: float | None | MISSING = MISSING

item = UpdateItem()
item.model_dump()  # {} -- MISSING fields excluded

exclude_if -- conditional field exclusion:

value: int = Field(ge=0, exclude_if=lambda v: v == 0)

@model_validator(mode='after') must now be an instance method (not @classmethod). See pydantic-updates.md for all Pydantic 2.9-2.12 changes.

Starlette 1.0 Removals (0.133.0+)

Hard removals (not just deprecated -- will raise errors):

| Removed | Replacement | |---------|-------------| | @app.on_event("startup"/"shutdown") | lifespan= context manager | | on_startup/on_shutdown params | lifespan= context manager | | @app.route() | routes= parameter | | @app.exception_handler() | exception_handlers= parameter | | @app.middleware() | middleware= parameter | | TemplateResponse(name, context) | TemplateResponse(request, name, ...) |

Jinja2Templates: autoescape enabled by default. jinja2 must be installed to import.

Lifespan Migration Pattern

# BROKEN in Starlette 1.0:
@app.on_event("startup")  # AttributeError -- hard removed
async def startup():
    ...

# CORRECT:
from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    # startup
    yield
    # shutdown

app = FastAPI(lifespan=lifespan)

Typed Lifespan State (Starlette 0.52.0)

Access lifespan state with type safety via TypedDict:

from typing import AsyncIterator, TypedDict
from contextlib import asynccontextmanager
import httpx

class AppState(TypedDict):
    http_client: httpx.AsyncClient

@asynccontextmanager
async def lifespan(app) -> AsyncIterator[AppState]:
    async with httpx.AsyncClient() as client:
        yield {"http_client": client}

# In route handler -- typed access:
async def handler(request: Request[AppState]):
    client = request.state["http_client"]  # typed as httpx.AsyncClient

See starlette-changes.md for CORSMiddleware, FileResponse range, ClientDisconnect.

`None` Return Type (0.117.0)

Valid return annotation for endpoints with no body (204, 304):

@app.delete("/items/{item_id}", status_code=204)
async def delete_item(item_id: int) -> None:
    ...

Streaming with yield (0.134.0)

Path operations can yield to stream responses directly -- no manual StreamingResponse needed. Requires Starlette >=0.46.0.

functools.partial() Dependencies (0.123.5)

Dependencies now fully support functools.partial() and functools.wraps():

from functools import partial

def get_db(engine: Engine, read_only: bool = False):
    ...

get_prod_db = partial(get_db, engine=prod_engine)

@app.get("/items")
async def read_items(db=Depends(get_prod_db)):
    ...

See dependency-injection.md for full details.

Reference Files

| File | Contents | |------|----------| | sse.md | SSE Last-Event-ID resumption, advanced ServerSentEvent usage | | breaking-changes.md | All breaking changes: strict_content_type, 401 security, bytes schema, Starlette 1.0 removals | | pydantic-updates.md | Pydantic 2.9-2.12: MISSING sentinel, exclude_if, temporal config, model_validator changes | | dependency-injection.md | Scopes, functools.partial/wraps, Response as dep, PEP 695 TypeAliasType | | starlette-changes.md | Starlette 0.39-1.0: typed lifespan state, CORSMiddleware, FileResponse range, ClientDisconnect | | ecosystem.md | SQLModel 0.0.25-0.0.36, Uvicorn changes, FastAPI Cloud CLI |

Agent Skills: FastAPI Knowledge Patch (0.112 to 0.135.3)

Install this agent skill to your local

Skill Files