Fastapi plugins

Modern Python development with 3.12+, async patterns, FastAPI/Django scaffolding, testing, packaging, and production best practices including observability, resilience, and code quality tooling

Orchestrates end-to-end full-stack feature development with specialized agents for architecture, implementation, testing, security, performance, and deployment, using an API-first approach and interactive checkpoints.

Develop production-ready Python backends with async patterns, modern frameworks (FastAPI, Django), and best practices for architecture, testing, and performance.

Build FastAPI APIs following best practices for Pydantic models, dependency injection, and streaming (SSE, JSON Lines, bytes). Keep code clean and up to date with the latest FastAPI features, including serving frontend applications.

Scaffolds production-ready REST and GraphQL APIs with framework selection (FastAPI, Django), async patterns, dependency injection, microservices architecture, and scalable backend design.

Generate mock REST APIs with configurable latency and scenarios for development and testing, then produce OpenAPI 3.1 documentation and interactive developer portals from those APIs

Build production-ready Python backends with async patterns, FastAPI/Django architecture, testing strategies, and modern tooling (uv, ruff, pydantic). Guides framework selection, project structure, and performance optimization for Python 3.12+ applications. Includes async web APIs, microservices, real-time systems, and TDD workflows.

Design, build, and document production-ready Python APIs with FastAPI and Django, including async patterns, OpenAPI spec generation, Pydantic models, and testing strategies.

Build, integrate, and debug AI-powered chat and agent features in CopilotKit projects, from setup to production across frontend and backend.

Scaffold production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling for new backend APIs.

De-identify PHI, extract clinical named entities, map to FHIR R4 and OMOP CDM, run compliance audits, and evaluate model fairness—all on-device.

Autonomous multi-agent development framework that orchestrates spec-driven sprints: agents plan, implement, test, and review code in parallel across frontend, backend, and CI/CD, converging on a finished feature without manual handoffs.

Build Python applications on Azure using SDK best practices across AI, storage, identity, messaging, monitoring, and management — including agents, content safety, translation, vision, speech, Cosmos DB, Event Hubs, Service Bus, Key Vault, and OpenTelemetry instrumentation.

Develop, deploy, and maintain Anthropic Claude API integrations across the full lifecycle: setup, coding patterns, streaming, tool use, cost optimization, security, monitoring, CI/CD, and production deployment.

Manage OpenRouter as an LLM gateway with 30 skills covering multi-model routing, fallback configuration, cost controls, caching, PII redaction, audit logging, rate limiting, production readiness validation, and usage analytics

Generate fullstack project scaffolds with React frontend, Express or FastAPI backend, PostgreSQL database, authentication, Docker, and CI/CD setup. Includes AI agents for API design, database schema, deployment, React expertise, and accessibility.

Add configurable rate limiting to API endpoints using token bucket, sliding window, or fixed window algorithms with Redis for distributed state management across Node.js, Python/FastAPI, and Java backends

Accelerate building and operating production LangChain 1.0 and LangGraph 1.0 Python applications with battle-tested patterns for chains, agents, RAG, streaming, HITL, middleware, monitoring, security, and deployment.

Generate production-ready WebSocket servers with Socket.IO or native WebSocket, including room management, authentication, broadcasting, presence tracking, and Redis-backed scaling for real-time applications.

Generate production-ready webhook endpoints with HMAC signature verification, idempotency checks, retry handling, and event routing for services like Stripe, GitHub, and Twilio, with integrated monitoring setup.

Implement standardized API error handling with RFC 7807 responses, custom error classes, middleware, and logging across multiple backends (Node.js, Python, Java, Go).

Protect backend services from overload by implementing API throttling with token bucket and sliding window algorithms, concurrency limits, circuit breakers, priority queues, and adaptive controls, including rate limit storage, middleware, usage tracking, and a management API for dynamic rate limits and quota management.

Generate production-ready REST APIs from OpenAPI specs or schemas, with CRUD endpoints, pagination, filtering, authentication, validation, and test scaffolding for Express, FastAPI, Spring Boot, Gin, and NestJS.

Build, debug, and optimize data transformation DAGs using the Hamilton framework. Supports decorator-based pipelines, testing, scaling with Spark/Ray/async, LLM/AI workflows, and observability via the Hamilton UI.

Generate structured Markdown API reference documentation by scanning your source code and route definitions, automatically detecting the API framework (Express, FastAPI, Django, Spring Boot), and extracting endpoints, methods, parameters, schemas, and authentication details.

