Fastapi plugins

Build production-ready Python applications with modern async patterns, type safety, and testing. Scaffold projects using FastAPI or Django, manage dependencies with uv, enforce code quality with ruff, and implement structured observability, retries, and background jobs.

Centers Python backend development around async patterns, FastAPI, Django, and modern tooling, providing architectural guidance, testing strategies with pytest, and production best practices for scalable APIs and services.

Automate Korean daily life and work tasks through 90+ agent skills covering transportation booking (SRT, KTX, buses), shopping (Coupang, Daangn, Naver), food, real estate, government services, finance, and more. Each skill wraps Korean-specific APIs and services for agent-driven workflows.

Orchestrate autonomous multi-agent sprints to develop full features from specs.md: agents handle architecture, parallel implementation of Next.js frontends and Python/FastAPI backends, CI/CD setup, automated testing, UI QA, reviews, and iterative convergence with structured reports and git safety.

Generate AI videos from text prompts or images using Kling AI API in Python. Build scalable production pipelines with async Redis queues, batch processing, rate limiting, webhooks, monitoring, cost controls, content filters, security audits, cloud storage uploads, and CI/CD integration.

Build production-grade LLM gateways with OpenRouter: route requests across 400+ models by task or criteria, chain fallbacks for reliability, cache responses to cut costs/latency, monitor usage/costs/latency, redact PII for compliance, and benchmark performance using Python OpenAI SDK wrappers.

Build production Python applications on Azure using SDK best practices for AI agents and ML pipelines, content analysis and multimodal processing, vector/hybrid search, hierarchical storage and queues, event streaming with Event Hubs and Service Bus, OpenTelemetry monitoring, secure authentication and key management, plus infrastructure provisioning.

Add Redis-backed rate limiting to Express, FastAPI, Python, Node.js, or Java APIs using token bucket, sliding window, or quota algorithms. Enforce per-user or per-IP limits with configurable tiers, monitoring headers, and automatic 429 responses to protect against abuse.

Generate and implement standardized API error handling with RFC 7807 responses, typed error classes, middleware, logging, monitoring, and recovery strategies for consistent HTTP status codes across Express, FastAPI, Flask, Node.js, Python, Java, and Go backends.

Generate production-ready REST APIs from OpenAPI specs or schemas, creating full CRUD endpoints with pagination, filtering, auth, routes, controllers, models, middleware, services, tests, and docs for Express, FastAPI, Spring Boot, and Gin.

Generate production-ready WebSocket servers for real-time bidirectional communication using Node.js with Socket.IO or native ws, Python/FastAPI, or Go. Scaffold includes authentication middleware, event handlers, rooms, broadcasting, heartbeats, presence tracking, client SDKs, configuration, tests, and Redis scaling for high-traffic apps.

Generate production-ready webhook endpoints with HMAC signature verification, idempotency checks, payload parsing, async Redis-backed retries, event processors, middleware, routes, schemas, config, and tests for Stripe, GitHub, Twilio in Express.js or FastAPI apps.

Protect backend APIs from overload by generating throttling middleware, quota services, and management APIs with token bucket, sliding window algorithms, concurrency limits, circuit breakers, priority queues, and adaptive controls using Redis in Express, FastAPI, or JavaScript apps.

Execute 80+ bioinformatics analysis workflows for pharmacogenomics, ancestry, single-cell RNA-seq, metagenomics, and variant annotation via natural language or CLI commands, with deterministic Python execution, local-first privacy, and reproducible output bundles.

Transform requirements documents, CSV/JSON schemas, SQL DDL, protobuf, or OpenAPI specs into production-ready codebases with types, CRUD APIs, and parsers for TypeScript/Express, Python/FastAPI, or Go.

Bootstrap production-ready fullstack MVPs with React+Vite+Tailwind frontend, Express/FastAPI backend, PostgreSQL+Prisma database, JWT/OAuth authentication, tests, Docker containers, and GitHub Actions CI/CD pipelines from a single command. Delegate to AI agents for designing APIs, database schemas, scalable architectures, UI/UX improvements, and deployment strategies.

Build, debug, secure, deploy, and scale production Anthropic Claude API integrations using 30 specialized skills for authentication, error diagnosis, cost/performance optimization, guardrails, CI/CD pipelines, observability, and architectures in Python and TypeScript.

Manage projects end-to-end with Product as Code (PAC) slash commands: initialize repos with framework setups, generate JTBD/PRD/PRP docs, create/track epics/tickets/status in YAML, validate structure, run health checks, simulate timelines, track milestones from GitHub/Linear, manage todos, and sync to Linear.

Build and deploy Python serverless applications on AWS Lambda with Chalice, implement Clean Architecture and DDD patterns in FastAPI/Flask backends, and enforce code quality through automated reviews, refactoring, and security audits with Pyright and Pylsp language servers.

