Dan 8/28: Uvod u FastAPI - Učitelj Vasa postaje web servis

Vreme potrebno: 90 – 180 minuta

Gde je Učitelj Vasa danas?

Učitelj Vasa je napredovao od jednostavnog Python skripta do robusnog AI asistenta sa multi-provider podrškom, automatskom optimizacijom, resilience sistemom koji elegantno rukuje greškama, i personalizacijom koja pamti svakog korisnika. Ali trenutno radi samo kao konzolna aplikacija – možeš ga koristiti samo kroz terminal na svom računaru. Danas menjamo to i otvaramo Vasu celom svetu!

Cilj današnje lekcije

Danas ćeš naučiti osnove FastAPI framework-a i transformisati Učitelja Vasu iz konzolne aplikacije u pravi web servis. Nakon ove lekcije, Vasa će moći da odgovara na osnovne HTTP zahteve, što znači da će biti dostupan preko web browser-a!

Predznanja

• Funkcionalan Učitelj Vasa sa personalizacijom (Dan 1-7)
• Razumevanje funkcija i modula u Python-u
• Osnovno razumevanje kako funkcioniše web (šta su URL, zahtev, odgovor)
• JSON format (korišćen u profilima)

Glavni sadržaj

Zašto FastAPI i šta je to uopšte?

Pre nego što krenemo sa kodom, razumimo zašto transformišemo Vasu u web servis.

📚 NIVO 1 – Osnovno objašnjenje

Trenutno, Učitelj Vasa je kao knjiga koju možeš čitati samo u svojoj sobi. Web servis je kao da tu knjigu staviš u biblioteku gde je svi mogu čitati!

FastAPI je Python framework (set alata) koji omogućava da napraviš web servis vrlo brzo i lako. Ime “FastAPI” dolazi od:

• Fast – brz je za pisanje i izvršavanje
• API – Application Programming Interface (način kako programi pričaju međusobno)

Kada Vasa postane web servis:

• Možeš mu pristupiti sa bilo kog uređaja
• Može da odgovara više korisnika istovremeno
• Možeš napraviti web sajt ili mobilnu aplikaciju koja ga koristi

🚀 NIVO 2 – Dublje razumevanje

FastAPI je moderan web framework koji koristi najnovije Python funkcionalnosti (type hints, async/await). Ključne prednosti:

1. Automatska dokumentacija – generiše interaktivnu dokumentaciju
2. Type validation – automatski proverava tipove podataka
3. Async podrška – može da obrađuje hiljade zahteva istovremeno
4. Brzina – jedan od najbržih Python framework-a
5. Developer-friendly – odlične error poruke i intuitivna sintaksa

FastAPI je baziran na Starlette (za web deo) i Pydantic (za validaciju podataka).

💡 PRO TIP: Zamislite FastAPI kao LEGO kockice za backend. Umesto da ručno “lepite” HTML ili Flask rute, svaka kockica (dekorejtor, tip hint, automatska dokumentacija) već ima tačne dimenzije – samo ih spojite i struktura stoji čvrsto bez dodatnog lepka.

🔍 UVID: Ključna inovacija FastAPI-ja je sistemsko korišćenje Python type hints. Dok su one prvobitno bile zamišljene samo kao pomoć programeru, FastAPI im daje “supermoć”: koristi ih za automatsku validaciju podataka, serijalizaciju (pretvaranje objekata u JSON) i generisanje API šeme (OpenAPI). Ovo je primer moćnog principa dizajna softvera: “Convention over Configuration”. Umesto da pišeš poseban kod za validaciju i dokumentaciju (konfiguracija), ti samo pratiš konvenciju pisanja modernog Pythona, a framework radi težak posao za tebe.

🎈 ZABAVNA ČINJENICA: FastAPI je jedan od najbrže rastućih Python projekata na GitHub-u. Za samo 2 godine prestigao je Django po broju GitHub zvezda, framework koji postoji od 2005!

