Redis plugins

Scaffold and develop production-ready Python projects with FastAPI, Django, async patterns, type safety, testing, and observability. Includes code generation, linting, profiling, packaging, and deployment guidance.

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.

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.

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.

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.

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.

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

Implement production-grade .NET patterns and practices for Akka.NET actor systems, ASP.NET Core, EF Core, Blazor, .NET Aspire, testing with xUnit/Playwright/TestContainers, CI/CD optimization, API design, and performance profiling via specialized Claude Code skills and agents.

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

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Build, analyze, and ship .NET 10 applications with architecture guidance, code generation, automated cleanup, testing, security scanning, and deployment pipelines — all within Claude Code.

Provides 193+ expert skills for every major Azure service—compute, data, AI/ML, networking, security, and management—delivering troubleshooting, architecture guidance, deployment patterns, and best practices directly in your development workflow.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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

Deploy any local or GitHub project to Sealos Cloud with a single command, including automatic cloud-native readiness assessment, Dockerfile generation, and container orchestration template creation. Manage cloud databases (PostgreSQL, MySQL, MongoDB, Redis), S3 object storage, and build Sealos Desktop apps — all from within Claude.

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.

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.

Audit PHP codebases for DDD, CQRS, Event Sourcing, and Clean/Hexagonal architecture compliance; generate domain-driven components, GoF patterns, Docker configurations, and CI/CD pipelines; and perform security, performance, and code quality reviews.

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.

Manage the full lifecycle of cloud applications on Zeabur: deploy projects, databases, and templates; rent and SSH into dedicated servers; configure DNS, domains, and email; monitor performance; and debug deployment issues—all from the CLI.

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.

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.

Manage the full lifecycle of applications on the Render cloud platform: deploy from Git or Docker, generate and validate Blueprint infrastructure, monitor real-time service health, debug failures, migrate from Heroku, and configure databases, private networking, custom domains, cron jobs, background workers, and static sites. Also includes MCP integration and git hooks for commit policy enforcement.

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.

Optimizes Claude Code interactions by reducing token usage and costs through hybrid retrieval (BM25 + vector search) and summarization, compressing large codebases into compact context packets while preserving key information for reasoning.

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.

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.

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.

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.

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.

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.

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.

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.

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.