Design RESTful or GraphQL APIs from domain models and requirements, generate OpenAPI 3.1 specs by scanning codebases in Express, FastAPI, Flask, Go, or Java, and consult an expert for endpoint reviews, schemas, auth, versioning, pagination, and optimizations.

Generate Markdown API reference docs from source code and routes, extracting endpoints, methods, parameters, schemas, auth, errors, and examples for Express, FastAPI, Django, Java, and Go backends.

Conduct iterative multi-agent AI audits of your codebase across code quality, security, performance, testing, architecture, database, API, frontend, backend, and DevOps domains until zero issues remain. Tracks technical debt, verifies fixes, and creates GitHub issues for findings.

Profile Python performance bottlenecks with cProfile/py-spy, analyze pytest test suites for quality/coverage, check async code for issues/patterns, lint/fix with ruff, optimize algorithms/memory, generate unit/integration tests, and package/publish projects using uv/pyproject.toml.

Launch, control, and debug Polar's Docker local dev environment for FastAPI API, Next.js web app, PostgreSQL, and Redis—start/stop services, tail logs, shell access, status checks. Reference and implement billing workflows: Stripe subscriptions, checkouts, proration, dunning, benefit provisioning in Django backend.

Build and manage Microsoft Teams bots via CLI: scaffold code in TypeScript, C#, or Python; register bots and set up infrastructure/credentials; configure SSO; troubleshoot deployments—all in one workflow.

Run autonomous full-stack dev workflows in Claude Code: generate PRDs/specs via interviews, execute Ralph/autodev loops for overnight PRD implementation with git branching/testing/committing, parallelize tasks across 12 agents (architect, frontend-dev, code-reviewer), build React/Tailwind/shadcn UIs and FastAPI backends, TDD/E2E test/verify/review code, automate git commits/PRs, and audit harness health.

Orchestrate 36 specialized AI agents and 281 skills to automate full-stack development workflows: plan/implement features with parallel subagents, generate/run tests, review PRs, enforce code quality/security via hooks, coordinate git worktrees, and produce demos/docs in React/Python/FastAPI stacks.

Validate OpenAPI, Swagger, and GraphQL schemas against Express, FastAPI, or Django backends to detect breaking changes. Synchronize API contracts with implementations and generate TypeScript clients directly from YAML, JSON, or GraphQL specs.

Harden REST APIs for production by implementing Express middleware for authentication, rate limiting, input validation, and security headers. Adapt patterns to FastAPI and Nginx setups, and run security audits using provided checklists to mitigate vulnerabilities, injections, and CORS issues.

Apply REST and GraphQL API design principles to design scalable maintainable APIs, review specifications, refactor endpoints, establish design standards, and document best practices.

Deploy production recommendation systems integrating feature stores, Redis caching for low-latency personalization APIs, A/B testing, experiment tracking, and quality monitoring. Tackles cache invalidation and serving scalability issues with Docker containers.

Deploy ML models to production by generating FastAPI servers for prediction serving, Docker containers for packaging, and Kubernetes configurations for orchestration. Monitor performance with drift detection, resolve latency issues, health checks, and version conflicts in a unified workflow.

Streamline the full academic research lifecycle—from literature search and idea generation to data analysis, code development, figure creation, paper drafting, peer review simulation, and submission formatting. Automates project organization, citation management, and compliance checks while offering backend system design guidance for research platforms.

Run a persistent AI team operating system inside Claude Code — manages role-based agents, task queues, structured meetings, and automated workflows via MCP server, hooks, and CLI commands for multi-agent coordination.

Integrate KryptoGO stablecoin payments (USDT/USDC on Arbitrum) into React/Next.js frontends and Node/Python backends. Create payment intents for checkout, query transaction statuses, handle webhook notifications, and execute token transfers or withdrawals via REST APIs.

Design original software architectures and UI/UX from first principles for innovative solutions in Next.js, Astro, Svelte, Rails, Django, FastAPI, or Hono apps. Accelerate feature ideation, architecture planning, brainstorming sessions, design reviews, and strategy discussions.

Automate full-cycle agentic coding workflows in Claude Codebases: classify GitHub issues into chores/bugs/features, generate plans/specs, implement/review/fix code with tests, track KPIs, and ship PRs to main using 89 skills and 34 specialized agents for Zero-Touch Engineering.

Develop high-performance FastAPI APIs with async route handlers for CPU/IO and database tasks, dependency injection for modular reusable services, and Pydantic v2 validation for type-safe requests and responses.

Establishes opinionated Python 3.11+ engineering standards with SOLID principles, strict typing, pytest testing, ruff linting; automates TDD workflows, routes to specialists for CLI apps (Typer/Rich/Textual), web APIs (FastAPI/Flask/Django), data pipelines, packaging, code reviews, and PyPI CI/CD deployment.

