Database

Redis Pub/Sub messaging patterns for real-time event broadcasting

Redis Sentinel and Cluster configurations for high availability and horizontal scaling

Redis Streams for durable event processing with consumer groups

Craft clear, accurate, and user-friendly API documentation that empowers developers to integrate with your services quickly and efficiently. This skill covers structuring content, providing executable examples, and maintaining accuracy. Activate this skill when you are designing or updating documentation for a new or existing API, or when seeking to improve developer experience and adoption.

Architect and implement robust API Gateway patterns to manage, secure, and scale your microservices APIs effectively. This skill guides you through crucial patterns like BFF, API Composition, and Caching, enabling you to optimize client-server interactions and enhance operational resilience. Activate this skill when designing a new API architecture, optimizing an existing microservices gateway, or addressing challenges related to API security, performance, or service orchestration.

Effectively implement and manage robust API monitoring strategies to ensure the availability, performance, and correctness of your API integrations. This skill guides you through proactive detection, deep diagnostics, and actionable alerting across your API ecosystem. Activate this skill when designing new API architectures, troubleshooting existing integrations, or optimizing the reliability and user experience of your services.

Master strategies for interacting with external APIs while respecting their rate limits, ensuring your applications remain compliant and robust. This skill teaches you how to prevent `429 Too Many Requests` errors, implement intelligent retry mechanisms, and optimize your API consumption. Activate this skill when you are integrating with third-party APIs, designing resilient data pipelines, or troubleshooting connection stability issues due to excessive requests.

Master the principles and practices for securing your APIs against common threats, ensuring data integrity, confidentiality, and availability. This skill guides you in implementing robust authentication, authorization, and data protection mechanisms. Activate this skill whenever you are designing, developing, or auditing an API, or when assessing potential vulnerabilities in existing integrations.

Master the comprehensive validation of API functionality, reliability, performance, and security. This skill covers strategic approaches to ensure your APIs consistently meet their contractual obligations and provide a robust integration experience. Activate this skill when developing new APIs, integrating third-party services, diagnosing API issues, or establishing continuous quality assurance for your microservices.

Strategically manage the evolution of your APIs to introduce new features, refactor endpoints, and deprecate old functionality without breaking existing client integrations. This skill teaches various versioning strategies and how to apply them to maintain stability and foster long-term API adoption. Activate this skill whenever you plan to make non-backward-compatible changes to an API, need to support multiple client versions, or are defining your API's lifecycle management.

Design and implement robust, informative, and developer-friendly error handling mechanisms for APIs. This skill teaches you how to craft predictable error responses that empower API consumers to diagnose issues and build resilient integrations. Activate this skill when architecting new API endpoints, refactoring existing error responses, or troubleshooting common integration failures caused by unclear error communication.

Design robust, intuitive, and performant GraphQL schemas that empower clients to request precisely the data they need. This skill covers type system modeling, query and mutation design, and strategies for schema evolution. Activate this skill when you are architecting a new GraphQL API, refactoring an existing schema, or need guidance on evolving your API while maintaining backward compatibility.

Master the common interaction models, service design strategies, and robust error handling mechanisms essential for building high-performance, resilient gRPC services. This skill equips you to select the appropriate RPC style, manage stream lifecycles, and design idiomatic gRPC APIs. Activate this skill when architecting new gRPC-based microservices, refactoring existing gRPC endpoints, or integrating complex systems using Protocol Buffers.

Master the various OAuth 2.0 authorization flows to securely delegate access from a resource owner to a client application. This skill guides you in selecting the appropriate flow for different application types and implementing robust token management strategies. Activate this skill when designing or integrating with APIs requiring delegated authorization, securing client applications, or enhancing your understanding of modern authentication protocols.

Master the creation and interpretation of OpenAPI Specification documents to design, document, and automate your API workflows. This skill teaches you to define robust API contracts, leverage tooling for code generation and validation, and foster seamless integration across development teams. Activate this skill when you are architecting a new RESTful API, documenting an existing one, or integrating with external services using their OpenAPI definitions.

