Wyslij produkcyjna aplikacje AI w 5 minut: FastAPI + Next.js + 20 integracji

Zaczynasz nowy projekt AI. Potrzebujesz backendu FastAPI z uwierzytelnianiem, frontendu Next.js ze streamingiem czatu, obslugi WebSocket, migracji bazodanowych, cachowania Redis, wdrozenia Docker i agenta Pydantic AI z obsluga narzedzi.

Otwierasz pusty katalog. Dwa tygodnie pozniej podlaczyles 15 bibliotek, naprawiles 30 problemow z konfiguracja i napisales zero logiki biznesowej.

TL;DR

• fastapi-fullstack create my_app generuje kompletny produkcyjny stos — backend FastAPI, frontend Next.js, Docker, CI/CD — jednym poleceniem.
• 20+ integracji od razu: Pydantic AI, LangChain, JWT auth, PostgreSQL, Redis, WebSocket streaming, Logfire, Sentry, Celery, Kubernetes i wiecej.
• Presety dopasowane do typowych architektur: --preset ai-agent dla aplikacji czatowych AI, --preset production dla wdrozen enterprise, lub wybierz poszczegolne opcje.
• CLI generuje kompletne, uruchamialne projekty — nie puste pliki z komentarzami TODO. Testy przechodza, Docker sie buduje, serwer startuje.
• Wszystko jest wymienialne. Zacznij z SQLite, przejdz na PostgreSQL. Zacznij z Pydantic AI, dodaj LangChain. Architektura wspiera inkrementalna migracje.

Tancowalismy ten taniec zbyt wiele razy. Po dziesiatym projekcie, w ktorym kopiowalismy ten sam system auth, ten sam handler WebSocket, ten sam setup Docker Compose i ten sam pipeline CI, zbudowalismy szablon. Potem zamienilismy go w narzedzie CLI.

fastapi-fullstack create my_app — i dostajesz caly stos, skonfigurowany, przetestowany i gotowy do wdrozenia.

CLI: jedno polecenie, pelny stos

pip install fastapi-fullstack
fastapi-fullstack create my_app --preset ai-agent

To generuje kompletny projekt z:

Backend: FastAPI + agent Pydantic AI + WebSocket streaming + JWT auth + PostgreSQL + Redis + migracje Alembic + rate limiting + panel administracyjny + obserwowalnosc Logfire

Frontend: Next.js 15 + React 19 + TypeScript + Tailwind CSS v4 + Zustand + TanStack Query + WebSocket chat UI + dark mode

DevOps: Docker + Docker Compose + wieloetapowe buildy + health checks + Makefile

Co jest w srodku: 20+ integracji

Presety: wybierz swoj stos

# Production -- wszystko czego potrzebujesz
fastapi-fullstack create my_app --preset production

# AI Agent -- zoptymalizowany dla aplikacji agentowych
fastapi-fullstack create my_app --preset ai-agent

# Custom -- wybierz dokladnie to, co chcesz
fastapi-fullstack create my_app \
  --database postgresql \
  --auth jwt \
  --ai-framework pydantic_ai \
  --llm-provider openai \
  --redis \
  --websockets \
  --admin-panel \
  --sentry

Preset ai-agent daje ci PostgreSQL, WebSocket streaming, persystencje konwersacji i w pelni skonfigurowanego agenta Pydantic AI z obsluga narzedzi.

Agent AI: Pydantic AI ze streamingiem

Wygenerowany agent jest gotowy produkcyjnie z dependency injection i obsluga narzedzi:

@dataclass
class Deps:
    user_id: str | None = None
    user_name: str | None = None
    metadata: dict[str, Any] = field(default_factory=dict)


class AssistantAgent:
    def __init__(self, model_name=None, temperature=None, system_prompt=None):
        self.model_name = model_name or settings.AI_MODEL
        self.temperature = temperature or settings.AI_TEMPERATURE
        self.system_prompt = system_prompt or DEFAULT_SYSTEM_PROMPT

    def _create_agent(self) -> Agent[Deps, str]:
        model = OpenAIChatModel(
            self.model_name,
            provider=OpenAIProvider(api_key=settings.OPENAI_API_KEY),
        )

        agent = Agent[Deps, str](
            model=model,
            model_settings=ModelSettings(temperature=self.temperature),
            system_prompt=self.system_prompt,
        )
        self._register_tools(agent)
        return agent

    def _register_tools(self, agent):
        @agent.tool
        async def current_datetime(ctx: RunContext[Deps]) -> str:
            """Get the current date and time."""
            return get_current_datetime()

Dodaj wlasne narzedzia rozszerzajac _register_tools(). Agent uzywa wzorca deps — kontekst uzytkownika przeplywana przez RunContext[Deps] do kazdego wywolania narzedzia.

WebSocket Streaming: token po tokenie

Endpoint WebSocket streamuje odpowiedzi agenta w czasie rzeczywistym:

