# 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 as a script file and run:

## 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}\n\n"
    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 -->

## 快速使用

```bash
pip install fastapi uvicorn
```

几分钟构建生产级 AI 后端 API。

## 什么是 FastAPI？

Python 最快的 Web 框架，AI 后端 API 首选。自动文档、Pydantic 验证、异步支持。

**一句话总结**：Python #1 AI 后端框架，自动 OpenAPI 文档 + Pydantic 验证 + 异步 + 最快性能，OpenAI/Anthropic/HuggingFace 使用，80k+ stars。

**适合人群**：构建 LLM 应用后端 API 的 AI 团队。

## 核心功能

### 1. 自动文档 — /docs 交互式 Swagger UI
### 2. Pydantic 验证 — 类型安全的请求/响应
### 3. 异步支持 — 高并发 LLM 调用
### 4. 流式响应 — SSE 实时输出

## 常见问题

**Q: FastAPI vs Flask？**
A: 新项目选 FastAPI，异步+验证+文档+更快。

## 来源与致谢

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

---
Source: https://tokrepo.com/en/workflows/00db0ed8-cdb7-4a83-bf67-a2fcae16f6bf
Author: Script Depot