About fastapi
fastapi is a skill for developers building FastAPI applications. It provides patterns and examples for asynchronous endpoints, Pydantic schemas, dependency injection, background tasks, WebSockets, and API documentation.
Key features
- 01Application structure and run commands
- 02Async endpoint and router patterns
- 03Pydantic schema examples
- 04Dependency injection patterns
- 05Background tasks and WebSockets
Use cases
- 01Creating FastAPI application endpoints
- 02Defining request and response schemas
- 03Wiring services through dependencies
- 04Handling background work or WebSocket messages
Install
Copy the command and run it in a terminal.
npx skills add https:/After installing, type/fastapiin Claude Code to confirm it loaded.
Details
From the project READMEFastAPI Skill
Provides comprehensive FastAPI development capabilities for the Golden Armada AI Agent Fleet Platform.
When to Use This Skill
Activate this skill when working with:
- FastAPI application development
- Async endpoint implementation
- Pydantic model definitions
- Dependency injection patterns
- OpenAPI/Swagger documentation
Quick Reference
Run Commands
```bash
Development
uvicorn main:app --reload --host 0.0.0.0 --port 8000
Production
uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4
With Gunicorn
gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000 ```
Application Structure
``` app/ ├── main.py ├── config.py ├── dependencies.py ├── routers/ │ ├── init.py │ ├── agents.py │ └── tasks.py ├── models/ │ ├── init.py │ ├── agent.py │ └── task.py ├── schemas/ │ ├── init.py │ ├── agent.py │ └── task.py └── services/ ├── init.py └── llm_service.py ```
Basic Application
```python
main.py
from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware from contextlib import asynccontextmanager
from app.routers import agents, tasks from app.config import settings
@asynccontextmanager async def lifespan(app: FastAPI): # Startup print("Starting up...") yield # Shutdown print("Shutting down...")
app = FastAPI( title="Golden Armada Agent API", version="1.0.0", lifespan=lifespan )
app.add_middleware( CORSMiddleware, allow_origins=settings.allowed_origins, allow_credentials=True, allow_methods=[""], allow_headers=[""], )
app.include_router(agents.router, prefix="/api/v1/agents", tags=["agents"]) app.include_router(tasks.router, prefix="/api/v1/tasks", tags=["tasks"])
@app.get("/health") async def health_check(): return {"status": "healthy", "service": "golden-armada"} ```
Pydantic Schemas
```python
schemas/agent.py
from pydantic import BaseModel, Field from typing import Optional from enum import Enum
class AgentType(str, Enum): CLAUDE = "claude" GPT = "gpt" GEMINI = "gemini"
class AgentBase(BaseModel): name: str = Field(..., min_length=1, max_length=100) type: AgentType description: Optional[str] = None
class AgentCreate(AgentBase): pass
class AgentResponse(AgentBase): id: str status: str created_at: datetime
model_config = ConfigDict(from_attributes=True)
```
Router Example
```python
routers/agents.py
from fastapi import APIRouter, HTTPException, Depends, status from typing import List
from app.schemas.agent import AgentCreate, AgentResponse from app.services.agent_service import AgentService from app.dependencies import get_agent_service
router = APIRouter()
@router.post("/", response_model=AgentResponse, status_code=status.HTTP_201_CREATED) async def create_agent( agent: AgentCreate, service: AgentService = Depends(get_agent_service) ): """Create a new agent.""" return await service.create(agent)
@router.get("/", response_model=List[AgentResponse]) async def list_agents( skip: int = 0, limit: int = 100, service: AgentService = Depends(get_agent_service) ): """List all agents.""" return await service.list(skip=skip, limit=limit)
@router.get("/{agent_id}", response_model=AgentResponse) async def get_agent( agent_id: str, service: AgentService = Depends(get_agent_service) ): """Get agent by ID.""" agent = await service.get(agent_id) if not agent: raise HTTPException(status_code=404, detail="Agent not found") return agent ```
Dependency Injection
```python
dependencies.py
from functools import lru_cache from typing import Annotated from fastapi import Depends
from app.config import Settings from app.services.agent_service import AgentService from app.services.llm_service import LLMService
@lru_cache def get_settings(): return Settings()
async def get_llm_service( settings: Annotated[Settings, Depends(get_settings)] ) -> LLMService: return LLMService(api_key=settings.anthropic_api_key)
async def get_agent_service( llm_service: Annotated[LLMService, Depends(get_llm_service)] ) -> AgentService: return AgentService(llm_service=llm_service) ```
Background Tasks
```python from fastapi import BackgroundTasks
@router.post("/tasks/{task_id}/execute") async def execute_task( task_id: str, background_tasks: BackgroundTasks, service: TaskService = Depends(get_task_service) ): background_tasks.add_task(service.execute_async, task_id) return {"status": "accepted", "task_id": task_id} ```
WebSocket Support
```python from fastapi import WebSocket, WebSocketDisconnect
@router.websocket("/ws/{agent_id}") async def agent_websocket(websocket: WebSocket, agent_id: str): await websocket.accept() try: while True: data = await websocket.receive_text() response = await process_message(agent_id, data) await websocket.send_text(response) except WebSocketDisconnect: print(f"Agent {agent_id} disconnected") ```