Design robust, scalable, and developer-friendly RESTful APIs that adhere to industry best practices and architectural principles. This skill covers resource modeling, HTTP method usage, versioning strategies, error handling, and security considerations. Activate this skill when you are planning a new API, reviewing an existing API's architecture, or need guidance on evolving an API for future needs.

Design intuitive, robust, and idiomatic SDKs that abstract API complexity and accelerate developer integration. This skill focuses on language-specific conventions, comprehensive error handling, and lifecycle management for seamless API consumption. Activate this skill when you are architecting a new client library, refactoring an existing SDK, or need to provide guidance on best practices for API consumers.

Master the design, implementation, and management of robust webhook systems for real-time, event-driven communication. This skill covers secure payload design, reliable delivery mechanisms, and best practices for integrating services asynchronously. Activate this skill when you are architecting event-driven APIs, integrating with third-party platforms, or building reactive, decoupled microservices.

Design robust, scalable, and efficient real-time communication systems using WebSockets. This skill covers message protocol design, connection management, and strategies for scaling persistent connections. Activate this skill when you are architecting new real-time features, improving existing WebSocket implementations, or need guidance on building high-performance, bi-directional communication channels.

Securing MCP servers with authentication, authorization, and defensive practices. Covers OAuth 2.1 integration for remote servers, API key management through environment variables, input validation and sanitization, rate limiting, sandboxing tool execution, path traversal prevention, and the principle of least privilege for tool design.

Deploying MCP servers across different environments and transports. Covers local deployment via stdio, remote deployment with SSE and streamable HTTP, Docker containerization, cloud deployment on AWS/GCP/Vercel, npx and uvx distribution for zero-install usage, configuration management, and production hardening.

Core architecture of the Model Context Protocol (MCP) — the open protocol from Anthropic that connects AI assistants to external tools and data sources. Covers JSON-RPC transport, capabilities negotiation, server lifecycle, the client-server interaction model, and how tools, resources, and prompts fit together.

Common architectural patterns for MCP servers — database servers, API wrappers, file system servers, multi-tool orchestration, caching strategies, error recovery, and composition patterns. Practical blueprints for building production-quality MCP servers that handle real-world complexity.

Defining prompt templates in MCP servers that AI clients can discover and invoke. Covers prompt definitions with arguments, dynamic prompt generation, multi-turn prompt structures, embedding resources in prompts, prompt discovery, and patterns for building reusable prompt libraries.

Building MCP servers in Python using the official mcp SDK and the FastMCP high-level pattern. Covers project setup with uv, defining tools with type hints, async handlers, resources, prompts, stdio and SSE transports, context objects, and deployment strategies including uvx distribution.

Exposing data and content to AI clients through MCP resources. Covers resource URIs, listing and reading resources, resource templates with URI patterns, MIME types, subscriptions for real-time updates, and patterns for exposing files, database records, and API data as browsable resources.

Use this skill when auditing the security of a Model Context Protocol server or client. Activate when users mention mcp server security audit, MCP vulnerabilities, tool poisoning, prompt injection via MCP, confused deputy, token passthrough, OAuth for MCP, rug-pull tool descriptions, or reviewing an MCP integration before connecting it to an agent with real capabilities.

Testing and debugging MCP servers effectively. Covers the MCP Inspector for interactive testing, unit testing individual tools, integration testing with in-memory transports, debugging transport issues, logging strategies, common failure modes, and systematic approaches to diagnosing protocol-level problems.

Defining and implementing tools in MCP servers — the primary way AI assistants take actions through MCP. Covers tool definitions with JSON Schema inputs, writing tool handlers, returning structured results, error handling with isError, tool annotations for UI hints, and patterns for robust tool implementations.