Invoke 70+ slash commands to delegate expert-level tasks across 12 development phases to specialized AI agents for languages like Rust, Python, Go, JavaScript, Bash, and FastAPI, plus performance tuning, documentation, and real-time systems, with Dagger-based safety validation ensuring secure execution.

Build modern Python web apps with Django and FastAPI, define SQLAlchemy models and Alembic migrations, write pytest tests, debug errors, and review code quality using specialized agents that orchestrate database tasks and full codebase reviews.

Enforce Python code quality with a verified-issue workflow: review FastAPI routing, SQLAlchemy database patterns, PostgreSQL queries, pytest tests, and general Python type safety, using parallel linters (ruff, mypy) and multi-step verification to eliminate false positives.

Manage full API lifecycle within Claude Code using Postman: discover APIs, sync collections, generate OpenAPI specs, run tests, create mocks, audit security, and publish docs.

Build and maintain Python 3.11+ CLI applications with Typer/Rich, following TDD workflows with pytest, modern type hints, and pyproject.toml packaging. Includes code review, debugging, test analysis, CI/CD setup, and documentation generation.

Guides Python application development with FastAPI, SQLAlchemy, and Temporal patterns, plus TypeScript support for Drizzle, Fastify, and Vitest. Includes architecture guidance, stub-driven TDD, automated code review, commit conventions, and documentation generation.

Delegate Python 3.12+ project setup, code optimization, debugging, web app development with FastAPI/Django/Flask, async patterns, pytest/hypothesis testing, AI/ML workflows, and packaging to an expert agent using modern tools like ruff/pyright/uv.

Orchestrate a full development lifecycle through three specialized agents and commands: generate feature requirements as executable Product Requirement Plans, containerize applications with production Dockerfiles, delegate full-stack implementation and testing to agents, and synchronize documentation automatically.

Build production Python 3.13+ projects with async FastAPI apps, pytest testing, uv packaging, Ruff linting, GitHub Actions CI/CD, Cloudflare Workers deployment, and Modal serverless for GPU-accelerated video pipelines using OpenCV and FFmpeg.

Jumpstart Claude Code projects with 47 pre-built skills, commands, agents, and hooks that automate scaffolding full-stack apps, generating APIs/auth/UI/databases/tests, handling git workflows/security/debugging/deployments, and producing Chinese reports/explanations across React/Next.js/Python stacks.

Develop FHIR R4/R5 applications with guidance on resource modeling, server implementation, profile validation, terminology handling, SMART on FHIR, FSH authoring, SUSHI, GoFSH, and IG publishing

Build production-ready Python applications with Django, FastAPI, and async patterns. Scaffold projects using uv, enforce code quality with ruff/mypy, implement background jobs with Celery, add structured logging and metrics, and apply resilience patterns like retries and timeouts.

Develop, configure, deploy, and debug serverless Python apps on Modal.com: set up GPU-accelerated functions (T4-H200) with autoscaling, create FastAPI/ASGI endpoints and cron schedules, manage sandboxes/volumes/secrets, integrate GitHub Actions CI/CD, and troubleshoot failures for AI/ML workloads.

Build and orchestrate multi-step AI agent workflows across domains: generative art, data pipelines, backend APIs, mobile apps, knowledge systems, and documentation pipelines using a library of skills with automated execution planning and quality gates.

Build secure backend services by designing REST/GraphQL APIs, implementing OAuth/JWT authentication, integrating LLMs with RAG pipelines and prompt engineering, and conducting OWASP Top 10 security reviews with threat modeling and vulnerability fixes.

Scaffold, generate, and deploy production FastAPI backends with Beanie MongoDB models/CRUD, Keycloak auth, Redis caching, ARQ/Celery tasks, WebSockets, pytest tests/migrations; add structlog/Prometheus/OTel observability; containerize with Docker/Helm K8s; optimize performance and audit security.

Provides a set of AI-driven skills for startup founders and engineers covering fullstack development (Next.js, TypeScript, Python, FastAPI), architecture decisions, code quality, testing, CI/CD, analytics, financial modeling, legal docs, and growth strategies — all orchestrated via git hooks and multi-agent workflows.

Orchestrate full-stack feature development with automated deployment, performance optimization, security auditing, and self-healing test suites across backend, frontend, database, and infrastructure layers.

Fetch, index, and search static documentation from any URL or library alias (e.g., react, nextjs, fastapi) directly into Claude Code sessions. Use conditional-GET caching for instant reloads of live docs, regex grep for context-aware searches, refresh stale caches (>7 days), manage sources, and expose as local MCP tools—no browser, API keys, or external services needed.

