Fastapi Templates
Seth HobsonCommunityCreated by Seth Hobson
- Skill
- Guidelines
- Software development
- MIT
- Low risk
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
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/wshobson/fastapi-templates/downloadUnzip 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 entry2. 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 dataFiles
- ATTRIBUTION.mdAdded by AutoGineer981 B
- LICENSELicence file added by AutoGineer1.0 KiB
- SKILL.md4.4 KiB
- references/details.md12.7 KiB
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.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download fastapi-templates.zip