Instalacija i priprema okruženja

Počnimo sa instalacijom potrebnih biblioteka.

📚 NIVO 1 – Osnovno objašnjenje

FastAPI zahteva dve stvari:

1. fastapi – sam framework
2. uvicorn – server koji pokreće našu aplikaciju

Uvicorn je kao konobar u restoranu – prima narudžbine (HTTP zahteve) i donosi jelo (odgovore).

🚀 NIVO 2 – Dublje razumevanje

Uvicorn je ASGI (Asynchronous Server Gateway Interface) server. Za razliku od tradicionalnih Python web servera koji mogu da obrađuju samo jedan zahtev u isto vreme po procesu, ASGI serveri mogu da obrađuju hiljade zahteva istovremeno koristeći async/await.

Otvori terminal u root folderu projekta i instaliraj:

pip install fastapi uvicorn[standard]

Opcija [standard] instalira dodatne dependencies za bolju performance (uvloop, httptools).

💡 PRO TIP: Ako ti je pip install fastapi uvicorn[standard] spor, probaj sa pip install fastapi && pip install "uvicorn[standard]" – dva odvojena koraka često prođu brže na sporijim vezama, jer fastapi nema C-ekstenzije, dok [standard] deo za uvicorn povlači uvloop koji zahteva kompajliranje.

Ažuriraj requirements.txt:

python-dotenv
openai
google-generativeai
fastapi
uvicorn[standard]

🎈 ZABAVNA ČINJENICA: uvicorn je skraćenica od Unicorn + UVloop. Programeri su hteli da aludiraju na brzinu (unicorns are fast, right?), a UVloop je poznata biblioteka za munjeviti event-loop.

Kreiranje prvog FastAPI endpoint-a

Sada ćemo kreirati našu prvu web rutu.

📚 NIVO 1 – Osnovno objašnjenje

Endpoint je kao vrata kroz koja neko može da ti postavi pitanje. Imaćemo različite “vrata” za različite stvari:

• Jedna vrata za pozdrav
• Druga vrata za AI pitanja
• Treća vrata za informacije o Vasi

Svaka vrata imaju svoju adresu (URL) i način kako se koriste (GET, POST…).

🚀 NIVO 2 – Dublje razumevanje

HTTP metode definišu akciju:

• GET – uzmi podatke (čitanje)
• POST – pošalji podatke (kreiranje)
• PUT – ažuriraj podatke
• DELETE – obriši podatke

Za našu aplikaciju, koristićemo GET za jednostavne informacije i POST za slanje pitanja AI-ju.

📊 DIJAGRAM: Osnovna struktura FastAPI aplikacije

     Browser/Klijent                    FastAPI Server
          │                                   │
          │ 1. HTTP Request (GET /)           │
          │──────────────────────────────────>│
          │                                   │
          │                                   ├─> @app.get("/")
          │                                   ├─> def root():
          │                                   ├─>     return {"ime": "Vasa"}
          │                                   │
          │ 2. HTTP Response (JSON)           │
          │<──────────────────────────────────│
          │    {"ime": "Vasa"}                │
          │                                   │

Kreiraj novu strukturu foldera:

mkdir src/web_api
touch src/web_api/__init__.py
touch src/web_api/app.py

Kreiraj src/web_api/app.py:

"""
FastAPI aplikacija za Učitelja Vasu
Transformiše konzolnu aplikaciju u web servis
"""

from fastapi import FastAPI, HTTPException
from typing import Dict
import sys
import os

# Dodaj src folder u Python path
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# Import Vasa modula
from vasa_core import pozdrav, predstavi_se, VASA_LICNOST
from ai_services.ai_factory import AIServiceFactory
from utils.config import Config

# Kreiraj FastAPI instancu
app = FastAPI(
    title="Učitelj Vasa API",
    description="AI asistent za učenje programiranja",
    version="1.0.0"
)

