diff --git a/docs/tr/docs/tutorial/first-steps.md b/docs/tr/docs/tutorial/first-steps.md
new file mode 100644
index 000000000..e66f73034
--- /dev/null
+++ b/docs/tr/docs/tutorial/first-steps.md
@@ -0,0 +1,333 @@
+# İlk Adımlar
+
+En sade FastAPI dosyası şu şekilde görünür:
+
+```Python
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Yukarıdaki içeriği bir `main.py` dosyasına kopyalayalım.
+
+Uygulamayı çalıştıralım:
+
+
+
+```console
+$ uvicorn main:app --reload
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+INFO: Started reloader process [28720]
+INFO: Started server process [28722]
+INFO: Waiting for application startup.
+INFO: Application startup complete.
+```
+
+
+
+!!! note "Not"
+ `uvicorn main:app` komutunu şu şekilde açıklayabiliriz:
+
+ * `main`: dosya olan `main.py` (yani Python "modülü").
+ * `app`: ise `main.py` dosyasının içerisinde `app = FastAPI()` satırında oluşturduğumuz `FastAPI` nesnesi.
+ * `--reload`: kod değişikliklerinin ardından sunucuyu otomatik olarak yeniden başlatır. Bu parameteyi sadece geliştirme aşamasında kullanmalıyız.
+
+Çıktı olarak şöyle bir satır ile karşılaşacaksınız:
+
+```hl_lines="4"
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+Bu satır, yerel makinenizde uygulamanızın çalıştığı bağlantıyı gösterir.
+
+### Kontrol Edelim
+
+Tarayıcınızı açıp http://127.0.0.1:8000 bağlantısına gidin.
+
+Şu şekilde bir JSON yanıtı ile karşılaşacağız:
+
+```JSON
+{"message": "Hello World"}
+```
+
+### Etkileşimli API Dokümantasyonu
+
+Şimdi http://127.0.0.1:8000/docs bağlantısını açalım.
+
+Swagger UI tarafından sağlanan otomatik etkileşimli bir API dokümantasyonu göreceğiz:
+
+
+
+### Alternatif API Dokümantasyonu
+
+Şimdi http://127.0.0.1:8000/redoc bağlantısını açalım.
+
+ReDoc tarafından sağlanan otomatik dokümantasyonu göreceğiz:
+
+
+
+### OpenAPI
+
+**FastAPI**, **OpenAPI** standardını kullanarak tüm API'ınızın tamamını tanımlayan bir "şema" oluşturur.
+
+#### "Şema"
+
+"Şema", bir şeyin tanımı veya açıklamasıdır. Geliştirilen koddan ziyade soyut bir açıklamadır.
+
+#### API "Şeması"
+
+Bu durumda, OpenAPI, API şemasını nasıl tanımlayacağınızı belirten bir şartnamedir.
+
+Bu şema tanımı, API yollarınızla birlikte yollarınızın aldığı olası parametreler gibi tanımlamaları içerir.
+
+#### Veri "Şeması"
+
+"Şema" terimi, JSON içeriği gibi bazı verilerin şeklini de ifade edebilir.
+
+Bu durumda, JSON özellikleri ve sahip oldukları veri türleri gibi anlamlarına gelir.
+
+#### OpenAPI ve JSON Şema
+
+OpenAPI, API'niz için bir API şeması tanımlar. Ve bu şema, JSON veri şemaları standardı olan **JSON Şema** kullanılarak API'niz tarafından gönderilen ve alınan verilerin tanımlarını (veya "şemalarını") içerir.
+
+#### `openapi.json` Dosyasına Göz At
+
+Ham OpenAPI şemasının nasıl göründüğünü merak ediyorsanız, FastAPI otomatik olarak tüm API'ınızın tanımlamalarını içeren bir JSON (şeması) oluşturur.
+
+Bu şemayı direkt olarak http://127.0.0.1:8000/openapi.json bağlantısından görüntüleyebilirsiniz.
+
+Aşağıdaki gibi başlayan bir JSON ile karşılaşacaksınız:
+
+```JSON
+{
+ "openapi": "3.1.0",
+ "info": {
+ "title": "FastAPI",
+ "version": "0.1.0"
+ },
+ "paths": {
+ "/items/": {
+ "get": {
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+
+
+
+...
+```
+
+#### OpenAPI Ne İşe Yarar?
+
+OpenAPI şeması, FastAPI projesinde bulunan iki etkileşimli dokümantasyon sistemine güç veren şeydir.
+
+OpenAPI'ya dayalı düzinelerce alternatif etkileşimli dokümantasyon aracı mevcuttur. **FastAPI** ile oluşturulmuş uygulamanıza bu alternatiflerden herhangi birini kolayca ekleyebilirsiniz.
+
+Ayrıca, API'ınızla iletişim kuracak önyüz, mobil veya IoT uygulamaları gibi istemciler için otomatik olarak kod oluşturabilirsiniz.
+
+## Adım Adım Özetleyelim
+
+### Adım 1: `FastAPI`yı Projemize Dahil Edelim
+
+```Python hl_lines="1"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+`FastAPI`, API'niz için tüm işlevselliği sağlayan bir Python sınıfıdır.
+
+!!! note "Teknik Detaylar"
+ `FastAPI` doğrudan `Starlette`'i miras alan bir sınıftır.
+
+ Starlette'in tüm işlevselliğini `FastAPI` ile de kullanabilirsiniz.
+
+### Adım 2: Bir `FastAPI` "Örneği" Oluşturalım
+
+```Python hl_lines="3"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Burada `app` değişkeni `FastAPI` sınıfının bir örneği olacaktır.
+
+Bu, tüm API'yı oluşturmak için ana etkileşim noktası olacaktır.
+
+Bu `app` değişkeni, `uvicorn` komutunda atıfta bulunulan değişkenin ta kendisidir.
+
+
+
+```console
+$ uvicorn main:app --reload
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+Uygulamanızı aşağıdaki gibi oluşturursanız:
+
+```Python hl_lines="3"
+{!../../../docs_src/first_steps/tutorial002.py!}
+```
+
+Ve bunu `main.py` dosyasına yerleştirirseniz eğer `uvicorn` komutunu şu şekilde çalıştırabilirsiniz:
+
+
+
+```console
+$ uvicorn main:my_awesome_api --reload
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+### Adım 3: Bir *Yol Operasyonu* Oluşturalım
+
+#### Yol
+
+Burada "yol" bağlantıda bulunan ilk `/` ile başlayan ve sonrasında gelen kısmı ifade eder.
+
+Yani, şu şekilde bir bağlantıda:
+
+```
+https://example.com/items/foo
+```
+
+... yol şöyle olur:
+
+```
+/items/foo
+```
+
+!!! info "Bilgi"
+ "Yol" genellikle "endpoint" veya "route" olarak adlandırılır.
+
+Bir API oluştururken, "yol", "kaynaklar" ile "endişeleri" ayırmanın ana yöntemidir.
+
+#### Operasyonlar
+
+Burada "operasyon" HTTP "metodlarından" birini ifade eder.
+
+Bunlardan biri:
+
+* `POST`
+* `GET`
+* `PUT`
+* `DELETE`
+
+...veya daha az kullanılan diğerleri:
+
+* `OPTIONS`
+* `HEAD`
+* `PATCH`
+* `TRACE`
+
+HTTP protokolünde, bu "metodlardan" birini (veya daha fazlasını) kullanarak her bir yol ile iletişim kurabilirsiniz.
+
+---
+
+API oluştururkan, belirli bir amaca hizmet eden belirli HTTP metodlarını kullanırsınız.
+
+Normalde kullanılan:
+
+* `POST`: veri oluşturmak.
+* `GET`: veri okumak.
+* `PUT`: veriyi güncellemek.
+* `DELETE`: veriyi silmek.
+
+Bu nedenle, OpenAPI'da HTTP metodlarından her birine "operasyon" denir.
+
+Biz de onları "**operasyonlar**" olarak adlandıracağız.
+
+#### Bir *Yol Operasyonu Dekoratörü* Tanımlayalım
+
+```Python hl_lines="6"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+`@app.get("/")` dekoratörü, **FastAPI**'a hemen altındaki fonksiyonun aşağıdaki durumlardan sorumlu olduğunu söyler:
+
+* get operasyonu ile
+* `/` yoluna gelen istekler
+
+!!! info "`@decorator` Bilgisi"
+ Python'da `@something` sözdizimi "dekoratör" olarak adlandırılır.
+
+ Dekoratörler, dekoratif bir şapka gibi (sanırım terim buradan geliyor) fonksiyonların üzerlerine yerleştirilirler.
+
+ Bir "dekoratör" hemen altında bulunan fonksiyonu alır ve o fonksiyon ile bazı işlemler gerçekleştirir.
+
+ Bizim durumumuzda, kullandığımız dekoratör, **FastAPI**'a altındaki fonksiyonun `/` yoluna gelen `get` metodlu isteklerden sorumlu olduğunu söyler.
+
+ Bu bir **yol operasyonu dekoratörüdür**.
+
+Ayrıca diğer operasyonları da kullanabilirsiniz:
+
+* `@app.post()`
+* `@app.put()`
+* `@app.delete()`
+
+Daha az kullanılanları da kullanabilirsiniz:
+
+* `@app.options()`
+* `@app.head()`
+* `@app.patch()`
+* `@app.trace()`
+
+!!! tip "İpucu"
+ Her işlemi (HTTP metod) istediğiniz gibi kullanmakta özgürsünüz.
+
+ **FastAPI** herhangi bir özel amacı veya anlamı olması konusunda ısrarcı olmaz.
+
+ Buradaki bilgiler bir gereklilik değil, bir kılavuz olarak sunulmaktadır.
+
+ Mesela GraphQL kullanırkan genelde tüm işlemleri yalnızca `POST` operasyonunu kullanarak gerçekleştirirsiniz.
+
+### Adım 4: **Yol Operasyonu Fonksiyonunu** Tanımlayın
+
+Aşağıdaki, bizim **yol operasyonu fonksiyonumuzdur**:
+
+* **yol**: `/`
+* **operasyon**: `get`
+* **fonksiyon**: "dekoratör"ün (`@app.get("/")`'in) altındaki fonksiyondur.
+
+```Python hl_lines="7"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Bu bir Python fonksiyonudur.
+
+Bu fonksiyon bir `GET` işlemi kullanılarak "`/`" bağlantısına bir istek geldiğinde **FastAPI** tarafından çağrılır.
+
+Bu durumda bu fonksiyon bir `async` fonksiyondur.
+
+---
+
+Bu fonksiyonu `async def` yerine normal bir fonksiyon olarak da tanımlayabilirsiniz.
+
+```Python hl_lines="7"
+{!../../../docs_src/first_steps/tutorial003.py!}
+```
+
+!!! note "Not"
+ Eğer farkı bilmiyorsanız, [Async: *"Aceleniz mi var?"*](../async.md#in-a-hurry){.internal-link target=_blank} sayfasını kontrol edebilirsiniz.
+
+### Adım 5: İçeriği Geri Döndürün
+
+```Python hl_lines="8"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Bir `dict`, `list` veya `str`, `int` gibi tekil değerler döndürebilirsiniz.
+
+Ayrıca, Pydantic modelleri de döndürebilirsiniz (bu konu ileriki aşamalarda irdelenecektir).
+
+Otomatik olarak JSON'a dönüştürülecek (ORM'ler vb. dahil) başka birçok nesne ve model vardır. En beğendiklerinizi kullanmayı deneyin, yüksek ihtimalle destekleniyordur.
+
+## Özet
+
+* `FastAPI`'yı projemize dahil ettik.
+* Bir `app` örneği oluşturduk.
+* Bir **yol operasyonu dekoratörü** (`@app.get("/")` gibi) yazdık.
+* Bir **yol operasyonu fonksiyonu** (`def root(): ...` gibi) yazdık.
+* Geliştirme sunucumuzu (`uvicorn main:app --reload` gibi) çalıştırdık.
diff --git a/docs/tr/docs/tutorial/first_steps.md b/docs/tr/docs/tutorial/first_steps.md
deleted file mode 100644
index b39802f5d..000000000
--- a/docs/tr/docs/tutorial/first_steps.md
+++ /dev/null
@@ -1,336 +0,0 @@
-# İlk Adımlar
-
-En basit FastAPI dosyası şu şekildedir:
-
-```Python
-{!../../../docs_src/first_steps/tutorial001.py!}
-```
-
-Bunu bir `main.py` dosyasına kopyalayın.
-
-Projeyi çalıştırın:
-
-
-
-```console
-$ uvicorn main:app --reload
-
-INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-INFO: Started reloader process [28720]
-INFO: Started server process [28722]
-INFO: Waiting for application startup.
-INFO: Application startup complete.
-```
-
-
-
-!!! note
- `uvicorn main:app` komutu şunu ifade eder:
-
- * `main`: `main.py` dosyası (the Python "module").
- * `app`: `main.py` dosyası içerisinde `app = FastAPI()` satırıyla oluşturulan nesne.
- * `--reload`: Kod değişikliği sonrasında sunucunun yeniden başlatılmasını sağlar. Yalnızca geliştirme için kullanın.
-
-Çıktıda şu şekilde bir satır vardır:
-
-```hl_lines="4"
-INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-Bu satır, yerel makinenizde uygulamanızın sunulduğu URL'yi gösterir.
-
-### Kontrol Et
-
-Tarayıcınızda http://127.0.0.1:8000 adresini açın.
-
-Bir JSON yanıtı göreceksiniz:
-
-```JSON
-{"message": "Hello World"}
-```
-
-### İnteraktif API dokümantasyonu
-
-http://127.0.0.1:8000/docs adresine gidin.
-
-Otomatik oluşturulmuş( Swagger UI tarafından sağlanan) interaktif bir API dokümanı göreceksiniz:
-
-
-
-### Alternatif API dokümantasyonu
-
-Şimdi, http://127.0.0.1:8000/redoc adresine gidin.
-
-Otomatik oluşturulmuş(ReDoc tarafından sağlanan) bir API dokümanı göreceksiniz:
-
-
-
-### OpenAPI
-
-**FastAPI**, **OpenAPI** standardını kullanarak tüm API'lerinizi açıklayan bir "şema" oluşturur.
-
-#### "Şema"
-
-Bir "şema", bir şeyin tanımı veya açıklamasıdır. Soyut bir açıklamadır, uygulayan kod değildir.
-
-#### API "şemaları"
-
-Bu durumda, OpenAPI, API şemasını nasıl tanımlayacağınızı belirten şartnamelerdir.
-
-Bu şema tanımı, API yollarınızı, aldıkları olası parametreleri vb. içerir.
-
-#### Data "şema"
-
-"Şema" terimi, JSON içeriği gibi bazı verilerin şeklini de ifade edebilir.
-
-Bu durumda, JSON öznitelikleri ve sahip oldukları veri türleri vb. anlamına gelir.
-
-#### OpenAPI and JSON Şema
-
-OpenAPI, API'niz için bir API şeması tanımlar. Ve bu şema, JSON veri şemaları standardı olan **JSON Şema** kullanılarak API'niz tarafından gönderilen ve alınan verilerin tanımlarını (veya "şemalarını") içerir.
-
-#### `openapi.json` kontrol et
-
-OpenAPI şemasının nasıl göründüğünü merak ediyorsanız, FastAPI otomatik olarak tüm API'nizin açıklamalarını içeren bir JSON (şema) oluşturur.
-
-Doğrudan şu adreste görebilirsiniz: http://127.0.0.1:8000/openapi.json.
-
-Aşağıdaki gibi bir şeyle başlayan bir JSON gösterecektir:
-
-```JSON
-{
- "openapi": "3.0.2",
- "info": {
- "title": "FastAPI",
- "version": "0.1.0"
- },
- "paths": {
- "/items/": {
- "get": {
- "responses": {
- "200": {
- "description": "Successful Response",
- "content": {
- "application/json": {
-
-
-
-...
-```
-
-#### OpenAPI ne içindir?
-
-OpenAPI şeması, dahili olarak bulunan iki etkileşimli dokümantasyon sistemine güç veren şeydir.
-
-Ve tamamen OpenAPI'ye dayalı düzinelerce alternatif vardır. **FastAPI** ile oluşturulmuş uygulamanıza bu alternatiflerden herhangi birini kolayca ekleyebilirsiniz.
-
-API'nizle iletişim kuran istemciler için otomatik olarak kod oluşturmak için de kullanabilirsiniz. Örneğin, frontend, mobil veya IoT uygulamaları.
-
-## Adım adım özet
-
-### Adım 1: `FastAPI`yi içe aktarın
-
-```Python hl_lines="1"
-{!../../../docs_src/first_steps/tutorial001.py!}
-```
-
-`FastAPI`, API'niz için tüm fonksiyonları sağlayan bir Python sınıfıdır.
-
-!!! note "Teknik Detaylar"
- `FastAPI` doğrudan `Starlette` kalıtım alan bir sınıftır.
-
- Tüm Starlette fonksiyonlarını `FastAPI` ile de kullanabilirsiniz.
-
-### Adım 2: Bir `FastAPI` örneği oluşturun
-
-```Python hl_lines="3"
-{!../../../docs_src/first_steps/tutorial001.py!}
-```
-
-Burada `app` değişkeni `FastAPI` sınıfının bir örneği olacaktır.
-
-Bu tüm API'yi oluşturmak için ana etkileşim noktası olacaktır.
-
-`uvicorn` komutunda atıfta bulunulan `app` ile aynıdır.
-
-
-
-```console
-$ uvicorn main:app --reload
-
-INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-
-
-Uygulamanızı aşağıdaki gibi oluşturursanız:
-
-```Python hl_lines="3"
-{!../../../docs_src/first_steps/tutorial002.py!}
-```
-
-Ve bunu `main.py` dosyasına koyduktan sonra `uvicorn` komutunu şu şekilde çağırabilirsiniz:
-
-
-
-```console
-$ uvicorn main:my_awesome_api --reload
-
-INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-
-
-### Adım 3: *Path işlemleri* oluşturmak
-
-#### Path
-
-Burada "Path" URL'de ilk "\" ile başlayan son bölümü ifade eder.
-
-Yani, şu şekilde bir URL'de:
-
-```
-https://example.com/items/foo
-```
-
-... path şöyle olabilir:
-
-```
-/items/foo
-```
-
-!!! info
- Genellikle bir "path", "endpoint" veya "route" olarak adlandırılabilir.
-
-Bir API oluştururken, "path", "resource" ile "concern" ayırmanın ana yoludur.
-
-#### İşlemler
-
-Burada "işlem" HTTP methodlarından birini ifade eder.
-
-Onlardan biri:
-
-* `POST`
-* `GET`
-* `PUT`
-* `DELETE`
-
-... ve daha egzotik olanları:
-
-* `OPTIONS`
-* `HEAD`
-* `PATCH`
-* `TRACE`
-
-HTTP protokolünde, bu "methodlardan" birini (veya daha fazlasını) kullanarak her path ile iletişim kurabilirsiniz.
-
----
-
-API'lerinizi oluştururkan, belirli bir işlemi gerçekleştirirken belirli HTTP methodlarını kullanırsınız.
-
-Normalde kullanılan:
-
-* `POST`: veri oluşturmak.
-* `GET`: veri okumak.
-* `PUT`: veriyi güncellemek.
-* `DELETE`: veriyi silmek.
-
-Bu nedenle, OpenAPI'de HTTP methodlarından her birine "işlem" denir.
-
-Bizde onlara "**işlemler**" diyeceğiz.
-
-#### Bir *Path işlem decoratorleri* tanımlanmak
-
-```Python hl_lines="6"
-{!../../../docs_src/first_steps/tutorial001.py!}
-```
-
-`@app.get("/")` **FastAPI'ye** aşağıdaki fonksiyonun adresine giden istekleri işlemekten sorumlu olduğunu söyler:
-
-* path `/`
-* get işlemi kullanılarak
-
-
-!!! info "`@decorator` Bilgisi"
- Python `@something` şeklinde ifadeleri "decorator" olarak adlandırır.
-
- Decoratoru bir fonksiyonun üzerine koyarsınız. Dekoratif bir şapka gibi (Sanırım terim buradan gelmektedir).
-
- Bir "decorator" fonksiyonu alır ve bazı işlemler gerçekleştir.
-
- Bizim durumumzda decarator **FastAPI'ye** fonksiyonun bir `get` işlemi ile `/` pathine geldiğini söyler.
-
- Bu **path işlem decoratordür**
-
-Ayrıca diğer işlemleri de kullanabilirsiniz:
-
-* `@app.post()`
-* `@app.put()`
-* `@app.delete()`
-
-Ve daha egzotik olanları:
-
-* `@app.options()`
-* `@app.head()`
-* `@app.patch()`
-* `@app.trace()`
-
-!!! tip
- Her işlemi (HTTP method) istediğiniz gibi kullanmakta özgürsünüz.
-
- **FastAPI** herhangi bir özel anlamı zorlamaz.
-
- Buradaki bilgiler bir gereklilik değil, bir kılavuz olarak sunulmaktadır.
-
- Örneğin, GraphQL kullanırkan normalde tüm işlemleri yalnızca `POST` işlemini kullanarak gerçekleştirirsiniz.
-
-### Adım 4: **path işlem fonksiyonunu** tanımlayın
-
-Aşağıdakiler bizim **path işlem fonksiyonlarımızdır**:
-
-* **path**: `/`
-* **işlem**: `get`
-* **function**: "decorator"ün altındaki fonksiyondur (`@app.get("/")` altında).
-
-```Python hl_lines="7"
-{!../../../docs_src/first_steps/tutorial001.py!}
-```
-
-Bu bir Python fonksiyonudur.
-
-Bir `GET` işlemi kullanarak "`/`" URL'sine bir istek geldiğinde **FastAPI** tarafından çağrılır.
-
-Bu durumda bir `async` fonksiyonudur.
-
----
-
-Bunu `async def` yerine normal bir fonksiyon olarakta tanımlayabilirsiniz.
-
-```Python hl_lines="7"
-{!../../../docs_src/first_steps/tutorial003.py!}
-```
-
-!!! note
-
- Eğer farkı bilmiyorsanız, [Async: *"Acelesi var?"*](../async.md#in-a-hurry){.internal-link target=_blank} kontrol edebilirsiniz.
-
-### Adım 5: İçeriği geri döndürün
-
-
-```Python hl_lines="8"
-{!../../../docs_src/first_steps/tutorial001.py!}
-```
-
-Bir `dict`, `list` döndürebilir veya `str`, `int` gibi tekil değerler döndürebilirsiniz.
-
-Ayrıca, Pydantic modellerini de döndürebilirsiniz. (Bununla ilgili daha sonra ayrıntılı bilgi göreceksiniz.)
-
-Otomatik olarak JSON'a dönüştürülecek(ORM'ler vb. dahil) başka birçok nesne ve model vardır. En beğendiklerinizi kullanmayı deneyin, yüksek ihtimalle destekleniyordur.
-
-## Özet
-
-* `FastAPI`'yi içe aktarın.
-* Bir `app` örneği oluşturun.
-* **path işlem decorator** yazın. (`@app.get("/")` gibi)
-* **path işlem fonksiyonu** yazın. (`def root(): ...` gibi)
-* Development sunucunuzu çalıştırın. (`uvicorn main:app --reload` gibi)