Redis 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.

Delegates product strategy, legal/licensing, business analysis, project management, UX research, content marketing, customer success, technical sales, technical writing, and WordPress development to specialized AI agents

Accelerate LLM application development with production-ready patterns for context window management, RAG pipelines, prompt caching, observability via Langfuse, and agent architectures.

Delegate to an expert .NET architect agent to build production-grade backend APIs and enterprise apps using clean architecture, CQRS/DDD patterns, EF Core/Dapper data access, Redis caching, dependency injection, IOptions configuration, and xUnit testing for scalable, performant services.

Generate production-ready Docker Compose YAML files for multi-container applications, configuring services, networks, volumes, health checks, resource limits, dependencies, and environment overrides for dev and prod workflows.

Integrate Perplexity Sonar API for AI-powered web search with verifiable citations into Node.js/Python apps. Handle full lifecycle workflows: auth setup, error debugging, rate limiting, caching optimization, monitoring, security guardrails, CI/CD testing, and scalable deployments to Vercel/Docker.

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 .NET backends with Akka.NET actors, Aspire orchestration, EF Core patterns, concurrency primitives, and Kubernetes clustering; run integration tests via TestContainers/Playwright; optimize performance/databases; analyze CRAP scores, benchmarks, and concurrency bugs using 61 skills and 11 agents.

Implement batch processing infrastructure for REST APIs using Bull/BullMQ job queues on Redis, enabling bulk operations with async/sync processing, concurrency limits, progress tracking, partial failure handling, transaction safety, and automatic error recovery.

Generate fast (<5min) smoke test suites in Jest-style JavaScript for critical paths like system health, authentication, and core features, then run them post-deployment via Playwright, curl, Bash scripts, or CI/CD to verify UI, APIs, and functionality.

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.

Build production Clay SaaS integrations for lead enrichment: configure tables and webhooks, deploy receivers to Vercel or Docker, scale pipelines with Redis queues, secure with RBAC and PII guards, optimize costs and performance, troubleshoot failures, and monitor metrics using 30 dedicated Claude Code skills.

Automate Linear issue tracker integration in TypeScript/Node.js apps: manage full issue lifecycles, handle webhooks and GraphQL queries, optimize rate limits/performance, link to CI/CD deployments, secure auth/RBAC, sync/backup data, and debug/monitor API usage across dev/prod environments.

Automate full-lifecycle Gamma API integrations in Node.js/TypeScript apps: generate presentations from prompts/templates, handle auth/errors/rate limits/costs, add security/observability/caching, set up CI/CD/local dev/prod deployment, and migrate content—all via 24 Claude Code skills.

Implement full Customer.io integrations in Node.js/TypeScript apps: track events, send transactional emails and pushes, handle webhooks, manage segments and broadcasts, with skills for authentication, debugging errors, CI/CD deployment to AWS/GCP/Vercel/K8s, performance tuning, cost optimization, monitoring, security, reliability patterns, and load testing.

Build production Evernote API integrations in JavaScript/Node.js apps using guided skills for note CRUD/search/webhooks, OAuth auth, rate limit handling, error debugging, data migration/sync, CI/CD pipelines, Docker/cloud deployments (AWS/GCP/K8s), monitoring/security, and performance optimization.

Build .NET applications that provision Azure infrastructure (databases, caches, bots), integrate AI services (agents, OpenAI, voice, document intelligence, search), manage events/messaging (Event Grid, Hubs, Service Bus), authenticate via Entra ID, and handle Key Vault cryptography using official SDKs and ARM clients.

Implement event-driven APIs by generating publishers and subscribers that integrate with message brokers, webhooks, and Server-Sent Events, handling retries, dead-letter queues, and event schemas for scalable microservices and distributed systems using Redis, PostgreSQL, MongoDB, and AWS in Node.js or Python.

Implement multi-level API caching strategies using Redis for server-side storage, CDNs for edge caching, and HTTP headers for browser control, with TTL settings, tag-based invalidation, cache-aside patterns, and stale-while-revalidate to optimize performance across Node, Python, and Java backends.

Provision and manage isolated test environments using Docker Compose and Testcontainers for databases, caches, queues like PostgreSQL, MySQL, Redis, DynamoDB. Generate docker-compose files, env vars, seed data scripts, startup scripts, and cleanup code to enable reliable, reproducible testing without local setup conflicts.

