diff --git a/docs/en/mkdocs.yml b/docs/en/mkdocs.yml
index bfa88c06e..2eedb2960 100644
--- a/docs/en/mkdocs.yml
+++ b/docs/en/mkdocs.yml
@@ -345,6 +345,8 @@ extra:
name: ja - 日本語
- link: /ko/
name: ko - 한국어
+ - link: /ml/
+ name: ml - മലയാളം
- link: /nl/
name: nl - Nederlands
- link: /pl/
diff --git a/docs/ml/docs/index.md b/docs/ml/docs/index.md
new file mode 100644
index 000000000..8b13a06a4
--- /dev/null
+++ b/docs/ml/docs/index.md
@@ -0,0 +1,496 @@
+# ഫാസ്റ്റ് API
+
+
+
+
+ 
+
+
+ ഫാസ്റ്റ് API ഫ്രെയിംവർക്ക്, ഉയർന്ന പ്രകടനം, പഠിക്കാൻ എളുപ്പം, നിർമ്മാണത്തിന് തയ്യാറാണ്
+
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+
+---
+
+**ഡോക്യുമെൻ്റേഷൻ**: https://fastapi.tiangolo.com
+
+**സോഴ്സ് കോഡ്**: https://github.com/fastapi/fastapi
+
+---
+
+
+ഫാസ്റ്റ് API ഒരു ആധുനികവും വേഗതയേറിയതുമായ (ഉയർന്ന പ്രകടനക്ഷമതയുള്ള) വെബ് ഫ്രെയിംവർക്ക് ആണ്, ഇത് സ്റ്റാൻഡേർഡ് പൈത്തൺ ടൈപ്പ് ഹിന്റ്സ് അടിസ്ഥാനമാക്കി പൈത്തണിൽ APIകൾ നിർമ്മിക്കാൻ വികസിപ്പിച്ചെടുത്തിരിക്കുന്നു.
+
+പ്രധാന സവിശേഷതകൾ ഇവയാണ്:
+
+* **വേഗതയുള്ള**: വളരെ ഉയർന്ന പ്രകടനം, **NodeJS**, **Go** എന്നിവയ്ക്ക് തുല്യമായി (സ്റ്റാർലെറ്റിനും പൈഡൻ്റിക്കിനും നന്ദി). [ ലഭ്യമായ ഏറ്റവും വേഗമേറിയ പൈത്തൺ ഫ്രെയിംവർക്കുകളിൽ ഒന്നു ](#പർഫോർമൻസ്).
+* **വേഗത്തിൽ കോഡ് ചെയ്യാം**: സവിശേഷതകൾ വികസിപ്പിക്കുന്നതിനുള്ള വേഗത ഏകദേശം 200% മുതൽ 300% വരെ വർദ്ധിപ്പിക്കുന്നു. *
+* **കുറവ് ബഗുകൾ**: മാനുഷിക (ഡെവലപ്പർ) പ്രേരിത പിശകുകളുടെ ഏകദേശം 40% കുറയ്ക്കുന്നു. *
+* **അവബോധജന്യമായ**: മികച്ച എഡിറ്റർ പിന്തുണ. പൂർത്തീകരണം എല്ലായിടത്തും. ചുരുങ്ങിയ സമയത്തിൽ ഡീബഗ്ഗിംഗ്.
+* **എളുപ്പം**: എളുപ്പത്തിൽ ഉപയോഗിക്കാനും പഠിക്കാനും രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. കുറഞ്ഞ സമയം കൊണ്ട് ഡോക്യുമെന്റേഷൻ വായിക്കാം.
+* **ലഘു**: കോഡ് ഡ്യൂപ്ലിക്കേഷൻ കുറയ്ക്കുക. ഓരോ പാരാമീറ്റർ പ്രഖ്യാപനത്തിൽ നിന്നും ഒന്നിലധികം സവിശേഷതകൾ. കുറച്ച് ബഗുകൾ.
+* **കരുത്തുള്ള**: ഓട്ടോമാറ്റിക് ഇൻ്ററാക്ടീവ് ഡോക്യുമെൻ്റേഷൻ ഉപയോഗിച്ച് നിർമ്മാണത്തിന് തയ്യാറായ കോഡ് ലഭിക്കും.
+* **മാനദണ്ഡങ്ങൾ അടിസ്ഥാനമാക്കിയുള്ളത്**: API-കൾക്കുള്ള ഓപ്പൺ സ്റ്റാൻഡേർഡുകളെ അടിസ്ഥാനമാക്കി (പൂർണമായും പൊരുത്തപ്പെടുന്നു): ഓപ്പൺ API (മുമ്പ് സ്വാഗർ എന്നറിയപ്പെട്ടിരുന്നു) and JSON സ്കീമ.
+
+* പ്രൊഡക്ഷൻ ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്ന ഒരു ഇൻറേണൽ ഡെവലപ്‌മെൻറ് ടീമിലെ ടെസ്റ്റുകളെ അടിസ്ഥാനമാക്കിയുള്ള മൂല്യനിർണ്ണയം. "
+
+## Sponsors
+
+
+
+{% if sponsors %}
+{% for sponsor in sponsors.gold -%}
+
+{% endfor -%}
+{%- for sponsor in sponsors.silver -%}
+
+{% endfor %}
+{% endif %}
+
+
+
+Other sponsors
+
+## അഭിപ്രായങ്ങൾ
+
+"_[...] ഞാൻ ഇക്കാലത്ത് **ഫാസ്റ്റ് API** ധാരാളം ഉപയോഗിക്കുന്നുണ്ട്. [...] മൈക്രോസോഫ്റ്റിലെ എന്റെ ടീമിന്റെ എല്ലാ **ML സേവനങ്ങൾക്കും** ഇത് ഉപയോഗിക്കാൻ ഞാൻ പദ്ധതിയിടുന്നു. അവയിൽ ചിലത് കോർ **വിൻഡോസ്** ഉൽപ്പന്നത്തിലും ചില **ഓഫീസ്** ഉൽപ്പന്നങ്ങളിലും സംയോജിപ്പിക്കപ്പെടുന്നു._"
+
+
+
+---
+
+"_**പ്രവചനങ്ങൾ** ലഭിക്കുന്നതിനായി അന്വേഷിക്കാൻ കഴിയുന്ന ഒരു **REST** സെർവർ നിർമ്മിക്കുന്നതിനായി ഞങ്ങൾ **ഫാസ്റ്റ് API** ലൈബ്രറി സ്വീകരിച്ചു. [ലുഡ്‌വിഗിന്]_"
+
+പൈറോ മോളിന, യാരോസ്ലാവ് ഡുഡിൻ, സായ് സുമന്ത് മിര്യാല -
യൂബർ (റഫറൻസ്)കെവിൻ ഗ്ലിസൻ, മാർക്ക് വിലനോവ, ഫോറസ്റ്റ് മോൺസെൻ -
നെറ്റ്ഫ്ലിക്സ് (റഫറൻസ്)
+
+വെബ് API-യ്ക്ക് പകരം ടെർമിനലിൽ ഉപയോഗിക്കുന്നതിനായി CLI ആപ്പ് നിർമ്മിക്കുകയാണെങ്കിൽ, **Typer** പരിശോധിക്കുക.
+
+**ടൈപ്പർ** എന്നത് ഫാസ്റ്റ് API യുടെ ഇളയ സഹോദരനാണ്. CLI-കളുടെ **ഫാസ്റ്റ് API** ആകാനാണ് ഇത് ഉദ്ദേശിക്കുന്നത്. ⌨️ 🚀
+
+## ആവശ്യമായത്
+
+ഫാസ്റ്റ് API ഭീമന്മാരുടെ തോളിൽ നിൽക്കുന്നു:
+
+* സ്റ്റാർലെറ്റ് വെബ് ഭാഗങ്ങൾക്കായി.
+* പൈഡാൻറിക് ഡാറ്റ ഭാഗങ്ങൾക്കായി.
+
+## ഇൻസ്റ്റലേഷൻ
+
+ഒരു വെർച്വൽ എൻവയോൺമെന്റ് സൃഷ്ടിച്ച് സജീവമാക്കുക, തുടർന്ന് ഫാസ്റ്റ് API ഇൻസ്റ്റാൾ ചെയ്യുക:
+
+
+```console
+$ pip install "fastapi[standard]"
+
+---> 100%
+```
+
+
+
+**കുറിപ്പ്**: എല്ലാ ടെർമിനലുകളിലും ഇത് പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഉദ്ധരണികളിൽ `"fastapi[standard]"` എന്ന് ചേർത്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക.
+
+## ഉദാഹരണം
+
+### സൃഷ്ടിക്കൂ
+
+* `main.py` എന്ന ഫയൽ സൃഷ്ടിക്കുക:
+
+```Python
+from typing import Union
+
+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: Union[str, None] = None):
+ return {"item_id": item_id, "q": q}
+```
+
+
+Or use async def...
+
+നിങ്ങളുടെ കോഡ് `async` / `await` ഉപയോഗിക്കുകയാണെങ്കിൽ, `async def` ഉപയോഗിക്കുക:
+
+```Python hl_lines="9 14"
+from typing import Union
+
+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: Union[str, None] = None):
+ return {"item_id": item_id, "q": q}
+```
+
+**കുറിപ്പ്**:
+
+നിങ്ങൾക്ക് അറിയില്ലെങ്കിൽ, ഡോക്യുമെന്റിലെ `async` ഉം `wait` ഉം എന്നതിനെക്കുറിച്ചുള്ള _"തിരക്കിലാണ്?"_ വിഭാഗം പരിശോധിക്കുക.
+
+
+
+### പ്രവർത്തിപ്പിക്കുക
+
+സെർവർ ഇതുപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുക:
+
+
+
+```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.
+```
+
+
+
+
+ fastapi dev main.py കമാൻഡിനെക്കുറിച്ച്...
+
+`fastapi dev` എന്ന കമാൻഡ് നിങ്ങളുടെ `main.py` ഫയൽ വായിക്കുകയും അതിലെ **FastAPI** ആപ്പ് കണ്ടെത്തുകയും Uvicorn ഉപയോഗിച്ച് ഒരു സെർവർ ആരംഭിക്കുകയും ചെയ്യുന്നു.
+
+ഡിഫോൾട്ടായി, പ്രാദേശിക വികസനത്തിനായി പ്രവർത്തനക്ഷമമാക്കിയ ഓട്ടോ-റീലോഡ് ഉപയോഗിച്ചായിരിക്കും `fastapi dev` ആരംഭിക്കുക.
+
+FastAPI CLI ഡോക്യുമെന്റുകളിൽ ഇതിനെക്കുറിച്ച് നിങ്ങൾക്ക് കൂടുതൽ വായിക്കാം.
+
+
+
+### Check it
+
+http://127.0.0.1:8000/items/5?q=somequery എന്ന അഡ്രസ് നിങ്ങളുടെ ബ്രൗസറിൽ തുറക്കുക.
+
+നിങ്ങൾക്ക് JSON പ്രതികരണം ഇങ്ങനെ കാണാനാകും:
+
+```JSON
+{"item_id": 5, "q": "somequery"}
+```
+
+നിങ്ങൾ ഇതിനകം തന്നെ ഒരു API സൃഷ്ടിച്ചിട്ടുണ്ട്, അത്:
+
+* _paths_ `/`, `/items/{item_id}` എന്നിവയിൽ HTTP അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്നു.
+* രണ്ട് _paths_ ഉം `GET` പ്രവർത്തനങ്ങൾ (HTTP _methods_ എന്നും അറിയപ്പെടുന്നു) എടുക്കുന്നു.
+* _path_ `/items/{item_id}` ന് ഒരു `int` ആയിരിക്കണം _path parameter_ `item_id` ഉണ്ട്.
+* _path_ `/items/{item_id}` ന് ഒരു ഓപ്ഷണൽ `str` _query പാരാമീറ്റർ_ `q` ഉണ്ട്.
+
+### ഇൻറ്ററാക്റ്റിവ് API ഡോക്യൂമെന്റുകൾ
+
+ഇനി http://127.0.0.1:8000/docs എന്നതിലേക്ക് പോകുക.
+
+നിങ്ങൾക്ക് ഓട്ടോമാറ്റിക് ഇന്ററാക്ടീവ് API ഡോക്യുമെന്റേഷൻ കാണാൻ കഴിയും (സ്വാഗർ UI നൽകുന്നത്):
+
+
+
+### ഇതര API ഡോക്യൂമെന്റുകൾ
+
+ഇനി, http://127.0.0.1:8000/redoc എന്നതിലേക്ക് പോകുക.
+
+നിങ്ങൾക്ക് ഇതര ഓട്ടോമാറ്റിക് ഡോക്യുമെന്റേഷൻ കാണാൻ കഴിയും (ReDoc നൽകുന്നത്):
+
+
+
+## ഉദാഹരണ നവീകരണം
+
+ഇനി `PUT` അഭ്യർത്ഥനയിൽ നിന്ന് ഒരു ബോഡി സ്വീകരിക്കുന്നതിന് `main.py` ഫയൽ പരിഷ്കരിക്കുക.
+
+സ്റ്റാൻഡേർഡ് പൈത്തൺ തരങ്ങൾ ഉപയോഗിച്ച് ബോഡി പ്രഖ്യാപിക്കുക, പൈഡാന്റിക്കിന് നന്ദി.
+
+```Python hl_lines="4 9-12 25-27"
+from typing import Union
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ price: float
+ is_offer: Union[bool, None] = None
+
+
+@app.get("/")
+def read_root():
+ return {"Hello": "World"}
+
+
+@app.get("/items/{item_id}")
+def read_item(item_id: int, q: Union[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}
+```
+
+`fastapi dev` സെർവർ യാന്ത്രികമായി റീലോഡ് ചെയ്തിട്ടുണ്ടാവണം.
+
+### ഇൻറ്ററാക്റ്റിവ് API ഡോക്‌സ് അപ്‌ഗ്രേഡ്
+
+ഇനി http://127.0.0.1:8000/docs എന്നതിലേക്ക് പോകുക.
+
+* പുതിയ ബോഡി ഉൾപ്പെടെ, ഇൻറ്ററാക്റ്റിവ് API ഡോക്യുമെന്റേഷൻ സ്വയമേവ അപ്ഡേറ്റ് ചെയ്യപ്പെടും:
+
+
+
+* "ഇത് പരീക്ഷിച്ചുനോക്കൂ" എന്ന ബട്ടണിൽ ക്ലിക്കുചെയ്യുക, ഇത് പാരാമീറ്ററുകൾ പൂരിപ്പിക്കാനും API-യുമായി നേരിട്ട് സംവദിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു:
+
+
+
+* തുടർന്ന് "എക്സിക്യൂട്ട്" ബട്ടണിൽ ക്ലിക്കു ചെയ്യുക, ഉപയോക്തൃ ഇന്റർഫേസ് നിങ്ങളുടെ API-യുമായി ആശയവിനിമയം നടത്തുകയും പാരാമീറ്ററുകൾ അയയ്ക്കുകയും ഫലങ്ങൾ നേടുകയും സ്ക്രീനിൽ കാണിക്കുകയും ചെയ്യും:
+
+
+
+### ഇതര API ഡോക്യൂമെന്റുകൾ നവീകരണം
+
+ഇനി, http://127.0.0.1:8000/redoc എന്നതിലേക്ക് പോകുക.
+
+* ഇതര ഡോക്യുമെന്റേഷൻ പുതിയ ക്വറി പാരാമീറ്ററും ബോഡിയും പ്രതിഫലിപ്പിക്കും:
+
+
+
+### പുനരാവലോകനം
+
+ചുരുക്കത്തിൽ, നിങ്ങൾ പാരാമീറ്ററുകളുടെ തരങ്ങൾ, ബോഡി മുതലായവ **ഒരിക്കൽ** ഫംഗ്ഷൻ പാരാമീറ്ററുകളായി പ്രഖ്യാപിക്കുന്നു.
+
+സ്റ്റാൻഡേർഡ് ആധുനിക പൈത്തൺ തരങ്ങൾ ഉപയോഗിച്ചാണ് നിങ്ങൾ അത് ചെയ്യുന്നത്.
+
+നിങ്ങൾ ഒരു പുതിയ വാക്യഘടന, ഒരു പ്രത്യേക ലൈബ്രറിയുടെ രീതികൾ അല്ലെങ്കിൽ ക്ലാസുകൾ മുതലായവ പഠിക്കേണ്ടതില്ല.
+
+വെറും സ്റ്റാൻഡേർഡ് **പൈത്തൺ**.
+
+ഉദാഹരണത്തിന്, ഒരു `int` ന്:
+
+```Python
+item_id: int
+```
+
+അല്ലെങ്കിൽ കൂടുതൽ സങ്കീർണ്ണമായ ഒരു `Item` മോഡലിന്:
+
+```Python
+item: Item
+```
+
+...ആ ഒരൊറ്റ പ്രസ്താവനയിലൂടെ നിങ്ങൾക്ക് ലഭിക്കുന്നത്:
+
+* എഡിറ്റർ പിന്തുണ, ഇതിൽ ഉൾപെടുന്നവ:
+ * പൂർത്തീകരണം.
+ * ടൈപ്പ് പരിശോധനകൾ.
+* ഡാറ്റയുടെ സാധൂകരണം:
+ * ഡാറ്റ അസാധുവാകുമ്പോൾ യാന്ത്രികവും മായ്‌ക്കുന്നതുമായ പിശകുകൾ.
+ * ആഴത്തിൽ നെസ്റ്റഡ് JSON ഒബ്‌ജക്‌റ്റുകൾക്കുപോലും സാധൂകരണം.
+* ഇൻപുട്ട് ഡാറ്റയുടെ പരിവർത്തനം:നെറ്റ്‌വർക്കിൽ നിന്ന് പൈത്തൺ ഡാറ്റയിലേക്കും തരങ്ങളിലേക്കും വരുന്നു. ഈ കംപോണന്റുകളിൽ നിന്നു വായിക്കുന്നു :ഹെഡ്‍റുകൾ
+ * JSON.
+ * പാഥ് പാരാമീറ്ററുകൾ.
+ * ക്വറി പാരാമീറ്ററുകൾ.
+ * കുക്കീസ്‌ .
+ * ഹെഡ്‍റുകൾ .
+ * ഫോമുകൾ .
+ * ഫയലുകൾ .
+* ഔട്ട്‌പുട്ട് ഡാറ്റയുടെ പരിവർത്തനം: പൈത്തൺ ഡാറ്റയിൽ നിന്നും തരങ്ങളിൽ നിന്നും നെറ്റ്‌വർക്ക് ഡാറ്റയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു (JSON ആയി):
+ * പൈത്തൺ തരങ്ങൾ പരിവർത്തനം ചെയ്യുക (`str`, `int`, `float`, `bool`, `list`, etc).
+ * `datetime` ഒബ്ജെക്ട്സ് .
+ * `UUID` ഒബ്ജെക്ട്സ് .
+ * ഡാറ്റാബേസ് മോഡലുകൾ.
+ * ...കൂടാതെ മറ്റു പലതും.
+* രണ്ട് ഇതര ഉപയോക്തൃ ഇന്റർഫേസുകൾ ഉൾപ്പെടെ ഓട്ടോമാറ്റിക് ഇന്ററാക്ടീവ് API ഡോക്യുമെന്റേഷൻ:
+ * സ്വാഗർ UI.
+ * റീഡോക്.
+
+---
+
+മുമ്പത്തേ കോഡ് ഉദാഹരണത്തിലേക്ക് തിരികെ വരുമ്പോൾ, **ഫാസ്റ്റ് API** ഇനിപ്പറയുന്നവ ചെയ്യും:
+
+* `GET`, `PUT` അഭ്യർത്ഥനകൾക്കുള്ള പാതയിൽ ഒരു `item_id` ഉണ്ടെന്ന് സാധൂകരിക്കുക.
+* `GET`, `PUT` അഭ്യർത്ഥനകൾക്കായി `item_id` `int` തരത്തിലുള്ളതാണെന്ന് സാധൂകരിക്കുക.
+ * അങ്ങനെയല്ലെങ്കിൽ, ക്ലയന്റ് ഉപയോഗപ്രദവും വ്യക്തവുമായ ഒരു പിശക് കാണും.
+* `GET` അഭ്യർത്ഥനകൾക്കായി `q` (`http://127.0.0.1:8000/items/foo?q=somequery` പോലെ) എന്ന പേരിൽ ഒരു ഓപ്ഷണൽ അന്വേഷണ പാരാമീറ്റർ ഉണ്ടോ എന്ന് പരിശോധിക്കുക.
+ * `q` പാരാമീറ്റർ `= None` എന്ന് പ്രഖ്യാപിച്ചിരിക്കുന്നതിനാൽ, അത് ഓപ്ഷണലാണ്.
+ * `None` ഇല്ലെങ്കിൽ അത് ആവശ്യമായി വരും (`PUT` ലെ ബോഡി പോലെ).
+* `/items/{item_id}` ലേക്കുള്ള `PUT` അഭ്യർത്ഥനകൾക്ക്, ബോഡി JSON ആയി വായിക്കുക:
+ * അതിന് ഒരു `str` ആയിരിക്കേണ്ട ഒരു ആവശ്യമായ ആട്രിബ്യൂട്ട് `name` ഉണ്ടോയെന്ന് പരിശോധിക്കുക.
+ * അതിന് `price` എന്ന ഒരു required ആട്രിബ്യൂട്ട് ഉണ്ടോ എന്നും അത് ഒരു `float` ആയിരിക്കണമെന്നും പരിശോധിക്കുക.
+ * ഇതിന് `is_offer` എന്ന ഓപ്ഷണൽ ആട്രിബ്യൂട്ട് ഉണ്ടോയെന്ന് പരിശോധിക്കുക, ഉണ്ടെങ്കിൽ അത് `bool` ആയിരിക്കണം.
+ * ഇതെല്ലാം ഡീപ്ലി നെസ്റ്റഡ് JSON ഒബ്‌ജക്‌റ്റുകൾക്കും പ്രവർത്തിക്കും.
+* JSON-ൽ നിന്നും JSON-ലേയ്ക്കും സ്വയമേവ പരിവർത്തനം ചെയ്യുക.
+* OpenAPI ഉപയോഗിച്ച് എല്ലാം രേഖപ്പെടുത്തുക, അത് ഇനിപ്പറയുന്നവർക്ക് ഉപയോഗിക്കാം:
+ * ഇന്ററാക്ടീവ് ഡോക്യുമെന്റേഷൻ സിസ്റ്റങ്ങൾ.
+ * പല ഭാഷകൾക്കുമായി ഓട്ടോമാറ്റിക് ക്ലയന്റ് കോഡ് ജനറേഷൻ സിസ്റ്റങ്ങൾ.
+* 2 ഇന്ററാക്ടീവ് ഡോക്യുമെന്റേഷൻ വെബ് ഇന്റർഫേസുകൾ നേരിട്ട് നൽകുക.
+
+---
+
+ഞങ്ങൾ ഉപരിതലം മുഴുവൻ വായിച്ചു, പക്ഷേ ഇതെല്ലാം എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഒരു ധാരണ നിങ്ങൾക്ക് ഇതിനകം ലഭിച്ചുകഴിഞ്ഞു.
+
+ഇതുപയോഗിച്ച് ലൈൻ മാറ്റാൻ ശ്രമിക്കുക:
+
+```Python
+ return {"item_name": item.name, "item_id": item_id}
+```
+
+...from:
+
+```Python
+ ... "item_name": item.name ...
+```
+
+...to:
+
+```Python
+ ... "item_price": item.price ...
+```
+
+...നിങ്ങളുടെ എഡിറ്റർ ആട്രിബ്യൂട്ടുകൾ എങ്ങനെ യാന്ത്രികമായി പൂർത്തിയാക്കുമെന്നും അവയുടെ തരങ്ങൾ എങ്ങനെ അറിയുമെന്നും കാണുക:
+
+
+
+കൂടുതൽ സവിശേഷതകൾ ഉൾപ്പെടെയുള്ള കൂടുതൽ പൂർണ്ണമായ ഉദാഹരണത്തിന്, ട്യൂട്ടോറിയൽ - ഉപയോക്തൃ ഗൈഡ് കാണുക.
+
+**സ്‌പോയിലർ അലേർട്ട്**: ട്യൂട്ടോറിയൽ - ഉപയോക്തൃ ഗൈഡിൽ ഇവ ഉൾപ്പെടുന്നു:
+
+* മറ്റ് വ്യത്യസ്ത സ്ഥലങ്ങളിൽ നിന്നുള്ള **പാരാമീറ്ററുകളുടെ** പ്രഖ്യാപനം: **ഹെഡറുകൾ**, **കുക്കികൾ**, **ഫോം ഫീൽഡുകൾ**, **ഫയലുകൾ**.
+* **മൂല്യനിർണ്ണയ നിയന്ത്രണങ്ങൾ** `maximum_length` അല്ലെങ്കിൽ `regex` ആയി എങ്ങനെ സജ്ജമാക്കാം.
+* വളരെ ശക്തവും ഉപയോഗിക്കാൻ എളുപ്പമുള്ളതുമായ ഒരു **ഡിപ്പെൻഡൻസി ഇഞ്ചക്ഷൻ** സിസ്റ്റം.
+* സുരക്ഷയും ഓതെന്റിക്കേഷനും , **JWT ടോക്കണുകൾ** ഉള്ള **OAuth2** നുള്ള പിന്തുണയും **HTTP ബേസിക്** ഓത്തും ഉൾപ്പെടെ.
+* **ഡീപ്ലി നെസ്റ്റഡ് JSON മോഡലുകൾ** പ്രഖ്യാപിക്കുന്നതിനുള്ള കൂടുതൽ വിപുലമായ (എന്നാൽ അത്രതന്നെ എളുപ്പമുള്ള) സാങ്കേതിക വിദ്യകൾ (പൈഡന്റിക്കിന് നന്ദി).
+* **ഗ്രാഫ് QL** സ്ട്രോബെറി, മറ്റ് ലൈബ്രറികൾ എന്നിവയുമായുള്ള സംയോജനം.
+* നിരവധി അധിക സവിശേഷതകൾ (സ്റ്റാർലെറ്റിന് നന്ദി) ഇവയാണ്:
+ * **വെബ്‌സോക്കറ്റുകൾ**
+ * HTTPX, `pytest` എന്നിവ അടിസ്ഥാനമാക്കിയുള്ള വളരെ എളുപ്പമുള്ള പരിശോധനകൾ
+ * **CORS**
+ **കുക്കി സെഷനുകൾ**
+ * ...പിന്നെ മറ്റുപലതും.
+
+## പ്രകടനം
+
+സ്വതന്ത്ര TechEmpower ബെഞ്ച്മാർക്കുകൾ, യൂവികോൺ -ന് കീഴിൽ പ്രവർത്തിക്കുന്ന **ഫാസ്റ്റ്API** ആപ്ലിക്കേഷനുകൾ ലഭ്യമായ ഏറ്റവും വേഗതയേറിയ പൈത്തൺ ഫ്രെയിംവർക്കുകളിൽ ഒന്നായി കാണിക്കുന്നു, ഇത് സ്റ്റാർലെറ്റ് , യൂവികോൺ എന്നിവയ്ക്ക് താഴെയാണ് (ഫാസ്റ്റ്API ആന്തരികമായി ഉപയോഗിക്കുന്നു). (*)
+
+ഇതിനെക്കുറിച്ച് കൂടുതലറിയാൻ, ബെഞ്ച്മാർക്സ് എന്ന വിഭാഗം കാണുക.
+
+## ആശ്രിതത്വങ്ങൾ
+
+ഫാസ്റ്റ്API പൈഡാന്റിക്, സ്റ്റാർലെറ്റ് എന്നിവയെ ആശ്രയിച്ചിരിക്കുന്നു.
+
+### `സ്റ്റാൻഡേർഡ്` ആശ്രിതത്വങ്ങൾ
+
+`pip install "fastapi[standard]"` ഉപയോഗിച്ച് ഫാസ്റ്റ് API ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ അത് ഓപ്ഷണൽ ഡിപൻഡൻസികളുടെ `standard` ഗ്രൂപ്പുമായി വരുന്നു:
+
+പൈഡാന്റിക് ഉപയോഗിക്കുന്നത്:
+
+* ഇ-മെയിൽ-വാലിഡേറ്റർ - ഇ-മെയിൽ വാലിഡേഷനായി.
+
+സ്റ്റാർലെറ്റ് ഉപയോഗിച്ചത്:
+
+* httpx - `TestClient` ഉപയോഗിക്കണമെങ്കിൽ ആവശ്യമാണ്.
+* jinja2 - ഡിഫോൾട്ട് ടെംപ്ലേറ്റ് കോൺഫിഗറേഷൻ ഉപയോഗിക്കണമെങ്കിൽ ആവശ്യമാണ്.
+* python-multipart - `request.form()` ഉപയോഗിച്ച് "പാഴ്‌സിംഗ്" എന്ന ഫോമിനെ പിന്തുണയ്ക്കണമെങ്കിൽ ആവശ്യമാണ്.
+
+ഫാസ്റ്റ് API / സ്റ്റാർലെറ്റ് ഉപയോഗിക്കുന്നത്:
+
+* uvicorn - നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ലോഡ് ചെയ്ത് സെർവ് ചെയ്യുന്ന സെർവറിനുള്ളത്. ഇതിൽ `uvicorn[standard]` ഉൾപ്പെടുന്നു, ഉയർന്ന പ്രകടനമുള്ള സെർവിംഗിന് ആവശ്യമായ ചില ആശ്രിതത്വങ്ങൾ (ഉദാ. `uvloop`) ഇതിൽ ഉൾപ്പെടുന്നു.
+* `fastapi-cli` - `fastapi` കമാൻഡ് നൽകാൻ.
+
+### `സ്റ്റാൻഡേർഡ്` ആശ്രിതത്വങ്ങൾ ഇല്ലാതെ
+
+`സ്റ്റാൻഡേർഡ്` ഓപ്ഷണൽ ആശ്രിതത്വങ്ങൾ ഉൾപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ, `pip install "fastapi[standard]"` എന്നതിന് പകരം `pip install fastapi` ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്യാം.
+
+### അധിക ഓപ്ഷണൽ ആശ്രിതത്വങ്ങൾ
+
+നിങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ചില അധിക ആശ്രിതത്വങ്ങൾ.
+
+അധിക ഓപ്ഷണൽ പൈഡാന്റിക് ആശ്രിതത്വങ്ങൾ:
+
+* pydantic-settings - ക്രമീകരണ മാനേജ്മെന്റിനായി.
+* pydantic-extra-types - പൈഡന്റിക്കിനൊപ്പം ഉപയോഗിക്കേണ്ട എക്സ്ട്രാ തരങ്ങൾക്കായി.
+
+അധിക ഓപ്ഷണൽ ഫാസ്റ്റ് API ആശ്രിതത്വങ്ങൾ:
+
+* orjson - `ORJSONResponse` ഉപയോഗിക്കണമെങ്കിൽ ആവശ്യമാണ്.
+* ujson - `UJSONResponse` ഉപയോഗിക്കണമെങ്കിൽ ആവശ്യമാണ്.
+
+## ലൈസൻസ്
+
+ഈ പ്രോജക്റ്റ് MIT ലൈസൻസിന്റെ നിബന്ധനകൾക്ക് കീഴിലാണ് ലൈസൻസ് ചെയ്തിരിക്കുന്നത്.
diff --git a/docs/ml/mkdocs.yml b/docs/ml/mkdocs.yml
new file mode 100644
index 000000000..de18856f4
--- /dev/null
+++ b/docs/ml/mkdocs.yml
@@ -0,0 +1 @@
+INHERIT: ../en/mkdocs.yml