Pulls any URL into Claude Code as formatted, indexed Markdown—no browser or API key needed. Instantly caches and retrieves docs for RAG, dependency-aware lookups, and version-sensitive tool behavior without leaving the terminal.

Build autonomous AI agents using Anthropic's Claude Agent SDK in TypeScript/Node.js and Python. In TypeScript, create type-safe agents with streaming queries, Zod tools, permissions, hooks, and MCP servers. In Python, develop async agents with SDK configuration, custom tools, framework integration in FastAPI/Django, and debugging support.

Summon Python specialists to scaffold production Django/FastAPI projects with uv/Docker/PostgreSQL, enforce Mypy/PEP8/security reviews, audit codebases for multi-agent parallelization, implement Celery tasks/WebSockets, and generate pytest strategies—all using 2025 patterns and official docs.

Build, optimize, and deploy DSPy programs for a wide range of AI tasks — chatbots, RAG, agents, classification, extraction — with guided skills covering every stage: signatures, modules, data handling, evaluation, optimizers, adapters, tools, retrieval, and deployment as web APIs.

Orchestrate autonomous multi-agent sprints from specs.md: project architect spawns parallel agents to implement Python/FastAPI backends, Next.js frontends, CI/CD pipelines, automated tests, UI validation, and convergent reviews until production-ready code finalizes. Setup projects, generate maps, resume/clean sprints.

Scaffold and deploy full-stack production stacks — generate FastAPI backends, React/Vite frontends, Terraform/AWS/Azure/GCP infrastructure, Ansible configs, Dockerfiles, Kubernetes manifests, and GitHub CI/CD pipelines from a single project.

Automate the full development lifecycle for AI Hero agents: scaffold projects, manage git workflows with conventional commits and PR automation, run quality checks (linting, tests, security scans), and generate architecture documentation with Mermaid diagrams.

Enforces a 31-stage AI-driven software development lifecycle for Claude Code — from PRD and design through TDD, implementation, code review, release, and retrospective — with hard contracts that persist artifacts to disk and require tests before code.

Implement the Agentic Commerce Protocol (ACP) — the open standard by OpenAI and Stripe — enabling AI agents to mediate commerce workflows including checkout sessions, delegated payments, product feeds, order lifecycle management, fulfillment, discounts, affiliate attribution, and merchant server scaffolding across Python, TypeScript, and Go backends.

Build and integrate agents using the A2A (Agent-to-Agent) protocol—create Agent Cards for discovery, handle JSON-RPC task lifecycle with streaming and push notifications, configure authentication, and orchestrate multi-agent systems with framework integrations like LangGraph and CrewAI.

Build hexagonal-architecture web apps where AI agents dynamically generate interactive HTML UIs with HTMX and Tailwind via FastAPI and Claude SDK. Persist feedback on designs, architecture, tools, and styling across sessions to iterate agent-driven apps.

Transform any folder into a professional Obsidian vault with local ML-powered curation: scaffold opinionated structure, migrate existing vaults non-destructively, cluster notes via HDBSCAN, detect duplicates and semantic gaps, generate bridge notes with a restricted LLM, and serve a privacy-first local dashboard with FSRS recommendations and anomaly detection.

Containerize apps into secure, production-grade Dockerfiles and docker-compose files, deploy zero-shot to Minikube Kubernetes with auto-generated Helm charts, build MCP servers for AI agents using FastMCP and OpenAI SDKs, generate polished React/Vue/HTML UIs and ChatGPT widgets, fetch filtered official docs for key libraries, validate skills against production criteria, and run discovery conversations to clarify intents.

Detect anti-patterns and architectural debt in Next.js, FastAPI, NestJS, Django, Express, or Go codebases. Receive tailored recommendations for GoF, SOLID, Clean Architecture, DDD, CQRS, Microservices, and Cloud patterns. Generate production-ready refactored code with detailed migration plans.

Orchestrate AI agent teams to dynamically plan multi-step Django projects with task dependencies and parallel execution, delegate implementation of models/views/serializers/admin/URLs following best practices, and validate via pytest tests, mypy checks, ruff linting, Django system checks, and migrations.

Build production-ready AI agents and multi-agent teams with the Agno framework by creating workflows and MCP integrations, adding tools, memory, debugging, and structured outputs, then deploy them via AgentOS using FastAPI.

Run three read-only code-quality audits in one command: detect unused code, identify breaking REST API changes between git revisions, and evaluate logging quality. Each skill produces a prioritized, actionable report without modifying any files.

Run production-ready Celery distributed task queues to handle async background jobs and scheduled tasks, managing workers, using Beat for scheduling, Flower for monitoring, with direct integrations into Django, Flask, or FastAPI apps.

Scaffold a production-ready FastAPI backend using async/await patterns, Mem0 for AI memory persistence, SQLAlchemy ORM with PostgreSQL database, and built-in deployment configurations.