fastapi-patterns
Skill17 starsChanged 5 months agoApache-2.0Archived repositoryView on GitHub
Build production FastAPI applications with dependency injection, middleware, background tasks, and structured project layouts. Covers async patterns, Pydantic models, OpenAPI customization, and testing strategies. Triggers on FastAPI development, Python API, or async web framework requests.
21 other projects use a version of this.
Adopted by
Most recently taken up by
- skateddu/claude-code-python-setuptheir own version, first seen Nov 8, 2026
- ahmadvahidi/skill-atlastheir own version, first seen Nov 8, 2026
- ControllableModel/SWE-Skills-Benchtheir own version, first seen Nov 8, 2026
- ku5ic/claude-kittheir own version, first seen Nov 4, 2026
- ai-enhanced-engineer/aiee-skillstheir own version, first seen Nov 1, 2026
- renepf/claude-skillstheir own version, first seen Oct 25, 2026
Used with
Projects with it also use typescript-patterns, docker-patterns and 9 more.
Other files people use alongside this one.
Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
cohen-lielSkilltypescript-patterns
TypeScript best practices and patterns. Use when writing TypeScript code, defining types, working with generics, or converting JavaScript to TypeScript.
Also in 3 projects that use this
LangChainSkilldocker-patterns
Best practices for Docker containerization and multi-stage builds
Also in 7 projects that use this
mstuder-slalomSkillgolang-patterns
Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications.
Also in 5 projects that use this
mstuder-slalomSkilldjango-security
Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations.
Also in 4 projects that use this
xenitV1Skillpython-patterns
Python development principles and decision-making. Framework selection, async patterns, type hints, project structure. Teaches thinking, not copying.
Also in 6 projects that use this
nek1987Skillpostgres-patterns
PostgreSQL patterns for reviewing migrations and writing efficient queries. Use when reviewing Alembic migrations, optimizing queries, or debugging database issues.
Also in 5 projects that use this
- +1 more from mstuder-slalom
Other versions21 projects use a version of this.
Word for word · 1
- organvm-iv-taxis/a-i--skills★ 17100% same
Edited · 0
None found.
Wrote their own version · 20
- Fmarzochi/EGC★ 61same name
- skateddu/claude-code-python-setup★ 28same name
- ControllableModel/SWE-Skills-Bench★ 8same name
- gongyijie85/dsh-ecc★ 8same name
- hieutrtr/ai1-skills★ 8same name
- ai-enhanced-engineer/aiee-skills★ 4same name
- peopleforrester/claude-dotfiles★ 3same name
- bjornjee/skills★ 2same name
- ku5ic/claude-kit★ 2same name
- ronmkr/PromptBook★ 2same name
10 more not listed
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository170 other files it gives its agents.
- AGENTS.mdAGENTS.md
- docs/AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- .github/copilot-instructions.mdCopilot instructions
- algorithmic-artSkill
- audio-engineering-patternsSkill
- canvas-designSkill
- creative-writing-craftSkill
- generative-art-algorithmsSkill
- generative-art-deploymentSkill
- generative-music-composerSkill
- interactive-theatre-designerSkill
- modular-synthesis-philosophySkill
- movement-notation-systemsSkill
- narratological-algorithmsSkill
- natural-center-extractionSkill
- react-three-fiber-patternsSkill
- reality-tv-narrative-analyzerSkill
- script-analysis-dramaturgicalSkill
- theme-factorySkill
- three-js-interactive-builderSkill
- corpus-persona-extractionSkill
- data-ingestion-pipelineSkill
- data-pipeline-architectSkill
- data-storytelling-analystSkill
- market-gap-analysisSkill
- ml-experiment-trackerSkill
- prompt-atom-formalizationSkill
- sql-query-optimizerSkill
- systemic-product-analystSkill
- time-series-analystSkill
- accessibility-patternsSkill
- agent-testing-patternsSkill
- api-design-patternsSkill
- artifacts-builderSkill
- backend-implementation-patternsSkill
- browser-extension-patternsSkill
- cli-tool-designSkill
- code-refactoring-patternsSkill
- code-review-checklistSkill
- coding-standards-enforcerSkill
- community-platform-patternsSkill
- configuration-managementSkill
- continuous-learning-agentSkill
- data-backup-patternsSkill
- database-migration-patternsSkill
- deployment-cicdSkill
- docker-containerizationSkill
- dotfile-systems-architectSkill
- error-handling-logging-patternsSkill
- feature-workflow-orchestratorSkill
- frontend-design-systemsSkill
- fullstack-starter-packSkill
- gcp-resource-optimizerSkill
- htmx-interaction-patternsSkill
- iterative-code-explorationSkill
- json-schema-designSkill
- mcp-builderSkill
- mcp-server-orchestratorSkill
- mobile-platform-architectSkill
- The first 60 shown.
The file
Files
FastAPI Patterns
Build production-ready async APIs with FastAPI's dependency injection and type system.
Project Layout
src/
├── app/
│ ├── __init__.py
│ ├── main.py # FastAPI app factory
│ ├── config.py # Pydantic Settings
│ ├── dependencies.py # Shared DI providers
│ ├── middleware.py # Custom middleware
│ ├── routers/
│ │ ├── __init__.py
│ │ ├── skills.py
│ │ └── registry.py
│ ├── models/
│ │ ├── __init__.py
│ │ ├── skill.py # Pydantic models
│ │ └── registry.py
│ ├── services/
│ │ ├── __init__.py
│ │ ├── skill_service.py
│ │ └── registry_service.py
│ └── db/
│ ├── __init__.py
│ └── session.py
└── tests/
├── conftest.py
└── test_skills.pyApp Factory
from fastapi import FastAPI
from contextlib import asynccontextmanager
@asynccontextmanager
async def lifespan(app: FastAPI):
# Startup
await init_db()
await init_cache()
yield
# Shutdown
await close_db()
await close_cache()
def create_app() -> FastAPI:
app = FastAPI(
title="ORGANVM Skills API",
version="1.0.0",
lifespan=lifespan,
)
app.include_router(skills_router, prefix="/api/skills", tags=["skills"])
app.include_router(registry_router, prefix="/api/registry", tags=["registry"])
app.add_middleware(CorrelationMiddleware)
return app
app = create_app()Dependency Injection
from fastapi import Depends
from typing import Annotated
async def get_db():
async with async_session() as session:
yield session
async def get_current_user(token: str = Depends(oauth2_scheme)) -> User: # allow-secret
user = await verify_token(token)
if not user:
raise HTTPException(status_code=401, detail="Invalid token")
return user
# Type aliases for clean signatures
DB = Annotated[AsyncSession, Depends(get_db)]
CurrentUser = Annotated[User, Depends(get_current_user)]
@router.get("/skills/{skill_id}")
async def get_skill(skill_id: str, db: DB, user: CurrentUser) -> SkillResponse:
skill = await db.get(Skill, skill_id)
if not skill:
raise HTTPException(status_code=404, detail="Skill not found")
return SkillResponse.model_validate(skill)Pydantic Models
from pydantic import BaseModel, Field
from datetime import datetime
class SkillBase(BaseModel):
name: str = Field(pattern=r"^[a-z][a-z0-9-]*$", min_length=2, max_length=64)
description: str = Field(min_length=20, max_length=600)
category: str
tags: list[str] = []
class SkillCreate(SkillBase):
pass
class SkillResponse(SkillBase):
id: str
created_at: datetime
updated_at: datetime
model_config = {"from_attributes": True}
class SkillList(BaseModel):
items: list[SkillResponse]
total: int
page: int
per_page: intRouter Patterns
from fastapi import APIRouter, Query
router = APIRouter()
@router.get("/", response_model=SkillList)
async def list_skills(
db: DB,
category: str | None = None,
tag: str | None = None,
page: int = Query(default=1, ge=1),
per_page: int = Query(default=20, ge=1, le=100),
) -> SkillList:
query = select(Skill)
if category:
query = query.where(Skill.category == category)
if tag:
query = query.where(Skill.tags.contains([tag]))
total = await db.scalar(select(func.count()).select_from(query.subquery()))
skills = await db.scalars(query.offset((page - 1) * per_page).limit(per_page))
return SkillList(items=skills.all(), total=total, page=page, per_page=per_page)
@router.post("/", response_model=SkillResponse, status_code=201)
async def create_skill(data: SkillCreate, db: DB, user: CurrentUser) -> SkillResponse:
skill = Skill(**data.model_dump())
db.add(skill)
await db.commit()
await db.refresh(skill)
return SkillResponse.model_validate(skill)Background Tasks
from fastapi import BackgroundTasks
@router.post("/skills/{skill_id}/validate")
async def validate_skill(
skill_id: str,
background_tasks: BackgroundTasks,
db: DB,
):
skill = await db.get(Skill, skill_id)
background_tasks.add_task(run_validation, skill_id)
return {"status": "validation_queued", "skill_id": skill_id}
async def run_validation(skill_id: str):
# Long-running validation logic
async with async_session() as db:
skill = await db.get(Skill, skill_id)
result = await validate_frontmatter(skill)
skill.validation_status = result.status
await db.commit()Error Handling
from fastapi import Request
from fastapi.responses import JSONResponse
class AppError(Exception):
def __init__(self, message: str, code: str, status: int):
self.message = message
self.code = code
self.status = status
@app.exception_handler(AppError)
async def app_error_handler(request: Request, exc: AppError):
return JSONResponse(
status_code=exc.status,
content={"error": {"code": exc.code, "message": exc.message}},
)Testing
import pytest
from httpx import AsyncClient, ASGITransport
@pytest.fixture
async def client():
async with AsyncClient(
transport=ASGITransport(app=app),
base_url="http://test",
) as client:
yield client
@pytest.mark.asyncio
async def test_list_skills(client: AsyncClient):
response = await client.get("/api/skills/")
assert response.status_code == 200
data = response.json()
assert "items" in data
assert "total" in data
@pytest.mark.asyncio
async def test_create_skill(client: AsyncClient):
response = await client.post("/api/skills/", json={
"name": "test-skill",
"description": "A test skill for unit testing purposes",
"category": "development",
})
assert response.status_code == 201
assert response.json()["name"] == "test-skill"Anti-Patterns
- Sync database calls — Always use async drivers (asyncpg, aiosqlite)
- Business logic in routes — Extract to service layer for testability
- No response models — Always define response_model for API documentation
- Global state — Use dependency injection, not module-level singletons
- Missing validation — Pydantic models should validate all inputs
- No lifespan management — Use the lifespan context manager for startup/shutdown
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