# Globalna varijabla za AI servis
ai_service = None


@app.on_event("startup")
async def startup_event():
    """Inicijalizuje AI servis pri pokretanju."""
    global ai_service
    
    print("🚀 Pokrećem Učitelja Vasu Web API...")
    
    try:
        # Jednostavno kreiraj AI servis kao što smo radili u konzoli
        ai_service = AIServiceFactory.create_resilient_service()
        print("✅ AI servis spreman!")
    except Exception as e:
        print(f"⚠️ Problem sa AI servisom: {e}")
        print("📌 API će raditi u ograničenom režimu")


@app.get("/")
async def root():
    """Osnovne informacije o API-ju."""
    return {
        "ime": "Učitelj Vasa API",
        "verzija": "1.0.0",
        "status": "aktivan",
        "opis": "AI asistent za učenje programiranja"
    }


@app.get("/zdravo")
async def zdravo():
    """Vasa pozdravlja."""
    return {
        "poruka": pozdrav(),
        "tip": "pozdrav"
    }


@app.get("/o-vasi")
async def o_vasi():
    """Informacije o Učitelju Vasi."""
    return {
        "ime": "Učitelj Vasa",
        "opis": predstavi_se(),
        "mogucnosti": [
            "Odgovara na pitanja o programiranju",
            "Objašnjava koncepte",
            "Pomaže sa debug-ovanjem",
            "Daje primere koda"
        ]
    }


@app.post("/pitaj")
async def pitaj_vasu(pitanje_data: Dict[str, str]):
    """
    Postavlja pitanje Učitelju Vasi.
    
    Očekuje JSON sa poljem:
    - pitanje: string (obavezno)
    """
    # Proveri da li postoji pitanje
    if "pitanje" not in pitanje_data:
        raise HTTPException(
            status_code=400,
            detail="Nedostaje 'pitanje' polje u zahtevu"
        )
    
    pitanje = pitanje_data["pitanje"]
    
    if not pitanje.strip():
        raise HTTPException(
            status_code=400,
            detail="Pitanje ne može biti prazno"
        )
    
    # Proveri AI servis
    if not ai_service:
        return {
            "greska": "AI servis trenutno nije dostupan",
            "savet": "Pokušaj ponovo za nekoliko sekundi"
        }
    
    try:
        # Jednostavno pozovi AI kao u konzoli
        odgovor = ai_service.pozovi_ai(pitanje, VASA_LICNOST)
        
        return {
            "pitanje": pitanje,
            "odgovor": odgovor
        }
        
    except Exception as e:
        # Loguj grešku ali vrati user-friendly poruku
        print(f"❌ Greška pri obradi pitanja: {e}")
        
        return {
            "greska": "Dogodila se greška pri obradi pitanja",
            "savet": "Pokušaj ponovo ili promeni formulaciju pitanja"
        }


if __name__ == "__main__":
    # Za development - pokreni server direktno
    import uvicorn
    
    print("🚀 Pokrećem Učitelja Vasu API na http://localhost:8000")
    print("📚 Dokumentacija dostupna na http://localhost:8000/docs")
    
    uvicorn.run(
        "app:app",
        host="0.0.0.0",
        port=8000,
        reload=True  # Automatski restart pri promeni koda
    )

⚡ SAVET ZA OPTIMIZACIJU: Primetio si da sve funkcije endpoint-a počinju sa async def. Ovo je ključ performansi! Koristi async def za sve operacije koje čekaju nešto (npr. AI odgovor, čitanje fajla, upit u bazu). Za čiste, brze kalkulacije koje opterećuju procesor (CPU-bound), koristi običan def. FastAPI je pametan: async funkcije će pokrenuti asinhrono, oslobađajući server da radi druge stvari dok čeka.

💡 PRO TIP: Kada praviš mnogo ruta, grupiši ih pomoću APIRouter. To je kao da u velikom špajzu držiš teglice u kutijama sa etiketom – brzo znaš gde je slatko, a gde ljuto, i možeš celu kutiju da premestiš u drugi ormar (aplikaciju) bez prosipanja.