@router.websocket("/ws/chat")
async def chat_websocket(websocket: WebSocket, user = Depends(get_current_user_ws)):
    await manager.connect(websocket)
    conversation_history = []

    try:
        while True:
            data = await websocket.receive_json()
            user_message = data.get("message", "")

            async with agent.iter(
                user_message,
                deps=deps,
                message_history=model_history,
            ) as agent_run:
                async for node in agent_run:
                    if Agent.is_model_request_node(node):
                        async with node.stream(agent_run.ctx) as stream:
                            async for event in stream:
                                if isinstance(event, PartDeltaEvent):
                                    await manager.send_event(
                                        websocket, "text_delta",
                                        {"content": event.delta.content_delta},
                                    )

                    elif Agent.is_call_tools_node(node):
                        async with node.stream(agent_run.ctx) as stream:
                            async for event in stream:
                                if isinstance(event, FunctionToolCallEvent):
                                    await manager.send_event(
                                        websocket, "tool_call",
                                        {"tool_name": event.part.tool_name},
                                    )

            await manager.send_event(websocket, "complete", {})

    except WebSocketDisconnect:
        manager.disconnect(websocket)

Frontend odbiera eventy text_delta, tool_call, tool_result i complete. Delty tekstu sa renderowane token po tokenie. Wywolania narzedzi pokazuja wizualny wskaznik. To ten sam streaming UX, ktory widzisz w ChatGPT.

Uwierzytelnianie JWT: logowanie, rejestracja, odswiezanie

System auth jest kompletny — nie stub:

@router.post("/login", response_model=Token)
async def login(
    form_data: OAuth2PasswordRequestForm,
    user_service: UserSvc,
    session_service: SessionSvc,
):
    user = await user_service.authenticate(
        form_data.username, form_data.password
    )
    access_token = create_access_token(subject=str(user.id))
    refresh_token = create_refresh_token(subject=str(user.id))

    await session_service.create_session(
        user_id=user.id,
        refresh_token=refresh_token,
    )
    return Token(
        access_token=access_token,
        refresh_token=refresh_token,
    )

Hashowanie hasel Bcrypt. Tokeny dostepu JWT (30 min). Tokeny odswiezania (7 dni). Sledzenie sesji. Frontend obsluguje auto-refresh transparentnie.

Polecenia CLI w stylu Django

Wygenerowany projekt zawiera CLI do zarzadzania:

# Serwer
uv run my_app server run --reload
uv run my_app server routes

# Baza danych
uv run my_app db migrate -m "Add users table"
uv run my_app db upgrade

# Uzytkownicy
uv run my_app user create-admin --email admin@example.com

# Celery
uv run my_app celery worker
uv run my_app celery beat

Plus Makefile dla typowych operacji:

make install       # Instalacja zaleznosci
make run           # Start serwera dev
make db-migrate    # Tworzenie migracji
make db-upgrade    # Zastosowanie migracji
make docker-up     # Start wszystkich serwisow
make test          # Uruchomienie testow

Docker: wieloetapowe buildy produkcyjne

Wygenerowany Dockerfile uzywa wieloetapowych buildow dla minimalnego rozmiaru obrazu:

# Build stage
FROM python:3.12-slim AS builder
COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
RUN --mount=type=cache,target=/root/.cache/uv \
    --mount=type=bind,source=uv.lock,target=uv.lock \
    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
    uv sync --frozen --no-install-project --no-dev

# Runtime stage
FROM python:3.12-slim
COPY --from=builder /app/.venv /app/.venv
RUN adduser --disabled-password appuser
USER appuser

HEALTHCHECK --interval=30s --timeout=10s \
    CMD python -c "import httpx; httpx.get('http://localhost:8000/api/v1/health')"

Uzytkownik nie-root. Health checks. Cache buildow dla szybkich przebudowan. Plik Docker Compose laczy PostgreSQL, Redis, Celery worker, Celery beat i monitoring Flower.

Frontend: Next.js 15 + React 19

Frontend to nowoczesny setup Next.js:

• Zustand do zarzadzania stanem
• TanStack Query do pobierania danych z API
• WebSocket chat UI ze streamingiem token po tokenie
• JWT auth z auto-odswiezaniem
• Dark mode od razu
• Tailwind CSS v4 do stylowania
• Playwright do testow e2e

Kluczowe wnioski

• Nie buduj boilerplate’u. JWT auth, WebSocket streaming, konfiguracje Docker, pipeline’y CI — to rozwiazane problemy. Uzyj szablonu, ktory robi to dobrze, abys mogl skupic sie na logice biznesowej.
• Presety pasuja do typowych architektur. --preset ai-agent daje ci dokladnie to, czego potrzebuja aplikacje czatowe AI. --preset production dodaje integracje enterprise.
• CLI generuje, a nie scaffolduje. Dostajesz kompletny, uruchamialny projekt — nie puste pliki z komentarzami TODO. Testy przechodza. Docker sie buduje. Serwer startuje.
• Wszystko jest wymienialne. Zacznij z SQLite, przejdz na PostgreSQL. Zacznij z Pydantic AI, dodaj LangChain. Architektura wspiera inkrementalna migracje.
• Prawdziwe projekty nauczyly nas, co jest potrzebne. Ten szablon nie jest teoretyczny — jest wyekstrahowany z wdrozen produkcyjnych. Kazda integracja jest tam, bo klient jej potrzebowal.

Wyprobuj sam

full-stack-fastapi-nextjs-llm-template — Gotowy produkcyjnie generator projektow dla aplikacji AI/LLM z FastAPI + Next.js + 20+ integracji.

pip install fastapi-fullstack
fastapi-fullstack create my_app --preset ai-agent