Python development kit for building backend applications with Clean Architecture/DDD, code review/refactoring, security auditing, and AWS Lambda deployment, enhanced by Pylsp and Pyright LSPs.

Write, test, profile, and publish Python code with async patterns, pytest, ruff, and performance tools. Agents handle code review, bottleneck analysis, and packaging to PyPI.

Orchestrate full-stack AI development with 281 skills, 71 agents, and 112 hooks: build React/Next.js UIs, FastAPI backends, LangGraph AI workflows, manage databases, deploy to Kubernetes, run security audits, generate tests, create demo videos, and coordinate multi-agent pipelines across git worktrees.

Enforces a structured 5-phase dev workflow (plan → tests → implementation → review → advance) with explicit phase gates and session-aware context tracking. Automatically retrieves and injects relevant coding rules via hybrid RAG. Keeps every coding step traceable and compliant with project specs.

Manage Polar payment processor's local development environment with Docker (FastAPI, Next.js, PostgreSQL, Redis) and reference billing entities, Stripe integration, subscription lifecycle, and checkout flows.

Build and manage Microsoft Teams bots by scaffolding TypeScript, C#, or Python code, configuring Azure infrastructure and SSO, and troubleshooting bot deployments.

Accelerate development workflows with a comprehensive Claude Code harness: 35 skills, 12 agents, and commands for spec generation, TDD, multi-agent orchestration, code review, documentation, and automated git/PR workflows. Supports React, TypeScript, Python, FastAPI, Tailwind, and more with quality gates and context optimization.

Harden REST APIs by adding authentication, rate limiting, input validation, and security headers to Express or FastAPI applications, with Nginx configuration examples and audit checklists.

Validate OpenAPI, Swagger, and GraphQL schemas against backend implementations (Express, FastAPI, Django), detect breaking changes, and generate TypeScript client code from your API specifications.

Apply REST and GraphQL API design principles when designing new APIs, reviewing specifications, refactoring, setting standards, or documenting to build intuitive, scalable, and maintainable APIs.

Deploy and manage production recommendation systems with integrated feature stores, caching, A/B testing, and monitoring for low-latency personalization APIs.

Deploy ML models to production using FastAPI for serving, Docker for containerization, and Kubernetes for orchestration, with built-in support for monitoring, drift detection, health checks, and version conflict resolution.

Automates content creation, publishing to platforms like Substack, X, and 知识星球, and security scanning for Next.js and Python projects, while enhancing developer workflows with session management and interactive UI components.

Accelerates production LLM system development with LangGraph agent workflows, RAG retrieval evaluation, prompt optimization, and AI backend service scaffolding from reference templates.

Build high-performance FastAPI backends with expert-level patterns for async routing, dependency injection, and Pydantic v2 validation, including async database operations with PostgreSQL and MongoDB.

Provides 70+ slash commands organized across 12 development phases, with specialized agents for Rust, Python, Go, JavaScript, Bash, FastAPI, documentation, performance analysis, real-time systems, and subagent creation, plus a Dagger-based safety system and multi-dimensional validation.

Accept stablecoin payments (USDT/USDC on Arbitrum) via KryptoGO Payment — create payment intents, process checkouts with React SDK or Direct API, query transaction status, handle webhook callbacks, and execute token transfers and withdrawals.

Lets developers architect software and design UI/UX from first principles, enabling genuinely new solutions rather than derivative work. Useful for feature design, app architecture, brainstorming, design reviews, and strategy discussions.

Manage the full API lifecycle from Claude Code: sync Postman collections, generate OpenAPI specs from codebases, run test suites, create mock servers, audit security against OWASP Top 10, and evaluate AI agent compatibility.

Generates and implements prioritized security hardening specs for backend services, covering auth patterns, security headers, rate limiting, input validation, secrets management, and dependency hygiene.

Design APIs, generate system architectures, fix performance bottlenecks, audit backend codebases, and scaffold production-ready services with Docker and structured logging.

Designs complete API specifications including endpoints, request/response shapes, error codes, auth patterns, and pagination, following Stripe's consistency principles. Use when asked to design an API, build endpoints, or create a REST API.

Provides a disciplined workflow for Python application development: from requirements discovery and domain modeling through implementation, TDD, code review, and PR management. Comes with specialized skills for FastAPI, SQLAlchemy, Temporal, Python 3.10+ patterns, and monorepo configuration.

Receive and verify Sanity GROQ-powered webhooks with signature verification, handling document create/update/delete events for cache revalidation and search reindexing.

Receive and verify Uber Eats webhooks with HMAC-SHA256 signature validation, handling order events like orders.notification, orders.cancel, and store status changes.

