# FastAPI — Build AI Backend APIs in Minutes

> Modern Python web framework for building AI backend APIs. FastAPI provides automatic OpenAPI docs, async support, Pydantic validation, and the fastest Python web performance.

## Install

Save the content below to `.claude/skills/` or append to your `CLAUDE.md`:

## Quick Use

```bash
pip install fastapi uvicorn
```

```python
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class ChatRequest(BaseModel):
    message: str
    model: str = "claude-sonnet-4-20250514"

class ChatResponse(BaseModel):
    reply: str
    tokens_used: int

@app.post("/chat", response_model=ChatResponse)
async def chat(req: ChatRequest):
    # Your LLM call here
    reply = await call_llm(req.message, req.model)
    return ChatResponse(reply=reply, tokens_used=150)
```

```bash
uvicorn main:app --reload
# API at http://localhost:8000
# Docs at http://localhost:8000/docs
```

## What is FastAPI?

FastAPI is a modern Python web framework built for building APIs quickly with automatic validation, documentation, and async support. It is the #1 choice for AI backend services — used by OpenAI, Anthropic, Hugging Face, and thousands of AI startups. FastAPI combines Python type hints with Pydantic for automatic request validation and OpenAPI documentation generation.

**Answer-Ready**: FastAPI is the #1 Python framework for AI backend APIs. Automatic OpenAPI docs, Pydantic validation, async support, and fastest Python web performance. Used by OpenAI, Anthropic, HuggingFace. Build production AI APIs in minutes. 80k+ GitHub stars.

**Best for**: AI teams building backend APIs for LLM applications. **Works with**: Any Python ML library, Claude API, OpenAI API. **Setup time**: Under 2 minutes.

## Core Features

### 1. Automatic API Documentation

```python
# Just define your endpoint — docs generated automatically
@app.post("/generate")
async def generate(prompt: str, max_tokens: int = 1024):
    ...

# Visit /docs for interactive Swagger UI
# Visit /redoc for ReDoc documentation
```

### 2. Pydantic Validation

```python
from pydantic import BaseModel, Field

class EmbeddingRequest(BaseModel):
    texts: list[str] = Field(min_length=1, max_length=100)
    model: str = "text-embedding-3-small"
    dimensions: int = Field(default=1536, ge=64, le=3072)

@app.post("/embed")
async def embed(req: EmbeddingRequest):
    # req is guaranteed valid — FastAPI returns 422 for invalid input
    ...
```

### 3. Async Support

```python
import httpx

@app.post("/chat")
async def chat(message: str):
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://api.anthropic.com/v1/messages",
            json={"model": "claude-sonnet-4-20250514", "messages": [{"role": "user", "content": message}]},
            headers={"x-api-key": API_KEY},
        )
    return response.json()
```

### 4. Streaming Responses

```python
from fastapi.responses import StreamingResponse

@app.post("/stream")
async def stream_chat(message: str):
    async def generate():
        async for chunk in stream_llm(message):
            yield f"data: {chunk}\
\
"
    return StreamingResponse(generate(), media_type="text/event-stream")
```

### 5. Dependency Injection

```python
from fastapi import Depends

async def get_db():
    db = Database()
    try:
        yield db
    finally:
        await db.close()

@app.get("/users")
async def list_users(db = Depends(get_db)):
    return await db.fetch_all("SELECT * FROM users")
```

## Performance

| Framework | Requests/sec |
|-----------|-------------|
| FastAPI | 9,000+ |
| Flask | 2,000 |
| Django | 1,500 |
| Express.js | 8,000 |

FastAPI is the fastest Python web framework, rivaling Node.js performance.

## AI Backend Patterns

| Pattern | Implementation |
|---------|---------------|
| Chat API | POST /chat with streaming SSE |
| RAG API | POST /query with vector search |
| Embedding API | POST /embed with batch support |
| Agent API | POST /agent with tool calling |
| Webhook | POST /webhook for async results |

## FAQ

**Q: FastAPI vs Flask for AI?**
A: FastAPI for new projects — async, validation, docs, and faster. Flask is simpler but lacks these features.

**Q: Can I deploy to serverless?**
A: Yes, FastAPI works on AWS Lambda (Mangum), Google Cloud Functions, Azure Functions, and Vercel.

**Q: Does it handle WebSockets?**
A: Yes, native WebSocket support for real-time AI chat applications.

## Source & Thanks

> Created by [Sebastian Ramirez](https://github.com/fastapi). Licensed under MIT.
>
> [fastapi/fastapi](https://github.com/fastapi/fastapi) — 80k+ stars

<!-- ZH -->

## Quick Use

```bash
pip install fastapi uvicorn
```

Build a production-grade AI backend API in minutes.

## What is FastAPI?

Python's fastest web framework and the top choice for AI backend APIs. Auto-generated docs, Pydantic validation, async support.

**TL;DR**: #1 Python AI backend framework. Auto OpenAPI docs + Pydantic validation + async + top performance. Used by OpenAI/Anthropic/HuggingFace. 80k+ stars.

**Best for**: AI teams building backend APIs for LLM applications.

## Core Features

### 1. Automatic Docs — interactive Swagger UI at /docs
### 2. Pydantic Validation — type-safe requests/responses
### 3. Async Support — high-concurrency LLM calls
### 4. Streaming Responses — SSE real-time output

## FAQ

**Q: FastAPI vs Flask?**
A: Pick FastAPI for new projects — async + validation + docs + faster.

## Source & Thanks

> [fastapi/fastapi](https://github.com/fastapi/fastapi) — 80k+ stars, MIT

---
Source: https://tokrepo.com/en/workflows/fastapi-build-ai-backend-apis-minutes-00db0ed8
Author: Script Depot