Generated banner for Fastapi Templates
Generated logo for Fastapi Templates

Fastapi Templates

Seth HobsonCommunityCreated by Seth Hobson

  • Skill
  • Guidelines
  • Software development
  • MIT
  • Low risk

From the author

Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Use when building new FastAPI applications or setting up backend API projects.
— the description by Seth Hobson

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a standardized project structure and implementation patterns for FastAPI applications. It emphasizes high-performance asynchronous programming, utilizing SQLAlchemy 2.0 with async drivers, Pydantic for data validation, and a modular architecture that separates concerns into APIs, services, repositories, and core configurations. It includes best practices for dependency injection, database session management, and testing with pytest-asyncio.

What it does

  • Defines a modular project directory structure for FastAPI applications.
  • Implements asynchronous database interactions using SQLAlchemy 2.0.
  • Provides a repository pattern for clean data access layer management.
  • Configures dependency injection for database sessions and application settings.
  • Includes boilerplate for CORS middleware and application lifespan events.
  • Offers testing patterns using pytest-asyncio and httpx for integration tests.

When to use it

  • When starting a new FastAPI project from scratch.
  • When you need a scalable architecture for a high-performance web service.
  • When implementing asynchronous REST APIs with PostgreSQL or MongoDB.
  • When you want to enforce consistent dependency injection and error handling patterns.

Advantages

  • Promotes clean code through separation of concerns (API, services, repositories).
  • Ensures production-readiness with async-first patterns.
  • Simplifies testing with pre-configured async test fixtures.
  • Reduces setup time for standard backend API requirements.

Usage examples

“How should I structure a new FastAPI project for scalability?”
The skill provides a recommended directory layout separating API routes, business logic, data models, and repositories to ensure maintainability.
“How do I implement an async database session in FastAPI?”
The skill provides a pattern using SQLAlchemy's AsyncSession with a dependency injection function that handles session lifecycle, commits, and rollbacks.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/wshobson/fastapi-templates/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip fastapi-templates.zip -d .agents/skills

Documentation by Seth Hobson

FastAPI Project Templates

Production-ready FastAPI project structures with async patterns, dependency injection, middleware, and best practices for building high-performance APIs.

When to Use This Skill

  • Starting new FastAPI projects from scratch

  • Implementing async REST APIs with Python

  • Building high-performance web services and microservices

  • Creating async applications with PostgreSQL, MongoDB

  • Setting up API projects with proper structure and testing

Core Concepts

1. Project Structure

Recommended Layout:

app/
├── api/                    # API routes
│   ├── v1/
│   │   ├── endpoints/
│   │   │   ├── users.py
│   │   │   ├── auth.py
│   │   │   └── items.py
│   │   └── router.py
│   └── dependencies.py     # Shared dependencies
├── core/                   # Core configuration
│   ├── config.py
│   ├── security.py
│   └── database.py
├── models/                 # Database models
│   ├── user.py
│   └── item.py
├── schemas/                # Pydantic schemas
│   ├── user.py
│   └── item.py
├── services/               # Business logic
│   ├── user_service.py
│   └── auth_service.py
├── repositories/           # Data access
│   ├── user_repository.py
│   └── item_repository.py
└── main.py                 # Application entry
2. Dependency Injection

FastAPI's built-in DI system using Depends:

  • Database session management

  • Authentication/authorization

  • Shared business logic

  • Configuration injection

3. Async Patterns

Proper async/await usage:

  • Async route handlers

  • Async database operations

  • Async background tasks

  • Async middleware

4. Dependencies

The packages the examples import:

# requirements.txt
fastapi
uvicorn[standard]
pydantic-settings
sqlalchemy[asyncio]>=2.0  # DeclarativeBase; [asyncio] installs greenlet for the async engine
asyncpg                   # PostgreSQL driver: postgresql+asyncpg://...
PyJWT
pwdlib[argon2]
python-multipart          # only for a login route that uses OAuth2PasswordRequestForm

# requirements-dev.txt
pytest
pytest-asyncio
httpx
aiosqlite                 # test database: sqlite+aiosqlite:///:memory:

Detailed worked examples and patterns

Detailed sections (starting with ## Implementation Patterns) live in references/details.md. Read that file when the navigation summary above is insufficient.

Testing

# tests/conftest.py
import pytest_asyncio
from httpx import ASGITransport, AsyncClient
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker

from app.main import app
from app.core.database import get_db, Base

TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"

# Async fixtures need pytest_asyncio.fixture in pytest-asyncio's default strict mode
@pytest_asyncio.fixture
async def db_session():
    engine = create_async_engine(TEST_DATABASE_URL, echo=True)
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)

    AsyncSessionLocal = sessionmaker(
        engine, class_=AsyncSession, expire_on_commit=False
    )

    async with AsyncSessionLocal() as session:
        yield session
    await engine.dispose()

@pytest_asyncio.fixture
async def client(db_session):
    async def override_get_db():
        yield db_session

    app.dependency_overrides[get_db] = override_get_db

    # httpx 0.28 removed AsyncClient(app=...); use an ASGI transport
    transport = ASGITransport(app=app)
    async with AsyncClient(transport=transport, base_url="http://test") as client:
        yield client
    app.dependency_overrides.clear()

# tests/test_users.py
import pytest

@pytest.mark.asyncio
async def test_create_user(client):
    response = await client.post(
        "/api/v1/users/",
        json={
            "email": "[email protected]",
            "password": "testpass123",
            "name": "Test User"
        }
    )
    assert response.status_code == 201
    data = response.json()
    assert data["email"] == "[email protected]"
    assert "id" in data

Files

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Low risk

  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Seth Hobson
Publisher
Seth Hobson (Community)
Source
wshobson/agents · plugins/api-scaffolding/skills/fastapi-templates · commit 4bde316
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Seth Hobson or Seth Hobson.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download fastapi-templates.zip