[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6C58FAW1DGGN90DJWRGZXQ4":3,"skill-same:01M6C58FAW1DGGN90DJWRGZXQ4":48},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":22,"linkOnly":23,"markdownContent":24,"markdownBody":25,"frontMatter":26,"refName":28,"commitSha":29,"skillDirectory":30,"forksCount":14,"repositoryHtmlUrl":31,"repositoryHomepageUrl":6,"ownerHtmlUrl":32,"ownerBlogUrl":33,"ownerDescription":6,"updatedAt":34,"install":35,"resources":47},"01M6C58FAW1DGGN90DJWRGZXQ4","flash",null,"runpod-flash SDK and CLI for deploying AI workloads on Runpod serverless GPUs\u002FCPUs.","CoralShades\u002Facm-ai","CoralShades","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F220297585?v=4","01M6C5211QSJHZ8HXSDDWCR507","Coral Shades AI Agency","01M6C52161FNQDRQ0FRR8DAA9D",0,"MIT","https:\u002F\u002Fgithub.com\u002FCoralShades\u002Facm-ai\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fflash\u002FSKILL.md",[],[5,19,20,21],"cli","sdk","serverless","2026-11-10 10:12:30",false,"---\nname: flash\ndescription: runpod-flash SDK and CLI for deploying AI workloads on Runpod serverless GPUs\u002FCPUs.\nuser-invocable: true\n---\n\n# Runpod Flash\n\nWrite code locally, test with `flash run` (dev server at localhost:8888), and flash automatically provisions and deploys to remote GPUs\u002FCPUs in the cloud. `Endpoint` handles everything.\n\n## Setup\n\n```bash\npip install runpod-flash                 # requires Python >=3.10\n\n# auth option 1: browser-based login (saves token locally)\nflash login\n\n# auth option 2: API key via environment variable\nexport RUNPOD_API_KEY=your_key\n\nflash init my-project                    # scaffold a new project in .\u002Fmy-project\n```\n\n## CLI\n\n```bash\nflash run                                # start local dev server at localhost:8888\nflash run --auto-provision               # same, but pre-provision endpoints (no cold start)\nflash build                              # package artifact for deployment (500MB limit)\nflash build --exclude pkg1,pkg2          # exclude packages from build\nflash deploy                             # build + deploy (auto-selects env if only one)\nflash deploy --env staging               # build + deploy to \"staging\" environment\nflash deploy --app my-app --env prod     # deploy a specific app to an environment\nflash deploy --preview                   # build + launch local preview in Docker\nflash env list                           # list deployment environments\nflash env create staging                 # create \"staging\" environment\nflash env get staging                    # show environment details + resources\nflash env delete staging                 # delete environment + tear down resources\nflash undeploy list                      # list all active endpoints\nflash undeploy my-endpoint               # remove a specific endpoint\n```\n\n## Endpoint: Three Modes\n\n### Mode 1: Your Code (Queue-Based Decorator)\n\nOne function = one endpoint with its own workers.\n\n```python\nfrom runpod_flash import Endpoint, GpuGroup\n\n@Endpoint(name=\"my-worker\", gpu=GpuGroup.AMPERE_80, workers=5, dependencies=[\"torch\"])\nasync def compute(data):\n    import torch  # MUST import inside function (cloudpickle)\n    return {\"sum\": torch.tensor(data, device=\"cuda\").sum().item()}\n\nresult = await compute([1, 2, 3])\n```\n\n### Mode 2: Your Code (Load-Balanced Routes)\n\nMultiple HTTP routes share one pool of workers.\n\n```python\nfrom runpod_flash import Endpoint, GpuGroup\n\napi = Endpoint(name=\"my-api\", gpu=GpuGroup.ADA_24, workers=(1, 5), dependencies=[\"torch\"])\n\n@api.post(\"\u002Fpredict\")\nasync def predict(data: list[float]):\n    import torch\n    return {\"result\": torch.tensor(data, device=\"cuda\").sum().item()}\n\n@api.get(\"\u002Fhealth\")\nasync def health():\n    return {\"status\": \"ok\"}\n```\n\n### Mode 3: External Image (Client)\n\nDeploy a pre-built Docker image and call it via HTTP.\n\n```python\nfrom runpod_flash import Endpoint, GpuGroup, PodTemplate\n\nserver = Endpoint(\n    name=\"my-server\",\n    image=\"my-org\u002Fmy-image:latest\",\n    gpu=GpuGroup.AMPERE_80,\n    workers=1,\n    env={\"HF_TOKEN\": \"xxx\"},\n    template=PodTemplate(containerDiskInGb=100),\n)\n\n# LB-style\nresult = await server.post(\"\u002Fv1\u002Fcompletions\", {\"prompt\": \"hello\"})\nmodels = await server.get(\"\u002Fv1\u002Fmodels\")\n\n# QB-style\njob = await server.run({\"prompt\": \"hello\"})\nawait job.wait()\nprint(job.output)\n```\n\nConnect to an existing endpoint by ID (no provisioning):\n\n```python\nep = Endpoint(id=\"abc123\")\njob = await ep.runsync({\"input\": \"hello\"})\nprint(job.output)\n```\n\n## How Mode Is Determined\n\n| Parameters | Mode |\n|-----------|------|\n| `name=` only | Decorator (your code) |\n| `image=` set | Client (deploys image, then HTTP calls) |\n| `id=` set | Client (connects to existing, no provisioning) |\n\n## Endpoint Constructor\n\n```python\nEndpoint(\n    name=\"endpoint-name\",                  # required (unless id= set)\n    id=None,                               # connect to existing endpoint\n    gpu=GpuGroup.AMPERE_80,               # single GPU type (default: ANY)\n    gpu=[GpuGroup.ADA_24, GpuGroup.AMPERE_80],  # or list for auto-select by supply\n    cpu=CpuInstanceType.CPU5C_4_8,        # CPU type (mutually exclusive with gpu)\n    workers=5,                             # shorthand for (0, 5)\n    workers=(1, 5),                        # explicit (min, max)\n    idle_timeout=60,                       # seconds before scale-down (default: 60)\n    dependencies=[\"torch\"],                # pip packages for remote exec\n    system_dependencies=[\"ffmpeg\"],        # apt-get packages\n    image=\"org\u002Fimage:tag\",                 # pre-built Docker image (client mode)\n    env={\"KEY\": \"val\"},                    # environment variables\n    volume=NetworkVolume(...),             # persistent storage\n    gpu_count=1,                           # GPUs per worker\n    template=PodTemplate(containerDiskInGb=100),\n    flashboot=True,                        # fast cold starts\n    execution_timeout_ms=0,                # max execution time (0 = unlimited)\n)\n```\n\n- `gpu=` and `cpu=` are mutually exclusive\n- `workers=5` means `(0, 5)`. Default is `(0, 1)`\n- `idle_timeout` default is **60 seconds**\n- `flashboot=True` (default) -- enables fast cold starts via snapshot restore\n- `gpu_count` -- GPUs per worker (default 1), use >1 for multi-GPU models\n\n### NetworkVolume\n\n```python\nNetworkVolume(name=\"my-vol\", size=100)  # size in GB, default 100\n```\n\n### PodTemplate\n\n```python\nPodTemplate(\n    containerDiskInGb=64,    # container disk size (default 64)\n    dockerArgs=\"\",           # extra docker arguments\n    ports=\"\",                # exposed ports\n    startScript=\"\",          # script to run on start\n)\n```\n\n## EndpointJob\n\nReturned by `ep.run()` and `ep.runsync()` in client mode.\n\n```python\njob = await ep.run({\"data\": [1, 2, 3]})\nawait job.wait(timeout=120)        # poll until done\nprint(job.id, job.output, job.error, job.done)\nawait job.cancel()\n```\n\n## GPU Types (GpuGroup)\n\n| Enum | GPU | VRAM |\n|------|-----|------|\n| `ANY` | any | varies |\n| `AMPERE_16` | RTX A4000 | 16GB |\n| `AMPERE_24` | RTX A5000\u002FL4 | 24GB |\n| `AMPERE_48` | A40\u002FA6000 | 48GB |\n| `AMPERE_80` | A100 | 80GB |\n| `ADA_24` | RTX 4090 | 24GB |\n| `ADA_32_PRO` | RTX 5090 | 32GB |\n| `ADA_48_PRO` | RTX 6000 Ada | 48GB |\n| `ADA_80_PRO` | H100 PCIe (80GB) \u002F H100 HBM3 (80GB) \u002F H100 NVL (94GB) | 80GB+ |\n| `HOPPER_141` | H200 | 141GB |\n\n## CPU Types (CpuInstanceType)\n\n| Enum | vCPU | RAM | Max Disk | Type |\n|------|------|-----|----------|------|\n| `CPU3G_1_4` | 1 | 4GB | 10GB | General |\n| `CPU3G_2_8` | 2 | 8GB | 20GB | General |\n| `CPU3G_4_16` | 4 | 16GB | 40GB | General |\n| `CPU3G_8_32` | 8 | 32GB | 80GB | General |\n| `CPU3C_1_2` | 1 | 2GB | 10GB | Compute |\n| `CPU3C_2_4` | 2 | 4GB | 20GB | Compute |\n| `CPU3C_4_8` | 4 | 8GB | 40GB | Compute |\n| `CPU3C_8_16` | 8 | 16GB | 80GB | Compute |\n| `CPU5C_1_2` | 1 | 2GB | 15GB | Compute (5th gen) |\n| `CPU5C_2_4` | 2 | 4GB | 30GB | Compute (5th gen) |\n| `CPU5C_4_8` | 4 | 8GB | 60GB | Compute (5th gen) |\n| `CPU5C_8_16` | 8 | 16GB | 120GB | Compute (5th gen) |\n\n```python\nfrom runpod_flash import Endpoint, CpuInstanceType\n\n@Endpoint(name=\"cpu-work\", cpu=CpuInstanceType.CPU5C_4_8, workers=5, dependencies=[\"pandas\"])\nasync def process(data):\n    import pandas as pd\n    return pd.DataFrame(data).describe().to_dict()\n```\n\n## Common Patterns\n\n### CPU + GPU Pipeline\n\n```python\nfrom runpod_flash import Endpoint, GpuGroup, CpuInstanceType\n\n@Endpoint(name=\"preprocess\", cpu=CpuInstanceType.CPU5C_4_8, workers=5, dependencies=[\"pandas\"])\nasync def preprocess(raw):\n    import pandas as pd\n    return pd.DataFrame(raw).to_dict(\"records\")\n\n@Endpoint(name=\"infer\", gpu=GpuGroup.AMPERE_80, workers=5, dependencies=[\"torch\"])\nasync def infer(clean):\n    import torch\n    t = torch.tensor([[v for v in r.values()] for r in clean], device=\"cuda\")\n    return {\"predictions\": t.mean(dim=1).tolist()}\n\nasync def pipeline(data):\n    return await infer(await preprocess(data))\n```\n\n### Parallel Execution\n\n```python\nimport asyncio\nresults = await asyncio.gather(compute(a), compute(b), compute(c))\n```\n\n## Gotchas\n\n1. **Imports outside function** -- most common error. Everything inside the decorated function.\n2. **Forgetting await** -- all decorated functions and client methods need `await`.\n3. **Missing dependencies** -- must list in `dependencies=[]`.\n4. **gpu\u002Fcpu are exclusive** -- pick one per Endpoint.\n5. **idle_timeout is seconds** -- default 60s, not minutes.\n6. **10MB payload limit** -- pass URLs, not large objects.\n7. **Client vs decorator** -- `image=`\u002F`id=` = client. Otherwise = decorator.\n8. **Auto GPU switching requires workers >= 5** -- pass a list of GPU types (e.g. `gpu=[GpuGroup.ADA_24, GpuGroup.AMPERE_80]`) and set `workers=5` or higher. The platform only auto-switches GPU types based on supply when max workers is at least 5.\n9. **`runsync` timeout is 60s** -- cold starts can exceed 60s. Use `ep.runsync(data, timeout=120)` for first requests or use `ep.run()` + `job.wait()` instead.\n","# Runpod Flash\n\nWrite code locally, test with `flash run` (dev server at localhost:8888), and flash automatically provisions and deploys to remote GPUs\u002FCPUs in the cloud. `Endpoint` handles everything.\n\n## Setup\n\n```bash\npip install runpod-flash                 # requires Python >=3.10\n\n# auth option 1: browser-based login (saves token locally)\nflash login\n\n# auth option 2: API key via environment variable\nexport RUNPOD_API_KEY=your_key\n\nflash init my-project                    # scaffold a new project in .\u002Fmy-project\n```\n\n## CLI\n\n```bash\nflash run                                # start local dev server at localhost:8888\nflash run --auto-provision               # same, but pre-provision endpoints (no cold start)\nflash build                              # package artifact for deployment (500MB limit)\nflash build --exclude pkg1,pkg2          # exclude packages from build\nflash deploy                             # build + deploy (auto-selects env if only one)\nflash deploy --env staging               # build + deploy to \"staging\" environment\nflash deploy --app my-app --env prod     # deploy a specific app to an environment\nflash deploy --preview                   # build + launch local preview in Docker\nflash env list                           # list deployment environments\nflash env create staging                 # create \"staging\" environment\nflash env get staging                    # show environment details + resources\nflash env delete staging                 # delete environment + tear down resources\nflash undeploy list                      # list all active endpoints\nflash undeploy my-endpoint               # remove a specific endpoint\n```\n\n## Endpoint: Three Modes\n\n### Mode 1: Your Code (Queue-Based Decorator)\n\nOne function = one endpoint with its own workers.\n\n```python\nfrom runpod_flash import Endpoint, GpuGroup\n\n@Endpoint(name=\"my-worker\", gpu=GpuGroup.AMPERE_80, workers=5, dependencies=[\"torch\"])\nasync def compute(data):\n    import torch  # MUST import inside function (cloudpickle)\n    return {\"sum\": torch.tensor(data, device=\"cuda\").sum().item()}\n\nresult = await compute([1, 2, 3])\n```\n\n### Mode 2: Your Code (Load-Balanced Routes)\n\nMultiple HTTP routes share one pool of workers.\n\n```python\nfrom runpod_flash import Endpoint, GpuGroup\n\napi = Endpoint(name=\"my-api\", gpu=GpuGroup.ADA_24, workers=(1, 5), dependencies=[\"torch\"])\n\n@api.post(\"\u002Fpredict\")\nasync def predict(data: list[float]):\n    import torch\n    return {\"result\": torch.tensor(data, device=\"cuda\").sum().item()}\n\n@api.get(\"\u002Fhealth\")\nasync def health():\n    return {\"status\": \"ok\"}\n```\n\n### Mode 3: External Image (Client)\n\nDeploy a pre-built Docker image and call it via HTTP.\n\n```python\nfrom runpod_flash import Endpoint, GpuGroup, PodTemplate\n\nserver = Endpoint(\n    name=\"my-server\",\n    image=\"my-org\u002Fmy-image:latest\",\n    gpu=GpuGroup.AMPERE_80,\n    workers=1,\n    env={\"HF_TOKEN\": \"xxx\"},\n    template=PodTemplate(containerDiskInGb=100),\n)\n\n# LB-style\nresult = await server.post(\"\u002Fv1\u002Fcompletions\", {\"prompt\": \"hello\"})\nmodels = await server.get(\"\u002Fv1\u002Fmodels\")\n\n# QB-style\njob = await server.run({\"prompt\": \"hello\"})\nawait job.wait()\nprint(job.output)\n```\n\nConnect to an existing endpoint by ID (no provisioning):\n\n```python\nep = Endpoint(id=\"abc123\")\njob = await ep.runsync({\"input\": \"hello\"})\nprint(job.output)\n```\n\n## How Mode Is Determined\n\n| Parameters | Mode |\n|-----------|------|\n| `name=` only | Decorator (your code) |\n| `image=` set | Client (deploys image, then HTTP calls) |\n| `id=` set | Client (connects to existing, no provisioning) |\n\n## Endpoint Constructor\n\n```python\nEndpoint(\n    name=\"endpoint-name\",                  # required (unless id= set)\n    id=None,                               # connect to existing endpoint\n    gpu=GpuGroup.AMPERE_80,               # single GPU type (default: ANY)\n    gpu=[GpuGroup.ADA_24, GpuGroup.AMPERE_80],  # or list for auto-select by supply\n    cpu=CpuInstanceType.CPU5C_4_8,        # CPU type (mutually exclusive with gpu)\n    workers=5,                             # shorthand for (0, 5)\n    workers=(1, 5),                        # explicit (min, max)\n    idle_timeout=60,                       # seconds before scale-down (default: 60)\n    dependencies=[\"torch\"],                # pip packages for remote exec\n    system_dependencies=[\"ffmpeg\"],        # apt-get packages\n    image=\"org\u002Fimage:tag\",                 # pre-built Docker image (client mode)\n    env={\"KEY\": \"val\"},                    # environment variables\n    volume=NetworkVolume(...),             # persistent storage\n    gpu_count=1,                           # GPUs per worker\n    template=PodTemplate(containerDiskInGb=100),\n    flashboot=True,                        # fast cold starts\n    execution_timeout_ms=0,                # max execution time (0 = unlimited)\n)\n```\n\n- `gpu=` and `cpu=` are mutually exclusive\n- `workers=5` means `(0, 5)`. Default is `(0, 1)`\n- `idle_timeout` default is **60 seconds**\n- `flashboot=True` (default) -- enables fast cold starts via snapshot restore\n- `gpu_count` -- GPUs per worker (default 1), use >1 for multi-GPU models\n\n### NetworkVolume\n\n```python\nNetworkVolume(name=\"my-vol\", size=100)  # size in GB, default 100\n```\n\n### PodTemplate\n\n```python\nPodTemplate(\n    containerDiskInGb=64,    # container disk size (default 64)\n    dockerArgs=\"\",           # extra docker arguments\n    ports=\"\",                # exposed ports\n    startScript=\"\",          # script to run on start\n)\n```\n\n## EndpointJob\n\nReturned by `ep.run()` and `ep.runsync()` in client mode.\n\n```python\njob = await ep.run({\"data\": [1, 2, 3]})\nawait job.wait(timeout=120)        # poll until done\nprint(job.id, job.output, job.error, job.done)\nawait job.cancel()\n```\n\n## GPU Types (GpuGroup)\n\n| Enum | GPU | VRAM |\n|------|-----|------|\n| `ANY` | any | varies |\n| `AMPERE_16` | RTX A4000 | 16GB |\n| `AMPERE_24` | RTX A5000\u002FL4 | 24GB |\n| `AMPERE_48` | A40\u002FA6000 | 48GB |\n| `AMPERE_80` | A100 | 80GB |\n| `ADA_24` | RTX 4090 | 24GB |\n| `ADA_32_PRO` | RTX 5090 | 32GB |\n| `ADA_48_PRO` | RTX 6000 Ada | 48GB |\n| `ADA_80_PRO` | H100 PCIe (80GB) \u002F H100 HBM3 (80GB) \u002F H100 NVL (94GB) | 80GB+ |\n| `HOPPER_141` | H200 | 141GB |\n\n## CPU Types (CpuInstanceType)\n\n| Enum | vCPU | RAM | Max Disk | Type |\n|------|------|-----|----------|------|\n| `CPU3G_1_4` | 1 | 4GB | 10GB | General |\n| `CPU3G_2_8` | 2 | 8GB | 20GB | General |\n| `CPU3G_4_16` | 4 | 16GB | 40GB | General |\n| `CPU3G_8_32` | 8 | 32GB | 80GB | General |\n| `CPU3C_1_2` | 1 | 2GB | 10GB | Compute |\n| `CPU3C_2_4` | 2 | 4GB | 20GB | Compute |\n| `CPU3C_4_8` | 4 | 8GB | 40GB | Compute |\n| `CPU3C_8_16` | 8 | 16GB | 80GB | Compute |\n| `CPU5C_1_2` | 1 | 2GB | 15GB | Compute (5th gen) |\n| `CPU5C_2_4` | 2 | 4GB | 30GB | Compute (5th gen) |\n| `CPU5C_4_8` | 4 | 8GB | 60GB | Compute (5th gen) |\n| `CPU5C_8_16` | 8 | 16GB | 120GB | Compute (5th gen) |\n\n```python\nfrom runpod_flash import Endpoint, CpuInstanceType\n\n@Endpoint(name=\"cpu-work\", cpu=CpuInstanceType.CPU5C_4_8, workers=5, dependencies=[\"pandas\"])\nasync def process(data):\n    import pandas as pd\n    return pd.DataFrame(data).describe().to_dict()\n```\n\n## Common Patterns\n\n### CPU + GPU Pipeline\n\n```python\nfrom runpod_flash import Endpoint, GpuGroup, CpuInstanceType\n\n@Endpoint(name=\"preprocess\", cpu=CpuInstanceType.CPU5C_4_8, workers=5, dependencies=[\"pandas\"])\nasync def preprocess(raw):\n    import pandas as pd\n    return pd.DataFrame(raw).to_dict(\"records\")\n\n@Endpoint(name=\"infer\", gpu=GpuGroup.AMPERE_80, workers=5, dependencies=[\"torch\"])\nasync def infer(clean):\n    import torch\n    t = torch.tensor([[v for v in r.values()] for r in clean], device=\"cuda\")\n    return {\"predictions\": t.mean(dim=1).tolist()}\n\nasync def pipeline(data):\n    return await infer(await preprocess(data))\n```\n\n### Parallel Execution\n\n```python\nimport asyncio\nresults = await asyncio.gather(compute(a), compute(b), compute(c))\n```\n\n## Gotchas\n\n1. **Imports outside function** -- most common error. Everything inside the decorated function.\n2. **Forgetting await** -- all decorated functions and client methods need `await`.\n3. **Missing dependencies** -- must list in `dependencies=[]`.\n4. **gpu\u002Fcpu are exclusive** -- pick one per Endpoint.\n5. **idle_timeout is seconds** -- default 60s, not minutes.\n6. **10MB payload limit** -- pass URLs, not large objects.\n7. **Client vs decorator** -- `image=`\u002F`id=` = client. Otherwise = decorator.\n8. **Auto GPU switching requires workers >= 5** -- pass a list of GPU types (e.g. `gpu=[GpuGroup.ADA_24, GpuGroup.AMPERE_80]`) and set `workers=5` or higher. The platform only auto-switches GPU types based on supply when max workers is at least 5.\n9. **`runsync` timeout is 60s** -- cold starts can exceed 60s. Use `ep.runsync(data, timeout=120)` for first requests or use `ep.run()` + `job.wait()` instead.\n",{"name":5,"description":7,"user-invocable":27},true,"main","1ca81b0a7de199942400f965edd4d7544077ac5d",".agents\u002Fskills\u002Fflash","https:\u002F\u002Fgithub.com\u002FCoralShades\u002Facm-ai","https:\u002F\u002Fgithub.com\u002FCoralShades","coralshades.com.au","2026-04-18 00:45:07",{"source":8,"skillName":5,"commands":36,"prompt":46,"zipAvailable":27},[37,40,43],{"tool":38,"command":39},"npx","npx skills add CoralShades\u002Facm-ai --skill flash",{"tool":41,"command":42},"bunx","bunx skills add CoralShades\u002Facm-ai --skill flash",{"tool":44,"command":45},"pnpm","pnpm dlx skills add CoralShades\u002Facm-ai --skill flash","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FCoralShades\u002Facm-ai\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fflash\u002FSKILL.md",[],[49,73,85,101,123,133],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":60,"publishedAt":22},"01M6C63HKXA890HHV47WBAX0TB","uncodixfy","Prevents generic AI\u002FCodex UI patterns when generating frontend code. Use this skill whenever generating HTML, CSS, React, Vue, Svelte, or any frontend UI code to enforce clean, human-designed aesthetics inspired by Linear, Raycast, Stripe, and GitHub instead of typical AI-generated UI.","https:\u002F\u002Fgithub.com\u002FCoralShades\u002Facm-ai\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Funcodixfy\u002FSKILL.md",[55],{"categoryNo":56,"categoryName":57,"taxonomyType":58,"taxonomyTypeDesc":59},"01JBSEEDCAT000000000000009","前端开发","SCENARIO","使用场景",[51,61,62,63,64,65,66,67,68,69,70,71,72],"github","frontend","css","codex","react","code","linear","ui","vue","generated","use","html",{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":77,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":22},"01M6C63FJ2GEBBGZ5XSMV40KXB","runpodctl","Runpod CLI to manage your GPU workloads.","Apache-2.0","https:\u002F\u002Fgithub.com\u002FCoralShades\u002Facm-ai\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Frunpodctl\u002FSKILL.md",[],[75,81,19,82,83,84],"macos","linux","gpu","Bash",{"skillNo":86,"name":87,"nameZh":6,"description":88,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":89,"categories":90,"keywords":91,"publishedAt":22},"01M6C63DPAV46TFVQ01SFYPJ7X","langgraph-persistence","INVOKE THIS SKILL when your LangGraph needs to persist state, remember conversations, travel through history, or configure subgraph checkpointer scoping. Covers checkpointers, thread_id, time travel, Store, and subgraph persistence modes.","https:\u002F\u002Fgithub.com\u002FCoralShades\u002Facm-ai\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Flanggraph-persistence\u002FSKILL.md",[],[92,93,94,95,96,97,98,99,100],"langgraph persistence","langgraph","persistence","travel","history","scoping","remember","state","configure",{"skillNo":102,"name":103,"nameZh":6,"description":104,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":105,"categories":106,"keywords":112,"publishedAt":22},"01M6C63BNS9CQEBTB8RNSSBFPA","langgraph-human-in-the-loop","INVOKE THIS SKILL when implementing human-in-the-loop patterns, pausing for approval, or handling errors in LangGraph. Covers interrupt(), Command(resume=...), approval\u002Fvalidation workflows, and the 4-tier error handling strategy.","https:\u002F\u002Fgithub.com\u002FCoralShades\u002Facm-ai\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Flanggraph-human-in-the-loop\u002FSKILL.md",[107],{"categoryNo":108,"categoryName":109,"taxonomyType":110,"taxonomyTypeDesc":111},"01JBSEEDCAT000000000000038","人力资源","PROFESSION","适用职业",[113,114,93,115,116,117,118,119,120,121,122],"langgraph human in the loop","loop","workflows","error handling","validation","human-in-the-loop","command","strategy","approval","resume",{"skillNo":124,"name":125,"nameZh":6,"description":126,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":127,"categories":128,"keywords":129,"publishedAt":22},"01M6C639GVYZFX3NFPV5FBDR4F","langgraph-fundamentals","INVOKE THIS SKILL when writing ANY LangGraph code. Covers StateGraph, state schemas, nodes, edges, Command, Send, invoke, streaming, and error handling.","https:\u002F\u002Fgithub.com\u002FCoralShades\u002Facm-ai\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Flanggraph-fundamentals\u002FSKILL.md",[],[130,93,116,99,131,132,119,66],"langgraph fundamentals","streaming","writing",{"skillNo":134,"name":135,"nameZh":6,"description":136,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":137,"categories":138,"keywords":139,"publishedAt":22},"01M6C6375N34YX2GZ3SD3R7XR2","langchain-rag","INVOKE THIS SKILL when building ANY retrieval-augmented generation (RAG) system. Covers document loaders, RecursiveCharacterTextSplitter, embeddings (OpenAI), and vector stores (Chroma, FAISS, Pinecone).","https:\u002F\u002Fgithub.com\u002FCoralShades\u002Facm-ai\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Flangchain-rag\u002FSKILL.md",[],[140,141,142,143,144,145,146,147,148,149],"rag","langchain rag","langchain","embeddings","vector","openai","chroma","faiss","vector stores","system"]