Pokretanje i testiranje FastAPI servera

Sada ćemo pokrenuti server i testirati naše endpoint-e.

📚 NIVO 1 – Osnovno objašnjenje

Pokretanje FastAPI servera je kao otvaranje radnje – dok je server pokrenut, ljudi mogu da dolaze i postavljaju pitanja. Kada zaustaviš server (Ctrl+C), to je kao da si zatvorio radnju.

Za testiranje možeš koristiti:

• Web browser (za GET zahteve)
• Automatsku dokumentaciju (za sve tipove zahteva)
• curl ili Postman (naprednije)

🚀 NIVO 2 – Dublje razumevanje

Uvicorn server sluša na određenom portu (standardno 8000) i čeka HTTP zahteve. Opcija --reload omogućava hot-reload – server se automatski restartuje kada promeniš kod, što je odlično za development.

Kreiraj src/web_api/run_server.py za lakše pokretanje:

"""
Skripta za pokretanje FastAPI servera
"""

import uvicorn
import sys
import os

# Dodaj src u path
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

if __name__ == "__main__":
    print("🎓 Učitelj Vasa Web API")
    print("=" * 50)
    print("🚀 Server se pokreće na: http://localhost:8000")
    print("📚 Dokumentacija: http://localhost:8000/docs")
    print("📊 Alternativna dokumentacija: http://localhost:8000/redoc")
    print("\n✋ Za zaustavljanje pritisni Ctrl+C")
    print("=" * 50 + "\n")
    
    uvicorn.run(
        "web_api.app:app",
        host="0.0.0.0",
        port=8000,
        reload=True,
        log_level="info"
    )

Pokreni server:

cd src
python web_api/run_server.py

Testiranje endpoint-a kroz browser

1. Test osnovnog endpoint-a:
   • Otvori browser i idi na: http://localhost:8000
   • Trebalo bi da vidiš JSON sa osnovnim informacijama
2. Test pozdrava:
   • Idi na: http://localhost:8000/zdravo
   • Vidiš Vasin pozdrav u JSON formatu
3. Interaktivna dokumentacija:
   • Idi na: http://localhost:8000/docs
   • Ovo je Swagger UI gde možeš testirati sve endpoint-e
4. Test POST zahteva kroz dokumentaciju:
   • U Swagger UI, klikni na /pitaj endpoint
   • Klikni “Try it out”
   • Unesi JSON:

   {
     "pitanje": "Šta je FastAPI?"
   }
   

   • Klikni “Execute”
   • Vidi odgovor ispod

💡 PRO TIP: Dok eksperimentišeš, pokreni dva terminala: jedan sa server-logom, drugi za curl pozive. Tako vidiš live svaku grešku bez prebacivanja prozora – kao da imaš otvoren kuhinjski prozor i odmah čuješ da li je pasta prekuvana.

🎈 ZABAVNA ČINJENICA: Swagger, interfejs koji FastAPI koristi, dobio je ime po “razmetanju krila” (engl. swagger) jer su njegovi tvorci želeli da se API-dokumentacija “šeta” samouvereno pred korisnikom.

Fast API

Fast API response

🔍 UVID: FastAPI-jeva automatska dokumentacija nije samo “nice to have” – ona fundamentalno menja način rada sa API-jima. Pre FastAPI-ja, developeri su morali ručno da pišu dokumentaciju koja je često bila zastarela. Sa FastAPI, dokumentacija se automatski generiše iz koda i uvek je ažurna. Swagger UI omogućava da testirate endpoint-e direktno iz browser-a bez potrebe za dodatnim alatima.

Integracija sa postojećim sistemima

Sada ćemo videti kako FastAPI elegantno koristi sve komponente koje smo već izgradili.

📚 NIVO 1 – Osnovno objašnjenje

