vstorm-co/full-stack-ai-agent-template: Production AI Apps Without Boilerplate
vstorm-co/full-stack-ai-agent-template: Production AI Apps Without Boilerplate
Building production-ready AI applications demands more than connecting an API to a chat interface. Developers need streaming responses, persistent conversations, vector search, authentication, background tasks, observability, and deployment infrastructure — all wired together correctly. Most teams spend weeks on boilerplate before writing domain logic.
The vstorm-co/full-stack-ai-agent-template addresses this directly. It's a CLI project generator that scaffolds complete FastAPI + Next.js↗ Bright Coding Blog applications with AI agents, RAG pipelines, WebSocket streaming, and enterprise integrations. With 1,532 GitHub stars, 298 forks, and an MIT license, it's maintained by Vstorm — an applied agentic AI engineering consultancy with 30+ production implementations. This full-stack AI agent template lets developers focus on building their product rather than infrastructure.
What is vstorm-co/full-stack-ai-agent-template?
The full-stack AI agent template is a Python↗ Bright Coding Blog CLI tool distributed via PyPI as fastapi-fullstack. It generates complete project structures through an interactive wizard or non-interactive flags, producing ready-to-run codebases rather than opaque frameworks or managed services.
Core identity: A project generator, not a framework. Generated projects are plain code with no runtime dependency on the generator. You own every file.
Maintainer: Vstorm, a consultancy specializing in production AI agent implementations. The project sits within a broader open-source ecosystem including pydantic-deepagents (modular agent runtime), pydantic-ai-shields (guardrails), and pydantic-ai-subagents (orchestration).
Technical relevance: The template targets the gap between prototype and production in AI application development. Most starter templates provide either a backend API wrapper or a frontend chat UI — rarely both with proper integration. This generator produces:
- Backend: FastAPI with SQLAlchemy 2.0, async PostgreSQL↗ Bright Coding Blog, Alembic migrations, JWT/OAuth auth, and optional Celery/Taskiq/ARQ/Prefect for background tasks
- Frontend: Next.js 15 with React 19, TypeScript, Tailwind CSS↗ Bright Coding Blog v4, WebSocket streaming, and dark mode
- AI Layer: Choice of 5 agent frameworks (PydanticAI, PydanticDeep, LangChain, LangGraph, DeepAgents) with 4 LLM providers (OpenAI, Anthropic, Google Gemini, OpenRouter)
- Infrastructure: Docker↗ Bright Coding Blog Compose for dev/stage/prod, Kubernetes manifests, GitHub Actions CI, Prometheus metrics, Sentry error tracking
The last commit was July 15, 2026, indicating active maintenance.
Key Features
AI Agent Frameworks (5 options): PydanticAI for type-safe agents with dependency injection; LangChain for flexible chaining; LangGraph for stateful multi-step workflows; DeepAgents (powered by Vstorm's pydantic-deepagents runtime) for sandboxed execution with Docker and browser automation; and PydanticDeep for structured outputs.
RAG Pipeline (4 vector stores): Document ingestion from local files, API uploads, Google Drive, or S3/MinIO with scheduled sync. Parsing supports 130+ formats via PyMuPDF, LlamaParse, and python-docx. Chunking uses recursive strategies with configurable overlap. Embedding providers include OpenAI, Voyage, Gemini (multimodal text + images), and SentenceTransformers. Vector search runs on Milvus, Qdrant, ChromaDB, or pgvector, with Cohere or CrossEncoder reranking.
Real-time Streaming: WebSocket endpoints deliver token-by-token responses with full event access — tool calls, reasoning steps, subagent status, and user prompts all stream to the frontend as structured events.
Rich Chat UI: Specialized rendering for tool outputs — web search results, knowledge base citations, Python code execution with stdout capture, interactive charts (bar/area/line/pie/scatter), live task checklists, and subagent monitoring panels.
Enterprise Integrations (20+): Stripe billing with seat-based subscriptions, usage metering, credits ledger, and Customer Portal. Admin panel with SQLAdmin for user management, conversation browser, message ratings analytics, and system health checks. Telegram and Slack multi-bot support with webhook/polling modes. Prefect for scheduled workflows. Logfire for PydanticAI observability, LangSmith for LangChain tracing.
Developer Experience: Django-style CLI commands auto-discovered from app/commands/. AI-coding-assistant optimized with CLAUDE.md, AGENTS.md, and .claude/ toolkit with feature-gated skills. 100% test coverage badge. PyPI distribution with uv, pip, and pipx install paths.
Use Cases
AI Chatbots and Assistants: The most direct application. The streaming WebSocket architecture, conversation persistence, and tool-calling infrastructure suit customer support bots, internal knowledge assistants, and coding copilots. The ask_user tool enables clarification loops, while subagent orchestration handles complex multi-step requests.
Enterprise SaaS Products: The billing module (Stripe subscriptions + credits), team workspaces with role-based access, admin panel, and API key management (sk_* tokens) provide the foundation for multi-tenant AI products. The marketing site generator (hero, pricing, blog, legal pages) accelerates go-to-market.
Document Intelligence Platforms: Organizations with large document corpora can leverage the full RAG pipeline — Google Drive and S3 connectors with encrypted credentials, scheduled sync jobs, per-run logs, and multimodal embeddings that process both text and images from PDFs.
Workflow Automation Tools: Prefect integration enables scheduled RAG ingestion, billing reconciliation, and email flows. Celery/Taskiq/ARQ handle asynchronous processing for long-running agent tasks, file conversions, and webhook deliveries.
Multi-channel AI Deployment: The Telegram and Slack bot integrations with per-thread session isolation allow deploying the same agent logic across chat interfaces without code duplication. Group concurrency controls prevent resource exhaustion.
Installation & Setup
Install the generator via PyPI using your preferred Python tool:
# pip
pip install fastapi-fullstack
# uv (recommended by the maintainers)
uv tool install fastapi-fullstack
# pipx
pipx install fastapi-fullstack
Generate a project interactively:
fastapi-fullstack
Or skip the wizard with explicit flags:
# AI agent with streaming, non-interactive
fastapi-fullstack create my_ai_app --preset ai-agent
# Full production setup
fastapi-fullstack create my_ai_app --preset production
# Minimal: PostgreSQL only, no Docker/Redis/CI
fastapi-fullstack create my_ai_app --minimal
Start the backend infrastructure:
cd my_ai_app
make bootstrap
This command is idempotent. It builds the backend Docker image, starts services via docker-compose.dev.yml, waits for PostgreSQL readiness (pg_isready), applies Alembic migrations, and seeds an admin user (admin@example.com / admin123).
Start the frontend in a second terminal:
cd frontend && bun install && bun dev
Access points after startup:
| Service | URL | Notes |
|---|---|---|
| Backend API | http://localhost:8000 | |
| API Documentation | http://localhost:8000/docs | OpenAPI/Swagger UI |
| Admin Panel | http://localhost:8000/admin | Credentials from make seed |
| Frontend | http://localhost:3000 | Next.js dev server |
Day-to-day development uses make dev (skips admin re-seed) and make dev-down to stop. See make help for all targets including stage and prod environments.
Real Code Examples
PydanticAI Agent with Dependency Injection
The README provides this pattern for type-safe agents with injected dependencies:
# app/agents/assistant.py
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
...
This demonstrates the template's emphasis on type safety and testability — dependencies are explicit and injectable rather than global or implicit.
WebSocket Streaming Endpoint
Both PydanticAI and LangChain agents use the same WebSocket interface:
@router.websocket("/ws")
async def agent_ws(websocket: WebSocket):
await websocket.accept()
# Works with both PydanticAI and LangChain
async for event in agent.stream(user_input):
await websocket.send_json({
"type": "text_delta",
"content": event.content
})
The unified streaming abstraction means switching AI frameworks doesn't require frontend changes — the event schema remains consistent.
Django-Style Custom Command
Auto-discovered commands extend the project CLI:
# app/commands/seed.py
from app.commands import command, success, error
import click
@command("seed", help="Seed database with test data")
@click.option("--count", "-c", default=10, type=int)
@click.option("--dry-run", is_flag=True)
def seed_database(count: int, dry_run: bool):
"""Seed the database with sample data."""
if dry_run:
info(f"[DRY RUN] Would create {count} records")
return
# Your logic here
success(f"Created {count} records!")
Commands are automatically discovered from app/commands/ — no registration boilerplate required.
Logfire Observability Setup
Automatic instrumentation for distributed tracing:
# Automatic instrumentation in app/main.py
import logfire
logfire.configure()
logfire.instrument_fastapi(app)
logfire.instrument_asyncpg()
logfire.instrument_redis()
logfire.instrument_httpx()
# Manual spans for custom logic
with logfire.span("process_order", order_id=order.id):
await validate_order(order)
await charge_payment(order)
await send_confirmation(order)
This captures traces across FastAPI requests, database queries, cache operations, background tasks, and external HTTP calls in a single timeline.
Advanced Usage & Best Practices
Framework Selection Guidance: PydanticAI offers the best provider flexibility (including OpenRouter) and type safety. LangGraph suits complex multi-step workflows with explicit state management. DeepAgents provides sandboxed code execution — valuable for agents that need to run untrusted code safely.
Vector Store Trade-offs: For development, ChromaDB requires no additional services. For production with existing PostgreSQL, pgvector minimizes infrastructure. Milvus and Qdrant offer superior performance at scale but add operational complexity — Milvus requires three services (etcd, MinIO, Milvus itself), while Qdrant runs as a single container.
Local Development Without Docker: Run make install for uv sync and pre-commit hooks, then start only infrastructure containers (db redis plus vector store if RAG-enabled). This enables IDE breakpoints in the backend while keeping dependencies containerized.
Production Deployment: The make prod target uses docker-compose.prod.yml with external Nginx. Copy backend/.env.example to backend/.env and fill real secrets. For frontend, npx vercel --prod deploys to Vercel with required environment variables (BACKEND_URL, BACKEND_WS_URL, NEXT_PUBLIC_AUTH_ENABLED=true).
AI-Assisted Development: The generated .claude/ toolkit adapts to selected options. Feature-gated skills like alembic-migration, agent-tool, and rag-knowledge auto-trigger when relevant. Convention rules enforce architecture patterns automatically. [INTERNAL_LINK: AI-assisted development workflows]
Comparison with Alternatives
| Feature | vstorm-co/full-stack-ai-agent-template | full-stack-fastapi-template (Tiangolo) | create-t3-app (T3 OSS) |
|---|---|---|---|
| AI Agents (5 frameworks) | ✅ | ❌ | ❌ |
| RAG Pipeline (4 vector stores) | ✅ | ❌ | ❌ |
| WebSocket Streaming | ✅ | ❌ | ❌ |
| Conversation Persistence | ✅ | ❌ | ❌ |
| LLM Observability | ✅ | ❌ | ❌ |
| FastAPI Backend | ✅ | ✅ | ❌ |
| Next.js Frontend | ✅ (v15) | ❌ | ✅ |
| JWT + OAuth Auth | ✅ | ✅ | ✅ (NextAuth) |
| Background Tasks | ✅ (4 options) | ✅ (Celery) | ❌ |
| Billing & Credits (Stripe) | ✅ | ❌ | ❌ |
| Admin Panel | ✅ (SQLAdmin) | ❌ | ❌ |
| Async PostgreSQL + pgvector | ✅ | ✅ | Prisma |
| Docker + Kubernetes | ✅ | ✅ | ❌ |
| Interactive CLI Wizard | ✅ | ❌ | ✅ |
| Document Sources (GDrive, S3) | ✅ | ❌ | ❌ |
| AI-Coding-Assistant Optimized | ✅ | ❌ | ❌ |
Trade-offs to consider: The Tiangolo template is lighter for traditional CRUD applications without AI requirements. create-t3-app excels at type-safe full-stack TypeScript but lacks Python backend and AI infrastructure. This template carries more complexity — appropriate for its scope, but potentially excessive for simple projects.
FAQ
Can I use this without AI features? Yes. Skip AI framework selection during setup. The auth, admin, background tasks, and frontend infrastructure remain available.
What's the minimum Python version?
Python 3.11+. Node.js 18+ for the frontend. The maintainers recommend uv for Python and bun for frontend package management.
Is the generated code locked to the generator?
No. Projects are plain code with no runtime dependency on fastapi-fullstack. Version metadata in pyproject.toml tracks the generator version for reference only.
Can I switch LLM providers after generation?
For PydanticAI, change environment variables (AI_MODEL, provider API keys) — no code changes needed. Other frameworks may require model-specific adjustments.
How do I add integrations after generation? Manually — the generator provides a starting point, not a plugin system. The structured project layout makes additions straightforward.
What's the license? MIT License — permissive for commercial use.
Does it work on Windows?
Yes, via WSL2 or Git Bash. make requires GNU Make (install via Chocolatey: choco install make).
Conclusion
The vstorm-co/full-stack-ai-agent-template solves a specific, painful problem: the weeks of infrastructure work between "AI prototype" and "production AI application." It doesn't abstract away complexity behind a managed service — it generates understandable, modifiable code that teams own.
This tool best serves teams building conversational AI products, document intelligence platforms, or multi-tenant SaaS with AI features. The 1,532-star adoption and active maintenance suggest real-world validation. The MIT license and plain-code output minimize adoption risk.
If you're evaluating whether to build AI infrastructure from scratch or start from a generator, this template warrants serious consideration — particularly if PydanticAI or LangChain align with your agent architecture preferences.
Explore the project: https://github.com/vstorm-co/full-stack-ai-agent-template
Outils recommandés
Explore on the BrightCoding network
Hand-picked resources from our other sites.
coder/coder: Self-Hosted Cloud Dev Environments with Terraform
coder/coder is a self-hosted platform for cloud development environments and AI agents using Terraform. Define workspaces as code, connect via Wireguard®, and r...
browser-use/browser-harness: Self-Healing CDP Bridge for LLM Browser Automation
browser-use/browser-harness is a 15.9k-star MIT-licensed Python tool that connects LLMs directly to Chrome via CDP websocket. Its self-healing workspace lets ag...
manaflow-ai/manaflow: Parallel AI Coding Agent Orchestration
manaflow-ai/manaflow is an MIT-licensed open-source platform for orchestrating multiple AI coding agents in parallel with isolated VS Code workspaces. Supports...
Continuez votre lecture
Why Alexandrie is the Ultimate Markdown Note-Taking App
Why CrossPaste is the Ultimate Game Changer for Clipboard Management
Why Chandra is the Ultimate OCR Tool for Handwriting and Tables
Stop Coding Alone: OPC-Skills Gives Your AI Agent Superpowers
Commentaires 0
Aucun commentaire pour l'instant. Soyez le premier à réagir !