100 FastAPI resources for developers

The official Tiangolo production-ready template including PostgreSQL, Docker, Celery, and a Vue frontend. Use it to understand the recommended project layout with separate services and alembic migrations.

A curated list of architectural patterns on GitHub (zhanymkanov/fastapi-best-practices) covering folder structure, dependency injection, and centralized exception handling.

Use SQLModel to eliminate code duplication between Pydantic models and SQLAlchemy entities. This reduces the surface area for bugs in larger applications.

Break down large APIs into domain-specific modules using fastapi.APIRouter. Mount them in a main.py file to maintain clean namespaces and manageable file sizes.

Implement the fastapi-versioning library to manage API lifecycle. It allows you to route requests based on header or URL versioning without duplicating the entire codebase.

Move business logic out of path operations and into service classes. Inject these services using FastAPI's Depends() to facilitate easier unit testing with mocks.

Upgrade to Pydantic v2 for up to 20x performance improvement in data validation. Ensure all Field and Validator definitions are updated to the new syntax.

Standardize list responses using the fastapi-pagination library. It supports multiple backends including SQLAlchemy, Tortoise, and Motor with minimal boilerplate.

Register global exception handlers using @app.exception_handler to return standardized JSON error schemas across the entire API.

A template for generating a FastAPI project with pre-configured Docker Compose, CI/CD pipelines, and environment variable management via Pydantic Settings.

Implement the async version of SQLAlchemy's sessionmaker. Use the async_scoped_session for thread-safe operations in high-concurrency environments.

Configure Alembic to use the async driver (e.g., postgresql+asyncpg). Modify the env.py file to use run_async for database schema updates.

Integrate redis-py (async) to cache expensive database queries. Use the fastapi-cache2 library to implement easy decorator-based caching on path functions.

An asynchronous Python ODM for MongoDB based on Pydantic. It allows you to use the same models for database storage and API validation.

A Django-inspired async ORM built specifically for FastAPI. Ideal for developers who prefer an Active Record pattern over SQLAlchemy's Data Mapper pattern.

Optimize PostgreSQL performance by using asyncpg's connection pool directly for high-throughput read operations that don't require a full ORM.

Implement a custom middleware to handle database transactions per request, ensuring automatic rollbacks on 4xx/5xx responses.

Use the Prisma ORM for auto-generated, type-safe database clients. It provides a superior developer experience for complex schema relationships.

An async ORM and query builder that includes a built-in admin interface and migration system, similar to Django but optimized for asyncio.

Create a dedicated /health endpoint that pings the database and Redis to ensure the application is truly ready to receive traffic.

Use fastapi.responses.StreamingResponse to stream tokens from OpenAI or local LLMs to the client in real-time, reducing perceived latency.

Deploy LangChain chains as FastAPI endpoints using LangServe. It automatically generates input/output schemas and provides a playground UI.

Implement Server-Sent Events (SSE) using sse-starlette to push updates from long-running AI inference tasks back to the frontend.

Integrate Ray Serve with FastAPI to scale compute-intensive ML models across a cluster while maintaining a standard REST interface.

Apply rate limiting to expensive AI endpoints using Redis-backed fastapi-limiter to prevent API abuse and manage inference costs.

Use asyncio.Semaphore(n) to limit the number of concurrent requests to a GPU-bound model, preventing OOM (Out of Memory) errors.

Package models with BentoML and serve them via FastAPI. It handles model versioning and provides optimized runners for inference.

Use prometheus-fastapi-instrumentator to track inference time, token usage, and model error rates for production AI services.

Offload data cleaning or vector embedding generation to FastAPI's BackgroundTasks to return immediate 202 Accepted responses to users.

Connect FastAPI to a vLLM inference server for high-throughput LLM serving, utilizing PagedAttention for efficient memory management.

Implement the fastapi-users library for a complete authentication system including registration, JWT/Cookie strategy, and password reset.

Use FastAPI's built-in OAuth2PasswordBearer to implement secure token-based authentication without external providers.

Deploy using Gunicorn with the Uvicorn worker class (uvicorn.workers.UvicornWorker) to manage multiple processes and improve reliability.

Configure Nginx with proxy_buffering off and proxy_set_header Connection 'upgrade' to support WebSockets and streaming responses.

Use pydantic-settings to manage environment variables. It provides automatic validation and type casting for configuration values.

Properly configure CORSMiddleware with specific allow_origins instead of '*' to secure your API against cross-site request forgery.

Write integration tests using httpx.AsyncClient and pytest-asyncio to simulate API requests in an asynchronous test environment.

Use multi-stage Dockerfiles to reduce image size by separating the build dependencies from the final production runtime environment.

Implement simple API Key authentication for internal service-to-service communication using a custom Security dependency.

Override the default Swagger UI settings in the FastAPI constructor to disable documentation in production or add custom branding.