fastapi

## When to use this skill

Use this skill whenever the user wants to:
- Build REST or async APIs with FastAPI and Pydantic models
- Implement dependency injection, authentication, or middleware
- Configure routing, OpenAPI documentation, and deployment
- Integrate with databases using async patterns

## How to use this skill

### Workflow

1. **Create app** — instantiate `FastAPI()` and define route handlers
2. **Define models** — use Pydantic for request/response validation
3. **Add dependencies** — implement DI for auth, DB sessions, etc.
4. **Test and deploy** — run with uvicorn, verify via `/docs`

### Quick Start Example

```python
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
from datetime import datetime

app = FastAPI(title="My API", version="1.0.0")

# Request/Response models
class ItemCreate(BaseModel):
    name: str
    price: float
    description: str | None = None

class ItemResponse(ItemCreate):
    id: int
    created_at: datetime

# Dependency example
async def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# Route handlers
@app.post("/items/", response_model=ItemResponse, status_code=201)
async def create_item(item: ItemCreate, db=Depends(get_db)):
    db_item = Item(**item.model_dump())
    db.add(db_item)
    db.commit()
    return db_item

@app.get("/items/{item_id}", response_model=ItemResponse)
async def get_item(item_id: int, db=Depends(get_db)):
    item = db.query(Item).get(item_id)
    if not item:
        raise HTTPException(status_code=404, detail="Item not found")
    return item
```

```bash
# Run the server
uvicorn main:app --reload

# Interactive docs available at http://localhost:8000/docs
```

### Authentication Example

```python
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.get("/users/me")
async def read_current_user(token: str = Depends(oauth2_scheme)):
    user = verify_token(token)
    if not user:
        raise HTTPException(status_code=401, detail="Invalid token")
    return user
```

## Best Practices

- Define explicit request and response schemas with Pydantic; use consistent status codes
- Use async functions and database connection pools for high concurrency
- Configure CORS middleware and security headers for production
- Leverage automatic OpenAPI docs (`/docs`, `/redoc`) for API exploration
- Use `BackgroundTasks` for non-blocking operations like email sending

## Reference

- Official documentation: https://fastapi.tiangolo.com/

## Keywords

fastapi, async API, Pydantic, OpenAPI, dependency injection, Python web, REST API, uvicorn