Receive and verify Polar webhooks with Standard Webhooks signature verification, including code snippets for Node.js and Python and examples for Express, Next.js, and FastAPI

Auto-derives codebase conventions from repo analysis and injects archetype-aware guidance into AI-generated code, enforcing team idioms, banned imports, and framework-specific patterns for TypeScript/JavaScript, Ruby, and Python projects.

Review Python/FastAPI backend code with automated checks for SQLAlchemy ORM patterns, PostgreSQL query optimization, pytest test quality, and type safety, using a multi-step verification protocol to eliminate false positives

Establishes opinionated Python 3.11+ engineering standards with SOLID principles, strict typing, ruff linting, pytest testing, and uv tooling. Routes tasks to specialist skills for TDD, CLI apps (Typer/Rich), web APIs (FastAPI/Django/Flask), data/science workflows, CI/CD publishing, and constrained environments.

Ship production-ready iOS apps to the App Store and TestFlight with HIG-compliant design, SwiftUI architecture guidance, performance profiling, code-signing diagnostics, and automated pre-flight checks that catch rejection risks before submission.

Streamlines Python development with automated workflows for building Django and FastAPI apps, managing SQLAlchemy databases with Alembic, writing pytest tests, debugging errors, and enforcing code quality.

Web development framework with 22 commands and 5 agents for code analysis, performance benchmarking, framework migration, documentation, testing, security review, and automated workflows across React, Vue, Angular, and backend frameworks.

Orchestrates multi-skill workflows across AI agent ecosystems, manages project governance and quality gates, builds full-stack apps with React/Next.js/FastAPI, creates generative art and design artifacts, and provides security auditing, database migrations, and CI/CD pipelines.

Enables full-stack PolicyEngine development — implementing policy reforms, running microsimulations, building dashboards, managing PRs, and validating data layers.

Manage Modal.com serverless cloud platform: deploy GPU-accelerated Python functions, configure autoscaling and scheduling, build web endpoints with FastAPI, and debug production issues.

Build modern Python applications with expert patterns for async/await, type hints, FastAPI, testing, uv packaging, and deployment to Cloudflare and Modal. Also includes OpenCV computer vision and FFmpeg video/audio processing with GPU acceleration.

Design and implement secure backends with REST/GraphQL APIs, authentication systems, and LLM integrations, while performing security reviews and hardening against OWASP Top 10 vulnerabilities.

Setup, optimize, and debug Python 3.12+ projects with expert validation and patterns, including type safety, async, web frameworks, testing, and AI/ML.

Enforces a disciplined development workflow with skills for test-driven development, structured planning, bug fixing, UI design exploration, FastAPI documentation, changelog management, and documentation syncing — all aimed at improving code quality and developer process.

Orchestrate end-to-end feature delivery across multiple repositories: discover architecture, implement backend/frontend/infra specs, review branches, assess cross-repo integration, and continuously learn from feedback. Ships full features with safety checks and audit trails.

Generates FastAPI backends with Pydantic v2 schemas, SQLAlchemy async sessions, JWT auth, and OpenAPI contracts, then manages Alembic migrations and data lineage checks.

Pull server-rendered web content from any URL into Claude Code with conditional-GET caching, then search, read, and index documentation sources without a browser or API keys.

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.

Build, optimize, and deploy production AI pipelines with DSPy using 95 skills covering the full lifecycle: signatures, LM configuration, data handling, evaluation, optimization, retrieval, adapters, tools, and deployment.

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.

Develop production-ready Python backends with Django, FastAPI, and async patterns, supported by modern tooling for testing, observability, and package management.

Provides Python backend specialists for Django, FastAPI, FastMCP, and Celery development with code quality enforcement, security auditing, and parallelization readiness analysis

Build and configure Litestar web applications with opinionated patterns for routing, DTOs, authentication, dependency injection, HTMX, Inertia.js, real-time features, API endpoints exposed as MCP tools, background task queues (SAQ, Litestar QueuePlugin), and production deployment on Docker, Kubernetes, or Cloud Run

Orchestrate autonomous multi-agent development sprints from spec files: plan, spawn parallel implementation agents (frontend, backend, CI/CD), run automated QA, and finalize with UI testing.

Access patterns, best practices, and domain knowledge for 19 technology stacks spanning backend (Django, FastAPI, Go, Rails, .NET, Spring Boot, NestJS, Laravel, Rust), frontend (React, Next.js, Vue, Angular, Nuxt), mobile (Flutter, React Native), and infrastructure (Docker, Kubernetes, Terraform).