Building MCP servers in TypeScript using the official @modelcontextprotocol/sdk package. Covers project setup, the McpServer high-level API, defining tools with Zod schemas, stdio and SSE transports, streaming responses, error handling, and deployment as npm packages or standalone binaries.

Advanced RAG patterns beyond basic retrieve-and-generate. Covers multi-hop RAG, agentic RAG with tool use, graph RAG (knowledge graphs + vector retrieval), recursive retrieval, self-querying retrievers, query decomposition, citation extraction, and corrective RAG. Includes implementation patterns and guidance on when each advanced technique is warranted.

Comprehensive guide to document chunking strategies for RAG pipelines. Covers fixed-size, semantic, recursive character, sentence-based, parent-child, markdown-aware, and code-aware chunking. Includes chunk size optimization, overlap strategies, and practical benchmarks for choosing the right approach based on document type and retrieval quality.

Guide to selecting, using, and optimizing text embedding models for RAG pipelines. Covers commercial models (OpenAI text-embedding-3, Cohere embed-v3, Voyage AI) and open-source options (BGE, E5, Nomic Embed). Includes dimensionality selection, batch processing, embedding caching, fine-tuning for domain-specific retrieval, and cost analysis.

Evaluating RAG systems end-to-end. Covers retrieval metrics (context precision, context recall, MRR), generation metrics (faithfulness, answer relevance, hallucination detection), the RAGAS framework, human evaluation protocols, A/B testing retrieval strategies, building evaluation datasets, and continuous monitoring in production.

Teaches the foundational architecture of Retrieval-Augmented Generation (RAG) systems. Covers why RAG outperforms fine-tuning for most knowledge-grounding use cases, the three core stages (indexing, retrieval, generation), component design, latency budgets, and evaluation metrics including faithfulness, relevance, and hallucination rate. Use when building or explaining any RAG system from scratch.

Production-grade RAG deployment patterns. Covers caching strategies (semantic and exact), streaming responses, token budget management, fallback strategies for retrieval failures, monitoring retrieval quality, cost optimization, incremental indexing, multi-tenancy, and operational best practices for running RAG systems at scale.

Building RAG pipelines with LangChain and LangGraph. Covers document loaders, text splitters, vector stores, retrievers, chains, and agents. Includes practical patterns for conversational RAG, multi-source retrieval, streaming, and LangGraph-based agentic RAG workflows.

Building RAG systems with LlamaIndex (formerly GPT Index). Covers data connectors, node parsers, index types (vector, keyword, knowledge graph, summary), query engines, response synthesizers, and advanced patterns like sub-question queries and recursive retrieval. Practical code for production LlamaIndex RAG pipelines.

Covers retrieval strategies for RAG pipelines: dense retrieval, sparse retrieval (BM25), hybrid search, re-ranking with cross-encoders and Cohere Rerank, Maximal Marginal Relevance (MMR), contextual retrieval, and Hypothetical Document Embeddings (HyDE). Includes practical implementation patterns and guidance on when to use each strategy.

Practical guide to vector databases for RAG systems. Covers Pinecone, Qdrant, Weaviate, ChromaDB, pgvector, and Milvus with setup, indexing, querying, metadata filtering, hybrid search, and scaling considerations. Includes selection criteria, performance benchmarks, and production deployment patterns.

Core patterns for building AI agent systems: the observe-think-act loop, ReAct pattern implementation, tool-use cycles, memory systems (short-term and long-term), and planning strategies. Covers how to structure an agent's main loop, manage state between iterations, and wire together perception, reasoning, and action into a reliable autonomous system.

Handling failures in AI agent systems: retry strategies with backoff, fallback tools, graceful degradation, human-in-the-loop escalation, stuck-loop detection, and context recovery after crashes. Covers practical patterns for making agents robust against tool failures, API errors, and reasoning dead-ends.

Testing and evaluating AI agents: trajectory evaluation, task completion metrics, tool-use accuracy measurement, regression testing, benchmark suites, and A/B testing agent configurations. Covers practical approaches to measuring whether agents are working correctly and improving over time.