Build production BambooHR API integrations for employee CRUD, directory syncs, time off management, reports, webhooks, and benefits; automate auth setup, CI/CD testing, rate limiting, performance optimization with caching, security hardening, and deployments to Vercel, AWS, GCP.

Integrate production-grade Exa neural search into Node.js/TypeScript apps across the full lifecycle: install SDK with auth, configure multi-env setups and caching, secure with guardrails and RBAC, optimize performance/costs/reliability, add monitoring/observability, deploy to Vercel/Docker/Cloud Run, set up CI/CD tests, and troubleshoot incidents via 30 targeted skills.

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.

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.

Implement multi-tier database caching using Redis for L2 distributed cache, in-memory L1 cache, and CDN layers with cache-aside and write-through patterns, TTLs, and invalidation strategies to reduce database load and boost read performance for PostgreSQL and MySQL setups.

Automate database testing workflows by generating test suites with data factories, transaction wrappers for automatic rollback, schema validation, assertions, cleanup, fixtures, migrations, integrity checks, and performance monitoring across PostgreSQL, MySQL, MongoDB, SQLite, Redis using Prisma, Drizzle, Jest, Pytest.

Build production-ready GraphQL servers using schema-first design, auto-generating optimized resolvers with DataLoader, WebSocket subscriptions, field-level authorization, types, and tests for Node.js or Python backends.

Run integration test suites for APIs, databases, services, queues, and files using real Dockerized dependencies without mocks. Automates full workflow: environment setup, database seeding, service orchestration, test execution with coverage reporting, and teardown cleanup. Select suites and configure environments via CLI flags.

Design and optimize NoSQL data models for MongoDB, DynamoDB, Redis, and Cassandra by analyzing access patterns, embedding vs referencing, denormalization trade-offs, sharding keys, and indexes.

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.

Analyze caching implementations for Redis, Memcached, and in-memory stores to detect inefficiencies in hit rates, TTLs, key designs, and invalidation policies, then generate optimization reports with actionable code examples to resolve performance bottlenecks.

Deploy, scale, manage, and optimize full-stack apps on Fly.io: from hello-world launches and GitHub Actions CI/CD to multi-region architectures, Postgres/Redis clusters, performance tuning, cost optimization, security hardening, error diagnosis, and Machines API scripting.

Build, debug, secure, deploy, monitor, and scale HubSpot CRM API integrations using 30 specialized skills for authentication, workflows, webhooks, rate limiting, error diagnosis, CI/CD pipelines, performance tuning, and enterprise patterns in Node.js/TypeScript projects.

Integrate SerpApi into Python and Node.js/TypeScript apps to extract structured search data from Google, Bing, YouTube, Shopping, News, and Maps. Automate setup, auth, cost-free local testing with pytest/Vitest fixtures, Redis caching, rate limiting, proxy deployment to Vercel/GCP/Fly.io, security hardening, production checklists, SEO monitoring, and legacy migrations via 18 Claude Code skills.

Accelerate Intercom API integrations in Node.js/TypeScript apps by generating code for contacts/conversations management, webhook/event handling, auth setup, CI/CD pipelines, local testing, production checklists, security hardening, rate limit retries, performance caching, observability instrumentation, cost optimization, data migrations, and incident response runbooks.

Build production Klaviyo email/SMS integrations in Node.js/TypeScript apps by generating SDK workflows for customer profiles, event tracking, campaigns/flows, webhooks; automate CI/CD pipelines, auth/security hardening, error debugging, performance/cost tuning, monitoring, migrations, and incident response.

Build production ElevenLabs voice AI apps with Claude Code skills: integrate TTS/voice cloning/STT, debug API errors, optimize costs/latency/rate limits, secure keys/webhooks, deploy to Vercel/Fly/Cloud Run, set up CI/CD with mocked tests, and generate reference architectures.

Develop full OneNote Graph API integrations in Python or TypeScript: perform CRUD on notebooks, sections, and pages; set up MSAL auth; debug errors and generate diagnostics; optimize for rate limits and performance; configure CI/CD pipelines, local mocks, Docker/K8s deployments, and production checklists.