Sve što smo do sada napravili (AI servisi, personalizacija, resilience) radi isto kao i pre – samo sada umesto kroz konzolu, pristupamo kroz web. To je kao kada istu knjigu čitaš na papiru ili telefonu – sadržaj je isti, samo je način pristupa drugačiji.

🚀 NIVO 2 – Dublje razumevanje

FastAPI endpoint-i su samo “thin wrapper” oko postojeće logike. Ovo je dobar primer separation of concerns – biznis logika (AI servisi) je odvojena od presentation layer-a (FastAPI). To omogućava da istu logiku koristimo kroz konzolu, web API, desktop aplikaciju, itd.

💡 PRO TIP: Nikad ne stavljaj biznis logiku direktno u endpoint funkcije. Endpoint treba samo da:

1. Validira input
2. Pozove odgovarajuću biznis funkciju
3. Formatira output
4. Handle-uje greške

Ovo čini kod lakšim za testiranje i održavanje.

Praktična implementacija

Testiranje sa curl

Za one koji žele da testiraju API iz terminala, evo osnovnih curl komandi:

# Test osnovnog endpoint-a
curl http://localhost:8000/

# Test pozdrava
curl http://localhost:8000/zdravo

# Test POST zahteva
curl -X POST http://localhost:8000/pitaj \
     -H "Content-Type: application/json" \
     -d '{"pitanje": "Objasni mi šta je REST API u dve rečenice"}'

🎯 ALTERNATIVNO REŠENJE: Ako želiš ultra minimalan server bez svih FastAPI pogodnosti, možeš pokrenuti Starlette direktno:

from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

async def homepage(request):
    return JSONResponse({"msg": "Hello from Starlette!"})

app = Starlette(debug=True, routes=[Route("/", homepage)])

Razlika? Starlette je “goli motor”; FastAPI dodaje karoseriju (type-validation, docs, dependency-injection).

Dodavanje CORS podrške

Ako želiš da tvoj API bude dostupan iz browser-a sa drugih domena, treba ti CORS.

📚 NIVO 1 – Osnovno objašnjenje

CORS (Cross-Origin Resource Sharing) je sigurnosni mehanizam browser-a. Ako imaš web sajt na jednoj adresi (npr. mysite.com) koji pokušava da pozove API na drugoj adresi (localhost:8000), browser će to blokirati osim ako API eksplicitno ne dozvoli.

🚀 NIVO 2 – Dublje razumevanje

CORS funkcioniše kroz HTTP header-e. Browser prvo šalje “preflight” OPTIONS zahtev da proveri da li je dozvoljen pristup. Server odgovara sa header-ima koji specificiraju ko može da pristupa i kako.

Ažuriraj src/web_api/app.py dodavanjem CORS podrške na početak (nakon kreiranja app instance):

from fastapi.middleware.cors import CORSMiddleware

# Nakon kreiranja app instance, dodaj:
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # U produkciji, navedi specifične domene
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

⚠️ VAŽNO: allow_origins=["*"] dozvoljava pristup sa svih domena, što je OK za development ali ne za produkciju. U produkciji, navedi samo domene kojima veruješ.

🔄 VEŽBA: Napravi novu rutu /echo koja prima JSON sa poljem text i vraća isti tekst nazad uz prefiks “EHO:”. Pazi da proveriš da text nije prazan string!

Česte greške i rešenja

❌ GREŠKA: ModuleNotFoundError: No module named 'fastapi'
💡 REŠENJE:

• Proveri da li si instalirao FastAPI: pip install fastapi uvicorn[standard]
• Možda si u pogrešnom virtual environment-u
• Proveri sa pip list | grep fastapi

🔬 DETALJNIJE: ModuleNotFoundError je sistemska greška koja ukazuje na problem u lancu snabdevanja zavisnosti (dependency supply chain) tvog projekta. Python interpreter, kada vidi import fastapi, pretražuje unapred definisane lokacije na tvom sistemu (kolekciju foldera poznatu kao sys.path). Ova greška znači da ni na jednoj od tih lokacija nije pronađen folder fastapi. Najčešći uzroci su:

1. Izolacija okruženja: pip install je izvršen u jednom okruženju, a kod se pokreće u drugom
2. Prekinut lanac: pip je uspešno preuzeo paket, ali ga nije ispravno postavio

❌ GREŠKA: Port 8000 je već zauzet
💡 REŠENJE:

• Neka druga aplikacija koristi port 8000
• Promeni port: uvicorn.run(..., port=8001)
• Ili zaustavi aplikaciju koja koristi 8000: lsof -i :8000 (na Mac/Linux)

❌ GREŠKA: API vraća 422 Unprocessable Entity
💡 REŠENJE:

• Šalješ neispravan JSON format
• Proveri da li imaš sva obavezna polja
• Koristi Swagger UI da vidiš tačan format

❌ GREŠKA: CORS greška u browser-u
💡 REŠENJE:

• Dodaj CORS middleware kao što je pokazano gore
• Proveri da li si restartovao server nakon dodavanja
• U browser DevTools, pogledaj Network tab za detalje

❌ GREŠKA: Server se ne restartuje automatski
💡 REŠENJE:

• Proveri da li si pokrenuo sa reload=True
• Možda si sačuvao fajl van src foldera
• Restartuj server ručno (Ctrl+C pa ponovo pokreni)

Proveri svoje razumevanje

[NIVO 1]:

1. Šta je FastAPI i čemu služi?
2. Koja je razlika između GET i POST zahteva?
3. Gde možeš videti automatsku dokumentaciju?
4. Zašto je važno da biznis logika bude odvojena od endpoint-a?

[NIVO 2]:

1. Šta su type hints i kako ih FastAPI koristi?
2. Šta je ASGI i zašto je bolje od WSGI?
3. Kako bi dodao novi GET endpoint /verzija koji vraća verziju API-ja?
4. Zašto koristimo async def umesto običnog def?
5. Šta se dešava kada browser pošalje OPTIONS zahtev?

🤔 MINI-KVIZ:

1. Koju prednost nam daju type hints u FastAPI u odnosu na Flask?
2. Šta radi [standard] deo u komandi uvicorn[standard]?
3. Zašto je ASGI pogodniji za aplikacije sa dugotrajnim AI-pozivima?

Dodatni primeri i zabavne vežbe

1. Ping-pong AI – Napravi endpoint /ping koji vraća {"odgovor": "pong", "vreme": "trenutni_timestamp"}
2. Brojač poziva – Dodaj globalnu varijablu koja broji koliko puta je pozvan /pitaj endpoint

Ažuriranje dokumentacije

Ažuriraj README.md:

## 🚀 Trenutni Status

- ✅ Dan -3: Python 3.13+ instaliran
- ✅ Dan -2: PyCharm unified edition podešen  
- ✅ Dan -1: GitHub repository kreiran
- ✅ Dan 0: Profesionalna struktura projekta
- ✅ Dan 1: Prvi Python moduli - Vasa može da pozdravi!
- ✅ Dan 2: Razumevanje AI API-ja - simulacija komunikacije
- ✅ Dan 3: Multi-provider podrška - OpenAI i Gemini
- ✅ Dan 4: Prvi AI poziv - univerzalni sistem sa SSL fix-om
- ✅ Dan 5: Profilisanje i optimizacija - automatski izbor najboljih postavki
- ✅ Dan 6: Resilience sistem - retry, circuit breaker, fallback i graceful degradation
- ✅ Dan 7: Napredna personalizacija - profili, preference i adaptivno učenje
- ✅ Dan 8: Uvod u FastAPI - Učitelj Vasa je sada web servis! 🌐
- ⏳ Dan 9: Prvi web endpoint za multi-provider sistem (sutra)

