Produktions-AI-App in 5 Minuten deployen: FastAPI + Next.js + 20 Integrationen

Du startest ein neues AI-Projekt. Du brauchst ein FastAPI-Backend mit Auth, ein Next.js-Frontend mit Streaming-Chat, WebSocket-Unterstützung, Datenbank-Migrationen, Redis-Caching, Docker-Deployment und einen Pydantic AI Agent mit Tool-Support.

Du öffnest ein leeres Verzeichnis. Zwei Wochen später hast du 15 Bibliotheken verdrahtet, 30 Konfigurationsprobleme behoben und null Business-Logik geschrieben.

TL;DR

• fastapi-fullstack create my_app generiert einen kompletten Produktions-Stack — FastAPI-Backend, Next.js-Frontend, Docker, CI/CD — mit einem Befehl.
• 20+ Integrationen sofort einsatzbereit: Pydantic AI, LangChain, JWT-Auth, PostgreSQL, Redis, WebSocket-Streaming, Logfire, Sentry, Celery, Kubernetes und mehr.
• Presets passen zu gängigen Architekturen: --preset ai-agent für AI-Chat-Apps, --preset production für Enterprise-Deployments, oder wähle einzelne Optionen.
• Die CLI generiert komplette, lauffähige Projekte — keine leeren Dateien mit TODO-Kommentaren. Tests laufen, Docker baut, der Server startet.
• Alles ist austauschbar. Starte mit SQLite, wechsle zu PostgreSQL. Starte mit Pydantic AI, füge LangChain hinzu. Die Architektur unterstützt inkrementelle Migration.

Wir haben diesen Tanz zu oft mitgemacht. Nach dem zehnten Projekt, in dem wir dasselbe Auth-System, denselben WebSocket-Handler, dasselbe Docker-Compose-Setup und dieselbe CI-Pipeline kopiert haben, haben wir ein Template gebaut. Dann haben wir es in ein CLI-Tool verwandelt.

fastapi-fullstack create my_app — und du bekommst den gesamten Stack, konfiguriert, getestet und bereit zum Deployen.

Die CLI: Ein Befehl, kompletter Stack

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

Das generiert ein komplettes Projekt mit:

Backend: FastAPI + Pydantic AI Agent + WebSocket-Streaming + JWT-Auth + PostgreSQL + Redis + Alembic-Migrationen + Rate Limiting + Admin Panel + Logfire Observability

Frontend: Next.js 15 + React 19 + TypeScript + Tailwind CSS v4 + Zustand + TanStack Query + WebSocket-Chat-UI + Dark Mode

DevOps: Docker + Docker Compose + Multi-Stage Builds + Health Checks + Makefile

Was steckt drin: 20+ Integrationen

Presets: Wähle deinen Stack

# Production - alles, was du brauchst
fastapi-fullstack create my_app --preset production

# AI Agent - optimiert für Agent-Apps
fastapi-fullstack create my_app --preset ai-agent

# Custom - wähle genau, was du willst
fastapi-fullstack create my_app \
  --database postgresql \
  --auth jwt \
  --ai-framework pydantic_ai \
  --llm-provider openai \
  --redis \
  --websockets \
  --admin-panel \
  --sentry

Das ai-agent-Preset liefert PostgreSQL, WebSocket-Streaming, Konversationspersistenz und einen vollständig konfigurierten Pydantic AI Agent mit Tool-Support.

Der AI Agent: Pydantic AI mit Streaming

Der generierte Agent ist produktionsreif mit Dependency Injection und Tool-Support:

@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()

Füge eigene Tools hinzu, indem du _register_tools() erweiterst. Der Agent nutzt das Deps-Pattern — Benutzerkontext fließt über RunContext[Deps] zu jedem Tool-Aufruf.

WebSocket-Streaming: Token für Token

Der WebSocket-Endpunkt streamt Agent-Antworten in Echtzeit:

@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)

Das Frontend empfängt text_delta-, tool_call-, tool_result- und complete-Events. Text-Deltas werden Token für Token gerendert. Tool-Aufrufe zeigen einen visuellen Indikator. Es ist dieselbe Streaming-UX wie bei ChatGPT.

JWT-Authentifizierung: Login, Registrierung, Refresh

Das Auth-System ist komplett — kein 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,
    )

Bcrypt-Passwort-Hashing. JWT Access Tokens (30 Min). Refresh Tokens (7 Tage). Session-Tracking. Das Frontend handhabt den Auto-Refresh transparent.

Django-artige CLI-Befehle

Das generierte Projekt enthält eine Management-CLI:

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

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

# Benutzer
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 ein Makefile für häufige Operationen:

make install       # Abhängigkeiten installieren
make run           # Dev-Server starten
make db-migrate    # Migration erstellen
make db-upgrade    # Migrationen anwenden
make docker-up     # Alle Services starten
make test          # Tests ausführen

Docker: Multi-Stage-Produktions-Builds

Das generierte Dockerfile nutzt Multi-Stage Builds für minimale Image-Größe:

# Build-Phase
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-Phase
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')"

Nicht-Root-Benutzer. Health Checks. Build-Cache für schnelle Rebuilds. Die Docker-Compose-Datei verbindet PostgreSQL, Redis, Celery Worker, Celery Beat und Flower Monitoring.

Frontend: Next.js 15 + React 19

Das Frontend ist ein modernes Next.js-Setup:

• Zustand für State Management
• TanStack Query für API-Datenabfragen
• WebSocket-Chat-UI mit Token-für-Token-Streaming
• JWT-Auth mit Auto-Refresh
• Dark Mode sofort verfügbar
• Tailwind CSS v4 für Styling
• Playwright für E2E-Tests

Wichtigste Erkenntnisse

• Baue keinen Boilerplate. JWT-Auth, WebSocket-Streaming, Docker-Konfigurationen, CI-Pipelines — das sind gelöste Probleme. Nutze ein Template, das sie richtig umsetzt, damit du dich auf Business-Logik konzentrieren kannst.
• Presets passen zu gängigen Architekturen. --preset ai-agent liefert genau das, was AI-Chat-Apps brauchen. --preset production fügt Enterprise-Integrationen hinzu.
• Die CLI generiert, statt zu scaffolden. Du bekommst ein komplettes, lauffähiges Projekt — keine leeren Dateien mit TODO-Kommentaren. Tests laufen. Docker baut. Der Server startet.
• Alles ist austauschbar. Starte mit SQLite, wechsle zu PostgreSQL. Starte mit Pydantic AI, füge LangChain hinzu. Die Architektur unterstützt inkrementelle Migration.
• Echte Projekte haben uns gelehrt, was nötig ist. Dieses Template ist nicht theoretisch — es wurde aus Produktions-Deployments extrahiert. Jede Integration ist vorhanden, weil ein Kunde sie brauchte.

Probier es selbst aus

full-stack-fastapi-nextjs-llm-template — Produktionsreifer Projektgenerator für AI/LLM-Anwendungen mit FastAPI + Next.js + 20+ Integrationen.

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