Generates a comprehensive skill set for building a secure, animated JARVIS-style AI assistant desktop app with Tauri, Vue 3, and GSAP, covering frontend HUD animations, backend APIs, database management, CI/CD, and security hardening.

Build production-ready FastAPI backends with MongoDB/Beanie ODM, Keycloak auth, Redis caching, background tasks (ARQ/Celery), WebSocket real-time features, Docker/K8s deployment, and observability (Prometheus/OpenTelemetry). Includes project scaffolding, CRUD generation, migration management, and security auditing.

Build and explore cross-domain knowledge graphs from document corpora, with pre-built domains for drug discovery, contract analysis, clinical trials, and FDA product labels. Includes an interactive workbench for graph visualization, conversational Q&A, and epistemic analysis.

Build and orchestrate multi-agent systems using Google's A2A protocol: create Agent Cards, manage task lifecycles, handle streaming and push notifications, implement authentication, and integrate with frameworks like LangGraph and CrewAI.

Implement the Agentic Commerce Protocol (ACP) for AI-agent-mediated commerce, including checkout sessions, delegated payments via Stripe SharedPaymentTokens, product feed generation, order lifecycle management, fulfillment options, discount handling, affiliate attribution, and merchant server scaffolding in Python, TypeScript, or Go.

Transform any folder into a professional Obsidian vault with automated scaffolding, semantic organization, duplicate detection, bridge-note generation, and a local ML-powered dashboard for temporal insights and recommendations. All operations are 100% local, privacy-first, and conducted in Portuguese.

Fetch and index documentation from any URL into Claude Code, with conditional-GET caching and searchable access via MCP tools. Supports fast-moving libraries like Next.js, FastAPI, LangChain, and React, enabling grounded answers with source citations.

Build and debug autonomous AI agents using the Anthropic Claude Agent SDK for Python and TypeScript, with support for custom tools, hooks, MCP integration, and type-safe streaming queries.

Audit code quality across three dimensions: find unused code, detect breaking REST API changes between git revisions, and evaluate logging quality — all read-only, producing prioritized reports.

Analyze codebases for anti-patterns and architectural debt, then generate production-ready refactored code with migration plans using GoF, SOLID, DDD, CQRS, and cloud patterns.

Audit APIs for OWASP Top 10 vulnerabilities and generate safe, reversible database migrations with up/down functions for Knex.js, TypeORM, Prisma, or Sequelize, coordinated by a backend lead agent that unifies API design, database strategy, security, and scalability decisions.

Orchestrates a team of specialized builder and validator agents to implement Django projects from engineering plans, with automated task delegation and parallel execution through a queue system

Build and deploy production-ready AI agents, multi-agent teams, and workflows using the Agno framework, with built-in support for MCP integrations, debugging, tools, memory, and structured outputs via AgentOS (FastAPI).

Manage the full Domino Data Lab lifecycle from Claude: create projects, run batch jobs and Spark/Ray/Dask clusters, deploy web apps and model APIs, track MLflow experiments, trace GenAI apps, configure compute environments and workspaces, and automate workflows via SDK or MCP.

Accelerates full-stack development with specialized agents for backend, frontend, AI/ML, and architecture, plus commands for database design, API docs, build fixing, git workflow, and deployment.

Enforces Clean Architecture in Python/FastAPI projects with layered scaffolding, design rule scanning, code smell detection, and automated refactoring plans. Scaffolds endpoints, reviews REST APIs, generates stub-based tests, and teaches Pythonic patterns.

Scaffold production-ready full-stack projects with FastAPI backends, React/Vite frontends, and Terraform/Ansible/Kubernetes infrastructure, including Docker, CI/CD pipelines, and multi-cloud IaC.

Build web applications where an AI agent dynamically generates HTML UI using hexagonal/ports-and-adapters architecture with HTMX for interactivity and MCP tools for data operations, with persistent feedback across sessions.

Build multimodal AI applications with Pixeltable's declarative data infrastructure: define tables with computed columns for chunking, embedding, retrieval, and tool-calling, and integrate with 25+ AI providers.

Run 60+ application security scans across 8 threat-modeling frameworks (OWASP Top 10, STRIDE, PASTA, LINDDUN, MITRE ATT&CK, SANS/CWE, DREAD, OWASP API Top 10), simulate red-team attacks with 6 attacker personas, and generate prioritized remediation reports with fix verification.

Install OpenRAG and integrate its SDK into Python or TypeScript applications for chat, search, and document management workflows.