## 🌐 Web API

Učitelj Vasa je sada dostupan kao REST API!

### Pokretanje servera:
```bash
cd src
python web_api/run_server.py

Dostupni endpoint-i:

• GET / – Osnovne informacije
• GET /zdravo – Vasin pozdrav
• GET /o-vasi – Detalji o Učitelju Vasi
• POST /pitaj – Postavi pitanje

Dokumentacija:

• Swagger UI: http://localhost:8000/docs
• ReDoc: http://localhost:8000/redoc

Dodaj u `docs/development_log.md`:

```markdown
## Dan 8: Uvod u FastAPI (19.06.2025)

### Šta je urađeno:
- ✅ Instaliran FastAPI i uvicorn
- ✅ Kreiran prvi web API sa osnovnim endpoint-ima
- ✅ GET endpoint-i za informacije (/zdravo, /o-vasi)
- ✅ POST endpoint za pitanja (/pitaj)
- ✅ Automatska dokumentacija (Swagger UI)
- ✅ CORS podrška za browser pristup
- ✅ Integrisan postojeći AI servis

### Naučene lekcije:
- FastAPI drastično pojednostavljuje kreiranje web API-ja
- Type hints omogućavaju automatsku dokumentaciju
- Swagger UI je game-changer za API development
- ASGI omogućava handling konkurentnih zahteva
- Convention over Configuration princip čini kod čistijim

### Problemi i rešenja:
- **Problem**: Module not found greške
- **Rešenje**: Dodavanje src foldera u Python path
- **Problem**: Kako integrisati postojeći sistem?
- **Rešenje**: Endpoint funkcije su thin wrapper oko postojeće logike

### Testiranje:
- Svi endpoint-i rade kroz Swagger UI
- Browser može pristupiti GET endpoint-ima
- POST zahtevi rade sa JSON payload-om
- CORS omogućava pristup iz browser-a

### Za sutra (Dan 9):
- Dodati endpoint-e specifične za multi-provider sistem
- Status endpoint sa provider informacijama
- Health check za svaki provider

Git commit za danas

git add .
git commit -m "Dan 8: FastAPI integracija - Učitelj Vasa je sada web servis!"
git push

ČESTITAM! 🎉 Učitelj Vasa je sada pravi web servis! Transformisao si konzolnu aplikaciju u moderan REST API koji:

• Može da prima HTTP zahteve
• Automatski generiše dokumentaciju
• Elegantno integriše postojeće AI servise
• Spreman je za dalje proširivanje

Ovo je ogroman korak – od lokalne aplikacije do servisa dostupnog preko web-a!

Sutra Učitelj Vasa uči

Sutra ćemo proširiti web API sa endpoint-ima specifičnim za multi-provider sistem. Naučićeš kako da dodaš status endpoint koji pokazuje dostupne providere, kako da implementiraš health check za svaki AI servis, i kako da omogućiš dinamičko prebacivanje između providera kroz API. Gradićemo na današnjoj osnovi!

📚 REČNIK DANAŠNJE LEKCIJE:

• FastAPI: Moderan Python web framework za kreiranje API-ja
• API (Application Programming Interface): Način kako programi komuniciraju međusobno
• Endpoint: Specifična ruta/adresa u API-ju koja prima zahteve
• HTTP metode: GET (čitanje), POST (kreiranje), PUT (ažuriranje), DELETE (brisanje)
• ASGI: Asynchronous Server Gateway Interface – standard za Python async web servere
• Uvicorn: ASGI server koji pokreće FastAPI aplikacije
• CORS: Cross-Origin Resource Sharing – sigurnosni mehanizam browser-a
• Swagger UI: Interaktivna dokumentacija za testiranje API-ja
• JSON: JavaScript Object Notation – format za razmenu podataka
• Route: Putanja u API-ju koja se mapira na funkciju
• Type hints: Python anotacije tipova koje FastAPI koristi za dokumentaciju