From 3cad74403e30237995f1385c537100e8cbc7f63c Mon Sep 17 00:00:00 2001
From: Rohit Verma <133568861+Rohit27305@users.noreply.github.com>
Date: Mon, 23 Feb 2026 12:50:15 +0530
Subject: [PATCH] docs: update README.md via AI documentation agent
---
README.md | 536 ++++--------------------------------------------------
1 file changed, 40 insertions(+), 496 deletions(-)
diff --git a/README.md b/README.md
index 16d149f8fe..2d9b6aa400 100644
--- a/README.md
+++ b/README.md
@@ -27,536 +27,80 @@
---
-FastAPI is a modern, fast (high-performance), web framework for building APIs with Python based on standard Python type hints.
+# Overview
-The key features are:
+FastAPI is a modern, fast (high‑performance) web framework for building APIs with Python 3.8+ based on standard Python type hints. It combines the speed of **Node.js** and **Go** with the developer friendliness of **Python**, delivering:
-* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
-* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *
-* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *
-* **Intuitive**: Great editor support. Completion everywhere. Less time debugging.
-* **Easy**: Designed to be easy to use and learn. Less time reading docs.
-* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
-* **Robust**: Get production-ready code. With automatic interactive documentation.
-* **Standards-based**: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.
+* **Performance** – on par with the fastest Python frameworks because it is built on **Starlette** for the web parts and **Pydantic** for the data parts.
+* **Fast to code** – increase development speed by 200 %–300 % thanks to automatic request validation, serialization, interactive API docs, and editor autocompletion.
+* **Reduced bugs** – data validation and type checking catch many errors at runtime, lowering the chance of human‑introduced bugs.
+* **Intuitive** – editors provide instant completion and type checking for request bodies, query parameters, headers, and more.
+* **Production ready** – OpenAPI, JSON‑Schema, automatic interactive documentation (Swagger UI & ReDoc), dependency injection, security utilities, and extensive testing support.
-* estimation based on tests conducted by an internal development team, building production applications.
+# Installation
-## Sponsors
+FastAPI is released on PyPI and can be installed with **pip**. It has no external runtime dependencies besides **uvicorn** (or another ASGI server) for development and production.
-
-### Keystone Sponsor
-
-
-
-### Gold and Silver Sponsors
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Other sponsors
-
-## Opinions
-
-"_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._"
-
-Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Deon Pillsbury -
Cisco (ref)
-
-## **Typer**, the FastAPI of CLIs
-
-
-
-If you are building a CLI app to be used in the terminal instead of a web API, check out **Typer**.
-
-**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀
-
-## Requirements
-
-FastAPI stands on the shoulders of giants:
-
-* Starlette for the web parts.
-* Pydantic for the data parts.
-
-## Installation
-
-Create and activate a virtual environment and then install FastAPI:
-
-
-
-```console
-$ pip install "fastapi[standard]"
-
----> 100%
-```
-
-
-
-**Note**: Make sure you put `"fastapi[standard]"` in quotes to ensure it works in all terminals.
-
-## Example
-
-### Create it
-
-Create a file `main.py` with:
-
-```Python
-from fastapi import FastAPI
-
-app = FastAPI()
-
-
-@app.get("/")
-def read_root():
- return {"Hello": "World"}
-
-
-@app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
- return {"item_id": item_id, "q": q}
-```
-
-
-Or use async def...
-
-If your code uses `async` / `await`, use `async def`:
-
-```Python hl_lines="7 12"
-from fastapi import FastAPI
-
-app = FastAPI()
-
-
-@app.get("/")
-async def read_root():
- return {"Hello": "World"}
-
-
-@app.get("/items/{item_id}")
-async def read_item(item_id: int, q: str | None = None):
- return {"item_id": item_id, "q": q}
-```
-
-**Note**:
-
-If you don't know, check the _"In a hurry?"_ section about `async` and `await` in the docs.
-
-
-
-### Run it
-
-Run the server with:
-
-
-
-```console
-$ fastapi dev main.py
-
- ╭────────── FastAPI CLI - Development mode ───────────╮
- │ │
- │ Serving at: http://127.0.0.1:8000 │
- │ │
- │ API docs: http://127.0.0.1:8000/docs │
- │ │
- │ Running in development mode, for production use: │
- │ │
- │ fastapi run │
- │ │
- ╰─────────────────────────────────────────────────────╯
-
-INFO: Will watch for changes in these directories: ['/home/user/code/awesomeapp']
-INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-INFO: Started reloader process [2248755] using WatchFiles
-INFO: Started server process [2248757]
-INFO: Waiting for application startup.
-INFO: Application startup complete.
-```
-
-
-
-
-About the command fastapi dev main.py...
-
-The command `fastapi dev` reads your `main.py` file, detects the **FastAPI** app in it, and starts a server using Uvicorn.
-
-By default, `fastapi dev` will start with auto-reload enabled for local development.
-
-You can read more about it in the FastAPI CLI docs.
-
-
-
-### Check it
-
-Open your browser at http://127.0.0.1:8000/items/5?q=somequery.
-
-You will see the JSON response as:
-
-```JSON
-{"item_id": 5, "q": "somequery"}
+```bash
+pip install "fastapi[all]" # includes optional dependencies such as python‑multipart, email‑validator, jinja2
+# Or, if you only need the core framework:
+pip install fastapi
```
-You already created an API that:
+> **Note**: FastAPI requires Python **3.8** or newer.
-* Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.
-* Both _paths_ take `GET` operations (also known as HTTP _methods_).
-* The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.
-* The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.
+# Quick start
-### Interactive API docs
+Below is a minimal example that demonstrates the core concepts:
-Now go to http://127.0.0.1:8000/docs.
-
-You will see the automatic interactive API documentation (provided by Swagger UI):
-
-
-
-### Alternative API docs
-
-And now, go to http://127.0.0.1:8000/redoc.
-
-You will see the alternative automatic documentation (provided by ReDoc):
-
-
-
-## Example upgrade
-
-Now modify the file `main.py` to receive a body from a `PUT` request.
-
-Declare the body using standard Python types, thanks to Pydantic.
-
-```Python hl_lines="2 7-10 23-25"
+```python
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
-
class Item(BaseModel):
name: str
+ description: str | None = None
price: float
- is_offer: bool | None = None
-
-
-@app.get("/")
-def read_root():
- return {"Hello": "World"}
-
+ tax: float | None = None
@app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+async def read_item(item_id: int, q: str | None = None):
return {"item_id": item_id, "q": q}
-
-@app.put("/items/{item_id}")
-def update_item(item_id: int, item: Item):
- return {"item_name": item.name, "item_id": item_id}
+@app.post("/items/")
+async def create_item(item: Item):
+ return {"item_id": 1, **item.dict()}
```
-The `fastapi dev` server should reload automatically.
-
-### Interactive API docs upgrade
-
-Now go to http://127.0.0.1:8000/docs.
-
-* The interactive API documentation will be automatically updated, including the new body:
-
-
-
-* Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:
-
-
-
-* Then click on the "Execute" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:
-
-
-
-### Alternative API docs upgrade
-
-And now, go to http://127.0.0.1:8000/redoc.
+Run the application with **uvicorn**:
-* The alternative documentation will also reflect the new query parameter and body:
-
-
-
-### Recap
-
-In summary, you declare **once** the types of parameters, body, etc. as function parameters.
-
-You do that with standard modern Python types.
-
-You don't have to learn a new syntax, the methods or classes of a specific library, etc.
-
-Just standard **Python**.
-
-For example, for an `int`:
-
-```Python
-item_id: int
-```
-
-or for a more complex `Item` model:
-
-```Python
-item: Item
+```bash
+uvicorn myapp:app --reload # where `myapp.py` contains the code above
```
-...and with that single declaration you get:
-
-* Editor support, including:
- * Completion.
- * Type checks.
-* Validation of data:
- * Automatic and clear errors when the data is invalid.
- * Validation even for deeply nested JSON objects.
-* Conversion of input data: coming from the network to Python data and types. Reading from:
- * JSON.
- * Path parameters.
- * Query parameters.
- * Cookies.
- * Headers.
- * Forms.
- * Files.
-* Conversion of output data: converting from Python data and types to network data (as JSON):
- * Convert Python types (`str`, `int`, `float`, `bool`, `list`, etc).
- * `datetime` objects.
- * `UUID` objects.
- * Database models.
- * ...and many more.
-* Automatic interactive API documentation, including 2 alternative user interfaces:
- * Swagger UI.
- * ReDoc.
+Open your browser at to see the automatically generated Swagger UI, or at for ReDoc.
----
+For a more detailed tutorial, see the official documentation: .
-Coming back to the previous code example, **FastAPI** will:
+# Documentation
-* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.
-* Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.
- * If it is not, the client will see a useful, clear error.
-* Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.
- * As the `q` parameter is declared with `= None`, it is optional.
- * Without the `None` it would be required (as is the body in the case with `PUT`).
-* For `PUT` requests to `/items/{item_id}`, read the body as JSON:
- * Check that it has a required attribute `name` that should be a `str`.
- * Check that it has a required attribute `price` that has to be a `float`.
- * Check that it has an optional attribute `is_offer`, that should be a `bool`, if present.
- * All this would also work for deeply nested JSON objects.
-* Convert from and to JSON automatically.
-* Document everything with OpenAPI, that can be used by:
- * Interactive documentation systems.
- * Automatic client code generation systems, for many languages.
-* Provide 2 interactive documentation web interfaces directly.
-
----
-
-We just scratched the surface, but you already get the idea of how it all works.
-
-Try changing the line with:
-
-```Python
- return {"item_name": item.name, "item_id": item_id}
-```
-
-...from:
-
-```Python
- ... "item_name": item.name ...
-```
-
-...to:
-
-```Python
- ... "item_price": item.price ...
-```
+The full documentation lives at . It covers:
-...and see how your editor will auto-complete the attributes and know their types:
+* **Tutorial** – step‑by‑step guide for beginners.
+* **Advanced user guide** – dependency injection, background tasks, websockets, security, testing, etc.
+* **Reference** – exhaustive API reference for `fastapi`, `starlette`, and `pydantic` integration.
+* **API OpenAPI schema** – automatically generated and customizable.
-
+# Contributing
-For a more complete example including more features, see the Tutorial - User Guide.
+Contributions are welcome! Please read our [CONTRIBUTING guide](https://github.com/fastapi/fastapi/blob/master/CONTRIBUTING.md) before submitting a pull request. All contributors are expected to follow the code of conduct and ensure that new code is covered by tests and adheres to the project's style guidelines.
-**Spoiler alert**: the tutorial - user guide includes:
+# License
-* Declaration of **parameters** from other different places as: **headers**, **cookies**, **form fields** and **files**.
-* How to set **validation constraints** as `maximum_length` or `regex`.
-* A very powerful and easy to use **Dependency Injection** system.
-* Security and authentication, including support for **OAuth2** with **JWT tokens** and **HTTP Basic** auth.
-* More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).
-* **GraphQL** integration with Strawberry and other libraries.
-* Many extra features (thanks to Starlette) as:
- * **WebSockets**
- * extremely easy tests based on HTTPX and `pytest`
- * **CORS**
- * **Cookie Sessions**
- * ...and more.
+FastAPI is licensed under the MIT License. See the `LICENSE` file for the full text.
-### Deploy your app (optional)
-
-You can optionally deploy your FastAPI app to FastAPI Cloud, go and join the waiting list if you haven't. 🚀
-
-If you already have a **FastAPI Cloud** account (we invited you from the waiting list 😉), you can deploy your application with one command.
-
-Before deploying, make sure you are logged in:
-
-
-
-```console
-$ fastapi login
-
-You are logged in to FastAPI Cloud 🚀
-```
-
-
-
-Then deploy your app:
-
-
-
-```console
-$ fastapi deploy
-
-Deploying to FastAPI Cloud...
-
-✅ Deployment successful!
-
-🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
-```
-
-
-
-That's it! Now you can access your app at that URL. ✨
-
-#### About FastAPI Cloud
-
-**FastAPI Cloud** is built by the same author and team behind **FastAPI**.
-
-It streamlines the process of **building**, **deploying**, and **accessing** an API with minimal effort.
-
-It brings the same **developer experience** of building apps with FastAPI to **deploying** them to the cloud. 🎉
-
-FastAPI Cloud is the primary sponsor and funding provider for the *FastAPI and friends* open source projects. ✨
-
-#### Deploy to other cloud providers
-
-FastAPI is open source and based on standards. You can deploy FastAPI apps to any cloud provider you choose.
-
-Follow your cloud provider's guides to deploy FastAPI apps with them. 🤓
-
-## Performance
-
-Independent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as one of the fastest Python frameworks available, only below Starlette and Uvicorn themselves (used internally by FastAPI). (*)
-
-To understand more about it, see the section Benchmarks.
-
-## Dependencies
-
-FastAPI depends on Pydantic and Starlette.
-
-### `standard` Dependencies
-
-When you install FastAPI with `pip install "fastapi[standard]"` it comes with the `standard` group of optional dependencies:
-
-Used by Pydantic:
-
-* email-validator - for email validation.
-
-Used by Starlette:
-
-* httpx - Required if you want to use the `TestClient`.
-* jinja2 - Required if you want to use the default template configuration.
-* python-multipart - Required if you want to support form "parsing", with `request.form()`.
-
-Used by FastAPI:
-
-* uvicorn - for the server that loads and serves your application. This includes `uvicorn[standard]`, which includes some dependencies (e.g. `uvloop`) needed for high performance serving.
-* `fastapi-cli[standard]` - to provide the `fastapi` command.
- * This includes `fastapi-cloud-cli`, which allows you to deploy your FastAPI application to FastAPI Cloud.
-
-### Without `standard` Dependencies
-
-If you don't want to include the `standard` optional dependencies, you can install with `pip install fastapi` instead of `pip install "fastapi[standard]"`.
-
-### Without `fastapi-cloud-cli`
-
-If you want to install FastAPI with the standard dependencies but without the `fastapi-cloud-cli`, you can install with `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
-
-### Additional Optional Dependencies
-
-There are some additional dependencies you might want to install.
-
-Additional optional Pydantic dependencies:
-
-* pydantic-settings - for settings management.
-* pydantic-extra-types - for extra types to be used with Pydantic.
-
-Additional optional FastAPI dependencies:
-
-* orjson - Required if you want to use `ORJSONResponse`.
-* ujson - Required if you want to use `UJSONResponse`.
-
-## License
+---
-This project is licensed under the terms of the MIT license.
+*FastAPI – The modern, fast (high‑performance) web framework for building APIs with Python.*
\ No newline at end of file