Comparison of major AI agent frameworks: LangGraph, CrewAI, AutoGen, Semantic Kernel, and Claude Agent SDK. Covers when to use each framework, their trade-offs, core patterns, practical setup examples, and migration strategies between frameworks.

Safety and control systems for AI agents: input and output validation, action authorization, rate limiting, cost controls, content filtering, scope restriction, and audit logging. Covers practical implementations for keeping agents within bounds while maintaining their usefulness.

Memory systems for AI agents: conversation history management, summarization strategies, vector-based long-term memory, entity memory, episodic memory, and memory retrieval patterns. Covers practical implementations for giving agents persistent, searchable memory across sessions and within long-running tasks.

Planning strategies for AI agents: chain-of-thought prompting, tree-of-thought exploration, plan-and-execute patterns, iterative refinement, task decomposition, and goal tracking. Covers practical implementations that make agents more reliable at complex, multi-step tasks by thinking before acting.

Building agents specifically with the Claude API: extended thinking for complex reasoning, tool use patterns, computer use for browser/desktop automation, multi-turn conversation management, crafting system prompts for agents, and streaming agent responses. Covers Claude-specific features and best practices for building reliable autonomous agents.

Orchestrating multiple AI agents working together: supervisor patterns, swarm architecture, handoff protocols, agent-to-agent communication, and agent specialization. Covers practical patterns for splitting complex tasks across coordinated agents, managing shared state, and routing work to the right specialist agent.

Implementing tool and function calling across Claude, OpenAI, and Gemini APIs. Covers schema design best practices, parallel tool calls, error handling, tool result formatting, dynamic tool registration, and patterns for building composable tool sets that agents can use reliably.

Comprehensive guide to database deployment for web applications, covering managed database services (PlanetScale, Neon, Supabase, Turso), migration strategies, connection pooling, backup and restore procedures, data seeding, and schema management best practices for production environments.

Comprehensive guide to using Docker for production deployments, covering multi-stage builds, .dockerignore optimization, layer caching strategies, health checks, Docker Compose for local development, container registries, and security scanning best practices.

Complete guide to deploying applications on Fly.io, covering flyctl CLI usage, Dockerfile-based deployments, fly.toml configuration, persistent volumes, horizontal and vertical scaling, multi-region deployments, managed Postgres and Redis, private networking, and auto-scaling strategies.

Comprehensive guide to implementing continuous deployment with GitHub Actions, covering deploy workflows, environment protection rules, secrets management, matrix builds, dependency caching, artifact management, and deploying to multiple targets including Vercel, Fly.io, AWS, and container registries.

Comprehensive guide to post-deployment monitoring for web applications, covering uptime checks, error tracking with Sentry, application performance monitoring, log aggregation, alerting strategies, public status pages, and incident response procedures for production systems.

Complete guide to deploying web applications on Netlify, covering build settings, deploy previews, serverless and edge functions, forms, identity, redirects and rewrites, split testing, and environment variable management for production workflows.

Complete guide to deploying applications on Railway, covering project setup, environment variable management, services and databases (Postgres, Redis, MySQL), persistent volumes, monorepo support, private networking between services, and scheduled cron jobs.

Comprehensive guide to deploying static sites and single-page applications, covering GitHub Pages, Cloudflare Pages, AWS S3 with CloudFront, cache busting strategies, prerendering for SEO, SPA routing configuration, and CDN setup for optimal performance.

Comprehensive guide to deploying modern web applications on Vercel, covering framework-specific configuration for Next.js, SvelteKit, Astro, and Remix, along with environment variables, preview deployments, edge and serverless functions, ISR, custom domains, and monorepo support.

Comprehensive guide to zero-downtime deployment patterns including blue-green deployments, canary releases, rolling updates, database migrations during deployments, health check strategies, rollback mechanisms, and feature flag integration for safe progressive rollouts.