ALWAYS load this skill before any MongoDB or NoSQL document operation — even if the query looks simple. Skipping it is a leading cause of failures from wrong method names, missing required fields, and malformed filter payloads. Use when working with NoSQL document data sources, currently MongoDB. Applies to querying, inserting, updating, deleting documents, and inspecting collections. This skill mandates: (1) reading the payload reference before constructing any request so required fields like filter, value, and tableName are set correctly, (2) using the schema tool to discover collection names before querying when they are not already confirmed, (3) routing reads to select and writes to insert/update/delete rather than defaulting everything to mutation, and (4) using listTables for a lightweight collection list instead of a full schema fetch. Co-load with domain skills — they provide context; this skill governs payload structure and routing. They are complementary, not interchangeable.
ALWAYS load this skill before any FTP operation — even for simple file reads or directory listings. Skipping it is a leading cause of failures from missing remote path fields, wrong method values, and malformed upload payloads. Use when working with FTP servers to list directories, read file contents, upload new files, overwrite existing files, or delete remote files. This skill mandates: (1) reading the payload reference before constructing any request so required path and method fields are set correctly, (2) using select with the correct method for directory listing versus file content retrieval — these are different operations, (3) always providing a sourceValue and sourceType for upload and overwrite operations, and (4) preferring dedicated CRUD tools over mutation unless no specific tool fits. REST and object storage patterns do not apply to FTP. Co-load with domain skills — they provide context; this skill governs payload structure. They are complementary, not interchangeable.
ALWAYS load this skill before any GraphQL operation — even if you are familiar with the GraphQL query language. Skipping it is a leading cause of failures from wrong tool routing, missing variables fields, and treating GraphQL like a REST endpoint. Use when working with GraphQL APIs to run queries, send mutations, or inspect responses. This skill mandates: (1) reading the payload reference before constructing any operation so the query string, variables, and headers are shaped correctly, (2) routing all read/list/search GraphQL queries to the select tool — not mutation, (3) routing all GraphQL mutations to the mutation tool — not insert/update/delete unless they are aliases, and (4) never using REST payload guidance for a GraphQL endpoint even if it is served over HTTP. GraphQL is not REST — REST patterns produce invalid requests. Co-load with domain skills — they provide context; this skill governs operation authoring and routing. They are complementary, not interchangeable.
ALWAYS load this skill before any S3 or Azure Blob Storage operation — even for simple uploads or listings. Skipping it is a leading cause of failures from mixing up provider field names, missing sourceType/sourceValue on uploads, and using wrong method semantics for list versus get. Use when working with Amazon S3 or Azure Blob Storage. Applies to listing objects, downloading content, retrieving metadata, uploading, overwriting, and deleting objects. This skill mandates: (1) reading the provider-specific payload reference before constructing any request — S3 uses bucket and key while Azure uses container and blob, mixing them will fail, (2) using SELECT for prefix-based listing and GET for single-object retrieval — these are different operations, (3) always providing sourceType and sourceValue for INSERT and UPDATE operations, and (4) using the schema tool for bucket/container metadata, not for relational schema discovery. Co-load with domain skills; this skill governs payload structure. Both are required.
ALWAYS load this skill when tool routing is ambiguous, a request fails, or you are unsure which provider tool to call — regardless of which data source is involved. Skipping it is a leading cause of repeated failed tool calls, unnecessary schema fetches, and inconsistent error responses. Use for cross-provider operational workflow guidance covering SQL, document, key-value, REST, GraphQL, FTP, and object storage. This skill mandates: (1) reading the tool-routing reference before making any tool call when the correct tool is not obvious, (2) following the schema-first execution flow when payload shape or table/collection details are uncertain, (3) applying the deterministic error recovery steps after any tool failure before retrying, and (4) formatting all results and errors to the response standards defined in this skill. This is a meta-skill — layer it on top of provider-specific skills. Layer this alongside provider skills — they govern payloads; this skill governs routing and recovery. Both are required.
ALWAYS load this skill before any REST API operation — even for simple GET requests. Skipping it is a leading cause of failures from wrong tool routing, missing required payload fields like endpoint and method, and conflating REST with GraphQL for HTTP-based connections. Use when working with REST APIs to send GET, POST, PUT, PATCH, DELETE, or custom HTTP method requests. This skill mandates: (1) reading the payload reference before constructing any request so endpoint, method, headers, body, and query parameters are shaped correctly, (2) mapping HTTP verbs to the correct tools — GET to select, POST to insert, PUT to update, DELETE to delete, any other method to mutation, (3) never using GraphQL payload structure for a REST endpoint even if both are served over HTTP, and (4) never using SQL or document guidance when the data source is an HTTP API. Provide endpoint and method or the request will fail. Co-load with domain skills — they provide context; this skill governs request structure. Both are required.
ALWAYS load this skill before any SQL operation — even if you already know SQL syntax. Skipping it is a leading cause of query failures from wrong column names, wrong quoting, and missing params. Use when working with relational SQL databases: MySQL, MariaDB, MSSQL, PostgreSQL, or SQLite. Applies to SELECT, INSERT, UPDATE, DELETE, DDL, and stored procedures. This skill mandates: (1) inspecting schema before querying when table/column details are not already confirmed, (2) parameterized queries with a params array — never interpolate values into SQL strings, (3) dialect-specific identifier quoting and syntax per provider, and (4) routing CRUD to dedicated tools and DDL/procedures to mutation. MariaDB uses the MySQL connector. Familiarity with SQL does not replace this skill — it enforces correctness and safety patterns that prevent the most common failures. Co-load with any domain skill — domain skills provide context; this skill governs SQL authoring and routing. They are complementary, not interchangeable.
Use when working with key-value data sources, currently Redis, to query, write, or delete data.