Build production Webflow Data API v2 integrations in TypeScript/Node.js: manage CMS collections/items/ecommerce, handle webhooks/events, configure GitHub Actions CI/CD/testing, deploy to Vercel/GCP/Fly.io, secure with OAuth/RBAC/tokens, monitor costs/performance/rate limits, migrate data, and upgrade SDKs.

Debug Buttercup CRS deployments on Kubernetes by triaging pod crashes, restart loops, Redis failures, DinD issues, queues, and service problems in the crs namespace using kubectl events and logs.

Design scalable backend architectures including REST/GraphQL/OpenAPI APIs, server-side logic, database schemas with indexing and Redis caching, OAuth authentication/security, and microservices.

Rapidly initialize and configure new projects using slash commands that modernize dependencies for Node/Python/PHP, set up complete dev environments with Docker/VSCode/Git, configure linting/formatting for JS/TS/Python/Java, scaffold monorepos with pnpm/Turborepo, and implement Express rate limiting with Redis.

Accelerate Java Spring Boot development by generating CRUD apps, REST APIs, and AI integrations with LangChain4j; write unit/integration tests; integrate AWS services like RDS, DynamoDB, S3, Lambda; refactor code, audit security/dependencies, and produce documentation/architecture reviews via agents, commands, skills, and LSP support.

Architect scalable backend systems by designing REST/GraphQL APIs with OpenAPI specs, implementing server-side logic, creating database schemas with indexing and Redis caching, setting up secure OAuth authentication, and planning microservices.

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.

Architect scalable backend systems using a specialized AI agent: design REST/GraphQL/OpenAPI APIs with authentication and rate limiting, optimize database schemas via indexing and Redis caching, implement secure OAuth flows, build server-side logic, and structure microservices for robustness and performance.

Generate production-ready AWS CloudFormation templates for VPCs, EC2, ECS, RDS, DynamoDB, Lambda, S3, CloudFront, ElastiCache, Bedrock, and security groups; deploy ECS services via GitHub Actions CI/CD; bootstrap SAM projects; create Draw.io architecture diagrams; automate AWS CLI workflows; optimize costs; and review designs with expert agents.

Optimize PostgreSQL, MySQL, MongoDB, and Redis performance for enterprise B2B SaaS and multi-tenant platforms by tuning queries, designing indexing strategies, configuring connection pooling, implementing scaling solutions, and setting up monitoring workflows.

Design and implement internal API architectures for B2B applications, including REST and GraphQL schemas, SDKs, documentation, developer portals, performance optimization, versioning strategies, and service communication workflows.

Orchestrate multi-session, multi-agent campaigns with persistent state, intent routing, and autonomous quality loops — decompose large work into phases, delegate to sub-agents, and maintain context across sessions.

Design and implement internal API architecture, developer experience, and infrastructure for B2B applications using REST and GraphQL. Generate API documentation, SDKs, and developer portals while optimizing performance, managing versioning strategies, and enabling internal service communication.

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.

Architect scalable backend systems with an AI agent: design REST/GraphQL/OpenAPI APIs, database schemas with indexing and Redis caching, secure OAuth authentication, server-side logic, and microservices.

Design and implement internal API architecture, developer experience, and infrastructure for B2B applications. Create REST and GraphQL APIs, generate documentation and SDKs, build developer portals, optimize performance, manage versioning, and enable internal service communication.

Optimize database performance for enterprise B2B SaaS and multi-tenant platforms by tuning queries, implementing indexing strategies, connection pooling, scaling, and monitoring setups tailored for PostgreSQL, MySQL, MongoDB, and Redis.

Optimize PostgreSQL, MySQL, MongoDB, and Redis performance for enterprise B2B SaaS and multi-tenant platforms by tuning queries, implementing indexing strategies, configuring connection pooling, and planning scaling with monitoring.

Implement secure session management in Node.js/Express apps using JWT tokens stored in Redis, with refresh token flows and secure cookie configuration for handling user authentication, sessions, and logout.

Secure Express APIs in Node.js with token bucket, sliding window, or Redis-based rate limiting middleware to protect public endpoints from abuse, enforce tiered access controls, and prevent DoS attacks.

