Od zera do produkcyjnego agenta AI w 30 minut — szablon full-stack z 5 frameworkami AI

Kazdy projekt AI zaczyna sie tak samo.

Potrzebujesz backendu FastAPI. Potem uwierzytelniania — tokeny JWT, logika odswiezania, zarzadzanie uzytkownikami. Potem bazy danych — PostgreSQL, migracje, polaczenia async. Potem streamowania WebSocket dla odpowiedzi AI w czasie rzeczywistym. Potem frontendu — Next.js, zarzadzanie stanem, interfejs czatu. Potem Docker. Potem CI/CD.

Trzy dni boilerplate’u zanim napiszesz jedna linijke kodu AI.

Ustawialem ten stos od zera wiecej razy niz chcialbym przyznac. Po trzecim projekcie, w ktorym skopiowalem ten sam middleware auth, ten sam handler WebSocket, te sama konfiguracje Docker Compose — postanowilem zbudowac generator, ktory robi to wszystko jednym poleceniem.

Rezultat: full-stack-ai-agent-template — open-source’owy szablon full-stack z 5 frameworkami AI, 75+ opcjami konfiguracji i konfiguratorem webowym, ktory generuje caly projekt w kilka minut.

614 gwiazdek na GitHubie. Uzywany przez zespoly w NVIDIA, Pfizer, TikTok i innych. Mozesz przejsc od zera do dzialajacego produkcyjnego agenta AI w okolo 30 minut.

Pokaze ci dokladnie jak.

Jestem Kacper, AI Engineer w Vstorm — boutique’owej firmie konsultingowej Applied Agentic AI Engineering. Dostarczylismy 30+ produkcyjnych implementacji agentow AI i udostepniamy nasze narzedzia open-source na github.com/vstorm-co. Polacz sie ze mna na LinkedIn.

Krok 1: Otworz konfigurator webowy

Wejdz na oss.vstorm.co/projects/full-stack-ai-agent-template/configurator/.

Nie trzeba instalowac CLI. Nie trzeba pip. Tylko przegladarka.

Konfigurator daje ci wizualny interfejs do wybrania kazdej opcji projektu. Baza danych, auth, framework AI, zadania w tle, obserwowalnosc, frontend — wszystko. Widzisz pelna konfiguracje zanim cokolwiek wygenerujesz.

Alternatywnie, jesli wolisz terminal:

pip install fastapi-fullstack
fastapi-fullstack

To uruchamia interaktywnego kreatora, ktory prowadzi cie przez te same opcje.

Krok 2: Wybierz preset (lub skonfiguruj recznie)

Szablon oferuje trzy presety obejmujace najczestsze przypadki uzycia:

W tym poradniku uzyje presetu AI Agent z Pydantic AI — najczestszego punktu startowego dla aplikacji AI:

fastapi-fullstack create my_ai_app \
  --preset ai-agent \
  --ai-framework pydantic_ai \
  --frontend nextjs

To jedno polecenie generuje pelny projekt z:

• Backend FastAPI z async PostgreSQL
• Uwierzytelnianie JWT z zarzadzaniem uzytkownikami
• Agent Pydantic AI ze streamowaniem WebSocket
• Zapisywanie konwersacji (historia czatu w bazie)
• Redis do cache’owania i sesji
• Frontend Next.js 15 z React 19 i Tailwind CSS v4
• Docker Compose dla calego stosu
• CI/CD GitHub Actions
• Obserwowalnosc Logfire

Krok 3: Zobacz co dostales

Wygenerowany projekt podaza za czysta architektura warstwowa — wzorzec Repository + Service, inspirowany prawdziwymi bazami kodu produkcyjnego:

my_ai_app/
├── backend/
│   ├── app/
│   │   ├── main.py              # Aplikacja FastAPI z lifespan
│   │   ├── api/routes/v1/       # Wersjonowane endpointy API
│   │   ├── core/                # Konfiguracja, bezpieczenstwo, middleware
│   │   ├── db/models/           # Modele SQLAlchemy
│   │   ├── schemas/             # Schematy Pydantic
│   │   ├── repositories/        # Warstwa dostepu do danych
│   │   ├── services/            # Logika biznesowa
│   │   ├── agents/              # Agenty AI (tu trafia twoj kod)
│   │   └── commands/            # Komendy CLI w stylu Django
│   ├── cli/                     # CLI projektu
│   ├── tests/                   # Testy pytest
│   └── alembic/                 # Migracje bazy danych
├── frontend/
│   ├── src/
│   │   ├── app/                 # Next.js App Router
│   │   ├── components/          # Komponenty React (UI czatu w zestawie)
│   │   ├── hooks/               # useChat, useWebSocket
│   │   └── stores/              # Zarzadzanie stanem Zustand
├── docker-compose.yml
├── Makefile
├── CLAUDE.md                    # Kontekst dla asystentow AI
└── AGENTS.md                    # Przewodnik multi-agentowy

Zwroc uwage na pliki CLAUDE.md i AGENTS.md — wygenerowany projekt jest zoptymalizowany dla asystentow kodowania AI takich jak Claude Code, Cursor i Copilot. Podaza za najlepszymi praktykami stopniowego ujawniania, wiec twoj asystent AI natychmiast rozumie strukture projektu.

Krok 4: Uruchom wszystko z Dockerem

cd my_ai_app
make docker-up        # Backend + PostgreSQL + Redis
make docker-frontend  # Frontend Next.js

To wszystko. Dwa polecenia. Caly stos dziala:

• API: http://localhost:8000
• Dokumentacja API: http://localhost:8000/docs
• Frontend: http://localhost:3000
• Panel admina: http://localhost:8000/admin

Jesli wolisz uruchamiac bez Dockera, szablon generuje Makefile ze skrotami:

make install       # Instalacja zaleznosci Python + Node
make docker-db     # Uruchom tylko PostgreSQL
make db-migrate    # Utworz poczatkowa migracje
make db-upgrade    # Zastosuj migracje
make create-admin  # Utworz admina
make run           # Uruchom backend
cd frontend && bun dev  # Uruchom frontend

Krok 5: Twoj agent AI juz dziala

Otworz http://localhost:3000, zaloguj sie i zacznij rozmowe. Agent AI jest juz podlaczony — streaming WebSocket, historia konwersacji, wywolania narzedzi — wszystko dziala od razu.

Oto jak wyglada wygenerowany agent:

from pydantic_ai import Agent, RunContext
from dataclasses import dataclass

@dataclass
class Deps:
    user_id: str | None = None
    db: AsyncSession | None = None

agent = Agent[Deps, str](
    model="openai:gpt-4o-mini",
    system_prompt="You are a helpful assistant.",
)

@agent.tool
async def search_database(ctx: RunContext[Deps], query: str) -> list[dict]:
    """Search the database for relevant information."""
    # Access user context and database via ctx.deps
    ...

Type-safe. Wbudowane wstrzykiwanie zaleznosci. Wywolywanie narzedzi z pelnym dostepem do kontekstu. To nie jest przyklad-zabawka — to ten sam wzorzec, ktorego uzywamy w produkcji w Vstorm.

Endpoint WebSocket obsluguje streaming automatycznie:

@router.websocket("/ws")
async def agent_ws(websocket: WebSocket):
    await websocket.accept()

    async for event in agent.stream(user_input):
        await websocket.send_json({
            "type": "text_delta",
            "content": event.content
        })

Krok 6: Dostosuj warstwe AI

Kluczowy insight: wszystko poza agentem AI to produkcyjna infrastruktura, ktorej nie musisz ruszac. Auth dziala. Baza dziala. Streaming dziala. Frontend dziala.

Modyfikujesz jeden katalog: app/agents/.

Chcesz zmienic z OpenAI na Anthropic? Zaktualizuj string modelu:

agent = Agent[Deps, str](
    model="anthropic:claude-sonnet-4-5",
    system_prompt="You are a helpful assistant.",
)

Chcesz dodac narzedzie? Dodaj funkcje:

@agent.tool
async def get_weather(ctx: RunContext[Deps], city: str) -> str:
    """Get current weather for a city."""
    async with httpx.AsyncClient() as client:
        resp = await client.get(f"https://api.weather.com/{city}")
        return resp.json()["summary"]

Chcesz calkowicie przejsc na LangChain lub CrewAI? Wygeneruj projekt ponownie z inna flaga --ai-framework. Reszta stosu pozostaje ta sama.

5 frameworkow AI, jeden szablon

Szablon obsluguje piec frameworkow AI, wszystkie z ta sama infrastruktura backendu:

Wybierasz framework przy generowaniu projektu. Streaming WebSocket, zapisywanie konwersacji, auth i frontend dzialaja tak samo niezaleznie od wybranego frameworka.

# Generowanie z LangGraph
fastapi-fullstack create my_app --preset ai-agent --ai-framework langgraph --frontend nextjs

# Generowanie z CrewAI
fastapi-fullstack create my_app --preset ai-agent --ai-framework crewai --frontend nextjs

75+ opcji konfiguracji

Poza frameworkami AI, szablon obejmuje pelne spektrum potrzeb produkcyjnych:

Bazy danych: PostgreSQL (async), MongoDB (async), SQLite ORM-y: SQLAlchemy, SQLModel Auth: JWT + tokeny odswiezania, klucze API, Google OAuth Zadania w tle: Celery, Taskiq, ARQ Obserwowalnosc: Logfire, LangSmith, Sentry, Prometheus Infrastruktura: Docker, Kubernetes, GitHub Actions, GitLab CI, Traefik, Nginx Frontend: Next.js 15 z React 19, TypeScript, Tailwind CSS v4, tryb ciemny, i18n Dodatki: Cache Redis, rate limiting, panel SQLAdmin, webhooki, S3 file storage, RAG z Milvus

Kazda opcja to flaga boolean. Zadnego hackowania szablonow Jinja. Zadnego czyszczenia po generowaniu. Generator produkuje czysty kod, ktory zawiera tylko to, co wybrales.

Kluczowe wnioski

• Konfigurator webowy na oss.vstorm.co pozwala wizualnie skonfigurowac i pobrac pelny projekt AI — bez CLI.
• Trzy presety (minimal, ai-agent, production) pokrywaja 90% przypadkow uzycia — dostosuj stamtad.
• 5 frameworkow AI wspoldzieli te sama infrastrukture — zmieniaj frameworki bez przepisywania backendu.
• Wygenerowany kod jest klasy produkcyjnej, nie prototypem — architektura warstwowa, async wszedzie, type-safe.
• Modyfikujesz app/agents/ i nic wiecej — auth, streaming, zapisywanie, frontend sa gotowe.

Wyprobuj sam

full-stack-ai-agent-template — Produkcyjny szablon full-stack agenta AI z 5 frameworkami i 75+ opcjami.

pip install fastapi-fullstack

Lub uzyj konfiguratora webowego — bez instalacji.

Wiecej z ekosystemu open-source Vstorm:

• Wszystkie nasze projekty open-source — 13 pakietow dla ekosystemu Pydantic AI
• awesome-pydantic-ai — wyselekcjonowana lista zasobow i narzedzi Pydantic AI
• vstorm.co — nasza firma konsultingowa (30+ implementacji agentow AI)

Jesli to bylo pomocne, zaobserwuj mnie na LinkedIn — codziennie publikuje o agentach AI.