菜单
Use when working with key-value data sources, currently Redis, to query, write, or delete data.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
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.
基于 SOC 职业分类
| name | data-store-key-value |
| description | Use when working with key-value data sources, currently Redis, to query, write, or delete data. |
Use this skill when the user needs to work with key-value data sources such as Redis. Key-value stores are command- and key-centric, so payload construction differs from SQL and document data sources. This skill provides routing guidance and payload references for read, write, update, and delete behaviors.
ALWAYS #tool:read/readFile these additional instructions to understand the Data Store flow, tools need to be used in the correct order in order for the tools to work properly.
Use this skill for requests that target keys, key patterns, hashes, or value mutations in a key-value store. It is the correct starting point for Redis operations and for future key-value providers that follow method-driven payload patterns. Prefer this skill over SQL or REST references when the core unit is a key/value pair.
Key-value operations map to CRUD tools by intent, even when underlying commands are provider-specific. Use read tools for retrieval and write tools for state changes, then refine method values in the payload reference. Reserve mutation as a generic write alias when a specific CRUD route is not required.
Redis is the current documented provider for this skill and uses command-like methods (get, set, del, and hash variants). Use these mappings as the primary operational path for Redis connections. Apply schema tooling only as a key-summary helper, not as relational metadata.
GET, EXISTS, or KEYS.SET to create or write a key.SET when the target key already exists.DEL.SET or DEL.Payload shape is provider-specific and currently documented for Redis. Read the payload reference before issuing commands when method/field requirements are unknown or stale. Reuse known payload context for repeated operations with unchanged connection/provider context.
ALWAYS read the payload instructions document for the specific key-value store before using the Key-Value skill to understand how to properly format the payload for that store's operations, including the required and optional fields for different operation types.
Redis currently uses a method-driven payload that includes a command-style method, a key, and an optional value for write operations. Refer to the Redis payload documentation for the supported fields and shapes.
Use the provider reference for command-level details and examples. These references are the authoritative source for method names and required field combinations. Consult this section whenever there is uncertainty about command semantics or field naming. It is especially useful when translating user intent into provider-specific method values. Keeping method details in one place helps reduce contradictory guidance across skills.
ALWAYS refer to the specific data store instructions for detailed guidance on payload structure, supported operations, and examples.
Use these Redis payload assets as templates for common key-value operations. These assets replace long inline JSON snippets and keep examples synchronized with runtime expectations. They are easier to update when provider behavior changes and simpler to validate during reviews. Start from the closest operation file, then adjust only keys and values for the task.