Implement idempotent API operations in Node.js using idempotency keys, Redis for response caching, and PostgreSQL constraints to safely retry payments, webhooks, and avoid duplicate processing or race conditions.

Build scalable real-time WebSocket servers in Node.js with Socket.IO, using Redis adapter for horizontal scaling across multiple instances, JWT authentication for secure connections, room-based messaging for group communication, user presence tracking, and a ready-to-use JavaScript client class to integrate into chat apps, live notifications, or collaborative tools.

Integrate Vercel KV (Redis-compatible via Upstash) into Next.js apps to implement caching, user sessions, rate limiting, and TTL-expiring data storage. Use atomic operations like incr/setnx, pipelines for efficiency, and best practices for error handling including KV_REST_API_URL issues and JSON serialization.

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.

Scaffolds production-grade .NET Clean Architecture solutions with CQRS, DDD entities, EF Core mappings, authentication, authorization, pipeline behaviors, background jobs, email sending, health checks, structured logging, rate limiting, and comprehensive testing (xUnit, integration with Testcontainers).

Route complex software engineering tasks to specialized Haiku/Sonnet subagents orchestrated by a managing agent, reducing API costs by ~50% while automating code review, security scanning, git operations, environment preflights, dependency analysis, documentation, and testing.

Deploy any GitHub project to Sealos Cloud with one command, managing cloud databases, S3 storage, and Docker artifacts while assessing cloud-native readiness and building Sealos Desktop apps.

Provides skills for setting up Docker-based local development environments and deploying to production, including generating Docker Compose configurations, managing Laravel-specific workflows, creating design systems, and maintaining project documentation.

Audits, generates, and refactors PHP applications using DDD, CQRS, Event Sourcing, Clean/Hexagonal Architecture, and GoF patterns. Provides CI/CD pipeline analysis, Docker optimization, security reviews, and architectural documentation for PHP projects.

Delegate database engineering to AI agents that design schemas with normalization, indexing, and migrations; optimize SQL queries through execution plans, rewrites, and parameter tuning; and engineer reliability via replication, backups, high availability, monitoring, and failover for PostgreSQL, MySQL, SQLite, MongoDB, Redis, Prisma, and Drizzle.

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.

Validate, curate, audit, and filter chemical structures for QSAR/ML drug discovery workflows using ChemAudit tools. Batch process SMILES/InChI/CSV/SDF files, standardize with ChEMBL-compatible pipelines and provenance tracking, detect dataset issues like contradictions and parse errors, filter generative outputs with REINVENT scorers, and lookup/resolve across PubChem, ChEMBL, COCONUT, Wikidata, SureChEMBL.

Build production-grade Ruby on Rails apps using MVC controller patterns for routing, filters, and REST APIs; optimize Active Record models with associations, queries, validations, and scopes; add reactivity with Hotwire Turbo Drive/Frames/Streams, Stimulus, and ActionCable over Redis.

Build and deploy Python MCP servers to expose custom tools, resources, and prompts to LLMs like Claude. Configure storage backends with memory, disk, Redis, or DynamoDB options. Integrate OAuth proxy for secure access and handle cloud deployment, lifespan management, middleware, circular imports, and async errors.

Delegate specialized Laravel tasks to Claude Code agents and skills: architect scalable apps, model Eloquent schemas and optimize queries, design REST APIs with auth and resources, review code quality and security, debug issues, tune performance via caching and queues, write Pest tests with TDD, implement notifications and scheduling, and generate docs.

Deploy, manage, and troubleshoot full-stack applications on Zeabur via CLI, covering project creation, database provisioning, domain management, template publishing, environment variables, logs, and container debugging.

Design, optimize, and implement enterprise GraphQL APIs: craft schemas, federate with Apollo, optimize queries via DataLoader patterns, harden security, manage subscriptions over WebSockets, integrate microservices, and leverage Redis for caching.

Monitor system health, optimize performance, manage scaling and capacity, control costs, ensure security/compliance, and handle disaster recovery for app stacks using an AI agent targeting Kubernetes, Docker, AWS, Redis, and PostgreSQL environments.

Generate complete docker-compose.yml files with pre-configured services for PostgreSQL, Redis, MongoDB, MySQL, and Elasticsearch, including environment variables, networking, volumes, and health checks to spin up local multi-service environments instantly.

