Database

Using Figma Dev Mode to inspect designs, extract code snippets, and streamline the design-to-code workflow

Using the Figma REST API to programmatically access files, components, images, and design data

Building Figma plugins using the Plugin API to automate tasks, generate assets, and extend Figma's capabilities

Analyze large datasets with Google BigQuery serverless data warehouse and SQL engine

Build and deploy event-driven serverless functions on Google Cloud Functions

Deploy and manage containerized applications on Google Cloud Run serverless platform

Store, retrieve, and manage objects in Google Cloud Storage buckets

Model, query, and manage data with Google Cloud Firestore NoSQL document database

Azure App Service for hosting web apps, REST APIs, and mobile backends

Azure Functions serverless compute for event-driven applications

Azure Blob Storage for scalable object storage and data lake scenarios

Azure Cosmos DB globally distributed multi-model database service

Key PostgreSQL extensions including pgvector, PostGIS, pg_cron, and other essential add-ons

Full-text search in PostgreSQL using tsvector, tsquery, ranking, and GIN indexes

Table partitioning strategies in PostgreSQL including range, list, and hash partitioning

Logical and streaming replication in PostgreSQL for high availability and data distribution

Row-level security policies in PostgreSQL for fine-grained access control on table rows

Triggers and PL/pgSQL functions in PostgreSQL for automated data processing and integrity enforcement

Cache-aside, write-through, and write-behind caching strategies with Redis

Redis core data structures including strings, hashes, sets, sorted sets, and lists

Lua scripting in Redis for atomic multi-step operations

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

Architect and implement robust API Gateway patterns to manage, secure, and scale your microservices APIs effectively.

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,

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,

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

Master the common interaction models, service design strategies, and robust error handling

Master the various OAuth 2.0 authorization flows to securely delegate access from a resource owner to a client application.

Master the creation and interpretation of OpenAPI Specification documents to design,

Design robust, scalable, and developer-friendly RESTful APIs that adhere to industry

Design intuitive, robust, and idiomatic SDKs that abstract API complexity and accelerate developer integration.

Master the design, implementation, and management of robust webhook systems for

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.

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.