Implement rate limiting for APIs using token bucket, sliding window, or fixed window algorithms, with Redis for distributed enforcement across services, DDoS protection, and IP-based filtering to secure your applications.

Deploy, debug, monitor, and migrate applications on Render cloud platform. Automatically generate Blueprint YAML from codebases, troubleshoot deployment failures, provision databases and workers, and migrate Heroku apps—all with deep integration for diagnostics and infrastructure as code.

Delegate high-performance game development to AI experts: implement Unity ECS/DOTS/Burst patterns in C#, Godot 4 GDScript architecture/signals/state machines, and Minecraft Bukkit/Spigot plugins with Java APIs, player/world management, databases, performance tweaks, and Docker.

Implement and optimize caching strategies in high-performance apps by consulting an expert on Redis patterns, cache invalidation, TTL management, distributed caching, CDN integration, and HTTP cache headers.

Delegate SDLC workflows to specialist AI agents that architect cloud-native systems, design databases, conduct deep web research, optimize performance and observability, distill repo knowledge, and build production agents via orchestrated pipelines.

Delegate SDLC tasks to 14 specialized AI agents that design multi-agent architectures, engineer prompts and RAG systems, orchestrate workflows, optimize LLM infrastructure, handle AI DevOps, testing, and quality assurance for production-ready AI/ML applications.

Activate zero-config Godmode in Claude Code to invoke 126 skills and 7 subagents that autonomously plan features, generate code/tests/docs, audit security/performance/accessibility, optimize via git worktrees, and orchestrate full-cycle dev workflows from ideation to deployment.

Delegate secure webhook integration in TypeScript/Node apps to an expert agent that designs endpoints, verifies HMAC signatures, implements exponential backoff retries, handles idempotency with Redis, and enables testing via ngrok.

Reduce token usage and costs in Claude Code by compressing large codebases and documents into compact, citation-rich context packets using hybrid RAG retrieval (BM25 + vector search), AST-aware chunking, and reranking.

Dockerize Node/Python/PHP/Go apps by generating optimized multi-stage Dockerfiles, docker-compose.yaml, .dockerignore, and .env files; provision secure, persistent PostgreSQL/MySQL/MongoDB/Redis containers with health checks; configure SSL/TLS proxies via Traefik or Nginx; diagnose and fix container failures, networking, permissions, and port issues using logs and docs.

Bootstrap Spring Boot projects from scratch with Maven/Gradle, generate full CRUD REST APIs with entities/services/tests, configure Redis caching, JWT/OAuth security, Resilience4J patterns, JPA optimizations, OpenAPI docs, logging best practices, and Spring AI integrations. Review code via skills/agent, scan routes, and start apps locally.

Adds Laravel-specific skills for test-driven development with Pest/PHPUnit, safe migrations, queue management, quality checks (Pint, Insights), and architecture patterns (DTOs, Form Requests, Actions). Works with Sail and non-Sail environments, includes Blade component patterns, API resources, and Playwright E2E testing.

Manage and troubleshoot Laravel Docker development environments with docker-local CLI expertise. Spin up/down services (PHP, MySQL, PostgreSQL, Redis, MinIO, Traefik), run health checks and status commands, diagnose access issues like SSL/DNS/404s via nginx logs, set up multi-project isolation, Xdebug, queues, and databases without app code changes.

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.

Guides building Go event-driven microservices with the xgodev/boost framework: boot sequence, config, logging, caching, and factories for Kafka, NATS, Pub/Sub, MongoDB, Redis, Elasticsearch, AWS, gRPC, and more.

Develop Bun projects with accurate knowledge of versions 1.2 through 1.3.10 features, including route-based HTTP servers, built-in clients for Redis, PostgreSQL, MySQL, SQLite, S3 storage integration, test runner, bundler, and package manager updates.

Load critical RHEL 10+ updates—like Valkey replacing Redis, Podman v5 with pasta networking, post-quantum crypto, ISC Kea DHCP, and stricter TLS/FIPS policies—before starting RHEL development, operations, or troubleshooting to handle breaking changes effectively.

Set up Laravel Reverb WebSockets, broadcast events, configure Echo clients for JavaScript apps including React and Vue, integrate real-time notifications in Filament panels, troubleshoot connections, and deploy to production.