[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6HAFKWNRAYE1C4AEAMTCT79":3,"skill-same:01M6HAFKWNRAYE1C4AEAMTCT79":53},{"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":24,"linkOnly":25,"markdownContent":26,"markdownBody":27,"frontMatter":28,"refName":31,"commitSha":32,"skillDirectory":33,"forksCount":14,"repositoryHtmlUrl":34,"repositoryHomepageUrl":6,"ownerHtmlUrl":35,"ownerBlogUrl":36,"ownerDescription":37,"updatedAt":38,"install":39,"resources":52},"01M6HAFKWNRAYE1C4AEAMTCT79","rate-limiting",null,"Rate limiting implementation and strategies","NeuralBlitz\u002FMito","NeuralBlitz","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F79354388?v=4","01M6H8T2TFH477HRS0KTSTKR2E","David Riggs","01M6H8T2YQQDXPYM092P670Z21",0,"MIT","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Frate-limiting\u002FSKILL.md",[],[19,20,21,22,23],"rate limiting","security","opencode","implementation","strategies","2026-11-10 10:12:30",false,"---\nname: rate-limiting\ndescription: Rate limiting implementation and strategies\nlicense: MIT\ncompatibility: opencode\nmetadata:\n  audience: developers\n  category: security\n---\n## What I do\n- Implement rate limiting\n- Choose appropriate algorithms\n- Handle rate limit headers\n- Design tiered limits\n- Handle rate limit exceeded\n- Distribute rate limits\n- Monitor rate limit usage\n- Implement custom providers\n\n## When to use me\nWhen implementing rate limiting or throttling.\n\n## Rate Limiting Algorithms\n```python\nfrom dataclasses import dataclass\nfrom datetime import datetime, timedelta\nfrom typing import Dict, Optional\nimport asyncio\n\n\n# Fixed Window\nclass FixedWindowRateLimiter:\n    \"\"\"\n    Simple fixed window rate limiting.\n    \n    Pros: Simple, memory efficient\n    Cons: Can allow bursts at window boundaries\n    \"\"\"\n    \n    def __init__(self, max_requests: int, window_seconds: int):\n        self.max_requests = max_requests\n        self.window_seconds = window_seconds\n        self.windows: Dict[str, list] = {}\n    \n    def is_allowed(self, key: str) -> tuple[bool, dict]:\n        now = datetime.utcnow()\n        window_start = self._get_window_start(now)\n        \n        if key not in self.windows:\n            self.windows[key] = []\n        \n        # Remove old requests\n        self.windows[key] = [\n            t for t in self.windows[key]\n            if t >= window_start\n        ]\n        \n        if len(self.windows[key]) >= self.max_requests:\n            return False, {\n                \"limit\": self.max_requests,\n                \"remaining\": 0,\n                \"reset\": int((window_start + timedelta(seconds=self.window_seconds)).timestamp())\n            }\n        \n        self.windows[key].append(now)\n        \n        return True, {\n            \"limit\": self.max_requests,\n            \"remaining\": self.max_requests - len(self.windows[key]),\n            \"reset\": int((window_start + timedelta(seconds=self.window_seconds)).timestamp())\n        }\n    \n    def _get_window_start(self, now: datetime) -> datetime:\n        seconds_past_window = now.timestamp() % self.window_seconds\n        return now - timedelta(seconds=seconds_past_window)\n\n\n# Sliding Window\nclass SlidingWindowRateLimiter:\n    \"\"\"\n    Sliding window rate limiting.\n    \n    Pros: More accurate than fixed window\n    Cons: More complex, more memory\n    \"\"\"\n    \n    def __init__(self, max_requests: int, window_seconds: int):\n        self.max_requests = max_requests\n        self.window_seconds = window_seconds\n        self.requests: Dict[str, list] = {}\n    \n    def is_allowed(self, key: str) -> tuple[bool, dict]:\n        now = datetime.utcnow()\n        window_start = now - timedelta(seconds=self.window_seconds)\n        \n        if key not in self.requests:\n            self.requests[key] = []\n        \n        # Remove old requests\n        self.requests[key] = [\n            t for t in self.requests[key]\n            if t >= window_start\n        ]\n        \n        if len(self.requests[key]) >= self.max_requests:\n            return False, {\n                \"limit\": self.max_requests,\n                \"remaining\": 0,\n                \"reset\": int((now + timedelta(seconds=self.window_seconds)).timestamp())\n            }\n        \n        self.requests[key].append(now)\n        \n        return True, {\n            \"limit\": self.max_requests,\n            \"remaining\": self.max_requests - len(self.requests[key]),\n            \"reset\": int((now + timedelta(seconds=self.window_seconds)).timestamp())\n        }\n\n\n# Token Bucket\nclass TokenBucketRateLimiter:\n    \"\"\"\n    Token bucket rate limiting.\n    \n    Pros: Allows bursts, smooth rate limiting\n    Cons: More complex\n    \"\"\"\n    \n    def __init__(self, max_tokens: int, refill_rate: float):\n        self.max_tokens = max_tokens\n        self.refill_rate = refill_rate  # tokens per second\n        self.tokens: Dict[str, float] = {}\n        self.last_refill: Dict[str, datetime] = {}\n    \n    def _refill(self, key: str) -> float:\n        now = datetime.utcnow()\n        \n        if key not in self.tokens:\n            self.tokens[key] = self.max_tokens\n            self.last_refill[key] = now\n            return self.tokens[key]\n        \n        elapsed = (now - self.last_refill[key]).total_seconds()\n        tokens_to_add = elapsed * self.refill_rate\n        \n        self.tokens[key] = min(\n            self.max_tokens,\n            self.tokens[key] + tokens_to_add\n        )\n        self.last_refill[key] = now\n        \n        return self.tokens[key]\n    \n    def is_allowed(self, key: str, tokens: int = 1) -> tuple[bool, dict]:\n        self._refill(key)\n        \n        if self.tokens[key] >= tokens:\n            self.tokens[key] -= tokens\n            \n            return True, {\n                \"limit\": self.max_tokens,\n                \"remaining\": int(self.tokens[key]),\n            }\n        \n        return False, {\n            \"limit\": self.max_tokens\": 0,\n,\n            \"remaining        }\n```\n\n## API Rate Limiting Middleware\n```python\nfrom fastapi import Request, HTTPException\nfrom fastapi.responses import JSONResponse\nfrom starlette.middleware.base import BaseHTTPMiddleware\n\n\nclass RateLimitMiddleware(BaseHTTPMiddleware):\n    \"\"\"Rate limiting middleware for FastAPI.\"\"\"\n    \n    def __init__(\n        self,\n        app,\n        rate_limiter,\n        exempt_paths: list = None\n    ):\n        super().__init__(app)\n        self.rate_limiter = rate_limiter\n        self.exempt_paths = exempt_paths or []\n    \n    async def dispatch(self, request: Request, call_next):\n        # Skip rate limiting for exempt paths\n        if request.url.path in self.exempt_paths:\n            return await call_next(request)\n        \n        # Get client identifier\n        key = self._get_client_key(request)\n        \n        # Check rate limit\n        allowed, headers = self.rate_limiter.is_allowed(key)\n        \n        if not allowed:\n            return JSONResponse(\n                status_code=429,\n                headers={\n                    **headers,\n                    \"Retry-After\": str(headers.get(\"reset\", 60)),\n                },\n                content={\n                    \"error\": {\n                        \"code\": \"RATE_LIMIT_EXCEEDED\",\n                        \"message\": \"Too many requests. Please retry later.\"\n                    }\n                }\n            )\n        \n        response = await call_next(request)\n        \n        # Add rate limit headers\n        for key, value in headers.items():\n            response.headers[key] = str(value)\n        \n        return response\n    \n    def _get_client_key(self, request: Request) -> str:\n        \"\"\"Get unique key for client.\"\"\"\n        # Check for API key\n        api_key = request.headers.get(\"X-API-Key\")\n        if api_key:\n            return f\"apikey:{api_key}\"\n        \n        # Use user ID if authenticated\n        if hasattr(request.state, \"user_id\"):\n            return f\"user:{request.state.user_id}\"\n        \n        # Fall back to IP\n        client_ip = request.client.host\n        return f\"ip:{client_ip}\"\n```\n\n## Distributed Rate Limiting with Redis\n```python\nimport redis\nfrom typing import Dict, Any\n\n\nclass RedisRateLimiter:\n    \"\"\"Distributed rate limiter using Redis.\"\"\"\n    \n    def __init__(\n        self,\n        redis_url: str,\n        max_requests: int = 100,\n        window_seconds: int = 60\n    ):\n        self.redis = redis.from_url(redis_url)\n        self.max_requests = max_requests\n        self.window_seconds = window_seconds\n    \n    def is_allowed(self, key: str) -> tuple[bool, dict]:\n        now = datetime.utcnow()\n        window_key = f\"ratelimit:{key}:{int(now.timestamp() \u002F\u002F self.window_seconds)}\"\n        \n        pipe = self.redis.pipeline()\n        \n        # Increment counter\n        pipe.incr(window_key)\n        # Set expiry\n        pipe.expire(window_key, self.window_seconds * 2)\n        # Get current count\n        results = pipe.execute()\n        \n        current_count = results[0]\n        \n        headers = {\n            \"X-RateLimit-Limit\": str(self.max_requests),\n            \"X-RateLimit-Remaining\": str(max(0, self.max_requests - current_count)),\n            \"X-RateLimit-Reset\": str(\n                int(now.timestamp()) + self.window_seconds\n            ),\n        }\n        \n        if current_count > self.max_requests:\n            return False, headers\n        \n        return True, headers\n    \n    def sliding_window(self, key: str) -> tuple[bool, dict]:\n        \"\"\"More accurate sliding window using sorted sets.\"\"\"\n        now = datetime.utcnow()\n        window_start = now - timedelta(seconds=self.window_seconds)\n        \n        pipe = self.redis.pipeline()\n        \n        # Remove old entries\n        pipe.zremrangebyscore(\n            f\"ratelimit:sliding:{key}\",\n            0,\n            window_start.timestamp() - 1\n        )\n        \n        # Add current request\n        pipe.zadd(\n            f\"ratelimit:sliding:{key}\",\n            {f\"{now.timestamp()}:{uuid.uuid4()}\": now.timestamp()}\n        )\n        \n        # Count requests in window\n        pipe.zcard(f\"ratelimit:sliding:{key}\")\n        \n        # Set expiry\n        pipe.expire(\n            f\"ratelimit:sliding:{key}\",\n            self.window_seconds * 2\n        )\n        \n        results = pipe.execute()\n        current_count = results[2]\n        \n        allowed = current_count \u003C= self.max_requests\n        \n        return allowed, {\n            \"X-RateLimit-Limit\": str(self.max_requests),\n            \"X-RateLimit-Remaining\": str(\n                max(0, self.max_requests - current_count)\n            ),\n            \"X-RateLimit-Reset\": str(\n                int(now.timestamp()) + self.window_seconds\n            ),\n        }\n```\n\n## Best Practices\n```\nRate Limiting Best Practices:\n\n1. Choose appropriate algorithm\n   - Fixed window: simple, forgiving\n   - Sliding window: more accurate\n   - Token bucket: burst handling\n\n2. Use tiered limits\n   - Different limits for different users\n   - Public vs authenticated\n\n3. Return proper headers\n   - X-RateLimit-Limit\n   - X-RateLimit-Remaining\n   - X-RateLimit-Reset\n   - Retry-After\n\n4. Handle exceeded gracefully\n   - Clear error messages\n   - Appropriate retry headers\n\n5. Monitor and alert\n   - Track rate limit hits\n   - Alert on unusual patterns\n\n6. Distribute across instances\n   - Use shared storage (Redis)\n   - Consistent hashing\n\n7. Consider endpoint-specific\n   - Different limits per endpoint\n   - Expensive operations get lower limits\n\n8. Allow some burst\n   - Users expect occasional bursts\n   - Token bucket handles this well\n\n9. Test rate limiting\n   - Verify limits are enforced\n   - Test header values\n\n10. Document limits\n    - API documentation\n    - Developer portal\n```\n","## What I do\n- Implement rate limiting\n- Choose appropriate algorithms\n- Handle rate limit headers\n- Design tiered limits\n- Handle rate limit exceeded\n- Distribute rate limits\n- Monitor rate limit usage\n- Implement custom providers\n\n## When to use me\nWhen implementing rate limiting or throttling.\n\n## Rate Limiting Algorithms\n```python\nfrom dataclasses import dataclass\nfrom datetime import datetime, timedelta\nfrom typing import Dict, Optional\nimport asyncio\n\n\n# Fixed Window\nclass FixedWindowRateLimiter:\n    \"\"\"\n    Simple fixed window rate limiting.\n    \n    Pros: Simple, memory efficient\n    Cons: Can allow bursts at window boundaries\n    \"\"\"\n    \n    def __init__(self, max_requests: int, window_seconds: int):\n        self.max_requests = max_requests\n        self.window_seconds = window_seconds\n        self.windows: Dict[str, list] = {}\n    \n    def is_allowed(self, key: str) -> tuple[bool, dict]:\n        now = datetime.utcnow()\n        window_start = self._get_window_start(now)\n        \n        if key not in self.windows:\n            self.windows[key] = []\n        \n        # Remove old requests\n        self.windows[key] = [\n            t for t in self.windows[key]\n            if t >= window_start\n        ]\n        \n        if len(self.windows[key]) >= self.max_requests:\n            return False, {\n                \"limit\": self.max_requests,\n                \"remaining\": 0,\n                \"reset\": int((window_start + timedelta(seconds=self.window_seconds)).timestamp())\n            }\n        \n        self.windows[key].append(now)\n        \n        return True, {\n            \"limit\": self.max_requests,\n            \"remaining\": self.max_requests - len(self.windows[key]),\n            \"reset\": int((window_start + timedelta(seconds=self.window_seconds)).timestamp())\n        }\n    \n    def _get_window_start(self, now: datetime) -> datetime:\n        seconds_past_window = now.timestamp() % self.window_seconds\n        return now - timedelta(seconds=seconds_past_window)\n\n\n# Sliding Window\nclass SlidingWindowRateLimiter:\n    \"\"\"\n    Sliding window rate limiting.\n    \n    Pros: More accurate than fixed window\n    Cons: More complex, more memory\n    \"\"\"\n    \n    def __init__(self, max_requests: int, window_seconds: int):\n        self.max_requests = max_requests\n        self.window_seconds = window_seconds\n        self.requests: Dict[str, list] = {}\n    \n    def is_allowed(self, key: str) -> tuple[bool, dict]:\n        now = datetime.utcnow()\n        window_start = now - timedelta(seconds=self.window_seconds)\n        \n        if key not in self.requests:\n            self.requests[key] = []\n        \n        # Remove old requests\n        self.requests[key] = [\n            t for t in self.requests[key]\n            if t >= window_start\n        ]\n        \n        if len(self.requests[key]) >= self.max_requests:\n            return False, {\n                \"limit\": self.max_requests,\n                \"remaining\": 0,\n                \"reset\": int((now + timedelta(seconds=self.window_seconds)).timestamp())\n            }\n        \n        self.requests[key].append(now)\n        \n        return True, {\n            \"limit\": self.max_requests,\n            \"remaining\": self.max_requests - len(self.requests[key]),\n            \"reset\": int((now + timedelta(seconds=self.window_seconds)).timestamp())\n        }\n\n\n# Token Bucket\nclass TokenBucketRateLimiter:\n    \"\"\"\n    Token bucket rate limiting.\n    \n    Pros: Allows bursts, smooth rate limiting\n    Cons: More complex\n    \"\"\"\n    \n    def __init__(self, max_tokens: int, refill_rate: float):\n        self.max_tokens = max_tokens\n        self.refill_rate = refill_rate  # tokens per second\n        self.tokens: Dict[str, float] = {}\n        self.last_refill: Dict[str, datetime] = {}\n    \n    def _refill(self, key: str) -> float:\n        now = datetime.utcnow()\n        \n        if key not in self.tokens:\n            self.tokens[key] = self.max_tokens\n            self.last_refill[key] = now\n            return self.tokens[key]\n        \n        elapsed = (now - self.last_refill[key]).total_seconds()\n        tokens_to_add = elapsed * self.refill_rate\n        \n        self.tokens[key] = min(\n            self.max_tokens,\n            self.tokens[key] + tokens_to_add\n        )\n        self.last_refill[key] = now\n        \n        return self.tokens[key]\n    \n    def is_allowed(self, key: str, tokens: int = 1) -> tuple[bool, dict]:\n        self._refill(key)\n        \n        if self.tokens[key] >= tokens:\n            self.tokens[key] -= tokens\n            \n            return True, {\n                \"limit\": self.max_tokens,\n                \"remaining\": int(self.tokens[key]),\n            }\n        \n        return False, {\n            \"limit\": self.max_tokens\": 0,\n,\n            \"remaining        }\n```\n\n## API Rate Limiting Middleware\n```python\nfrom fastapi import Request, HTTPException\nfrom fastapi.responses import JSONResponse\nfrom starlette.middleware.base import BaseHTTPMiddleware\n\n\nclass RateLimitMiddleware(BaseHTTPMiddleware):\n    \"\"\"Rate limiting middleware for FastAPI.\"\"\"\n    \n    def __init__(\n        self,\n        app,\n        rate_limiter,\n        exempt_paths: list = None\n    ):\n        super().__init__(app)\n        self.rate_limiter = rate_limiter\n        self.exempt_paths = exempt_paths or []\n    \n    async def dispatch(self, request: Request, call_next):\n        # Skip rate limiting for exempt paths\n        if request.url.path in self.exempt_paths:\n            return await call_next(request)\n        \n        # Get client identifier\n        key = self._get_client_key(request)\n        \n        # Check rate limit\n        allowed, headers = self.rate_limiter.is_allowed(key)\n        \n        if not allowed:\n            return JSONResponse(\n                status_code=429,\n                headers={\n                    **headers,\n                    \"Retry-After\": str(headers.get(\"reset\", 60)),\n                },\n                content={\n                    \"error\": {\n                        \"code\": \"RATE_LIMIT_EXCEEDED\",\n                        \"message\": \"Too many requests. Please retry later.\"\n                    }\n                }\n            )\n        \n        response = await call_next(request)\n        \n        # Add rate limit headers\n        for key, value in headers.items():\n            response.headers[key] = str(value)\n        \n        return response\n    \n    def _get_client_key(self, request: Request) -> str:\n        \"\"\"Get unique key for client.\"\"\"\n        # Check for API key\n        api_key = request.headers.get(\"X-API-Key\")\n        if api_key:\n            return f\"apikey:{api_key}\"\n        \n        # Use user ID if authenticated\n        if hasattr(request.state, \"user_id\"):\n            return f\"user:{request.state.user_id}\"\n        \n        # Fall back to IP\n        client_ip = request.client.host\n        return f\"ip:{client_ip}\"\n```\n\n## Distributed Rate Limiting with Redis\n```python\nimport redis\nfrom typing import Dict, Any\n\n\nclass RedisRateLimiter:\n    \"\"\"Distributed rate limiter using Redis.\"\"\"\n    \n    def __init__(\n        self,\n        redis_url: str,\n        max_requests: int = 100,\n        window_seconds: int = 60\n    ):\n        self.redis = redis.from_url(redis_url)\n        self.max_requests = max_requests\n        self.window_seconds = window_seconds\n    \n    def is_allowed(self, key: str) -> tuple[bool, dict]:\n        now = datetime.utcnow()\n        window_key = f\"ratelimit:{key}:{int(now.timestamp() \u002F\u002F self.window_seconds)}\"\n        \n        pipe = self.redis.pipeline()\n        \n        # Increment counter\n        pipe.incr(window_key)\n        # Set expiry\n        pipe.expire(window_key, self.window_seconds * 2)\n        # Get current count\n        results = pipe.execute()\n        \n        current_count = results[0]\n        \n        headers = {\n            \"X-RateLimit-Limit\": str(self.max_requests),\n            \"X-RateLimit-Remaining\": str(max(0, self.max_requests - current_count)),\n            \"X-RateLimit-Reset\": str(\n                int(now.timestamp()) + self.window_seconds\n            ),\n        }\n        \n        if current_count > self.max_requests:\n            return False, headers\n        \n        return True, headers\n    \n    def sliding_window(self, key: str) -> tuple[bool, dict]:\n        \"\"\"More accurate sliding window using sorted sets.\"\"\"\n        now = datetime.utcnow()\n        window_start = now - timedelta(seconds=self.window_seconds)\n        \n        pipe = self.redis.pipeline()\n        \n        # Remove old entries\n        pipe.zremrangebyscore(\n            f\"ratelimit:sliding:{key}\",\n            0,\n            window_start.timestamp() - 1\n        )\n        \n        # Add current request\n        pipe.zadd(\n            f\"ratelimit:sliding:{key}\",\n            {f\"{now.timestamp()}:{uuid.uuid4()}\": now.timestamp()}\n        )\n        \n        # Count requests in window\n        pipe.zcard(f\"ratelimit:sliding:{key}\")\n        \n        # Set expiry\n        pipe.expire(\n            f\"ratelimit:sliding:{key}\",\n            self.window_seconds * 2\n        )\n        \n        results = pipe.execute()\n        current_count = results[2]\n        \n        allowed = current_count \u003C= self.max_requests\n        \n        return allowed, {\n            \"X-RateLimit-Limit\": str(self.max_requests),\n            \"X-RateLimit-Remaining\": str(\n                max(0, self.max_requests - current_count)\n            ),\n            \"X-RateLimit-Reset\": str(\n                int(now.timestamp()) + self.window_seconds\n            ),\n        }\n```\n\n## Best Practices\n```\nRate Limiting Best Practices:\n\n1. Choose appropriate algorithm\n   - Fixed window: simple, forgiving\n   - Sliding window: more accurate\n   - Token bucket: burst handling\n\n2. Use tiered limits\n   - Different limits for different users\n   - Public vs authenticated\n\n3. Return proper headers\n   - X-RateLimit-Limit\n   - X-RateLimit-Remaining\n   - X-RateLimit-Reset\n   - Retry-After\n\n4. Handle exceeded gracefully\n   - Clear error messages\n   - Appropriate retry headers\n\n5. Monitor and alert\n   - Track rate limit hits\n   - Alert on unusual patterns\n\n6. Distribute across instances\n   - Use shared storage (Redis)\n   - Consistent hashing\n\n7. Consider endpoint-specific\n   - Different limits per endpoint\n   - Expensive operations get lower limits\n\n8. Allow some burst\n   - Users expect occasional bursts\n   - Token bucket handles this well\n\n9. Test rate limiting\n   - Verify limits are enforced\n   - Test header values\n\n10. Document limits\n    - API documentation\n    - Developer portal\n```\n",{"name":5,"license":15,"metadata":29,"description":7,"compatibility":21},{"audience":30,"category":20},"developers","main","2ea764e153842704d24a2e9aa4170441a7f03081",".opencode\u002Fskills\u002Frate-limiting","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito","https:\u002F\u002Fgithub.com\u002FNeuralBlitz","nuralnexus.org","Theoretical and Futuristic AI Nerd 🤓 ","2026-04-21 14:37:05",{"source":8,"skillName":5,"commands":40,"prompt":50,"zipAvailable":51},[41,44,47],{"tool":42,"command":43},"npx","npx skills add NeuralBlitz\u002FMito --skill rate-limiting",{"tool":45,"command":46},"bunx","bunx skills add NeuralBlitz\u002FMito --skill rate-limiting",{"tool":48,"command":49},"pnpm","pnpm dlx skills add NeuralBlitz\u002FMito --skill rate-limiting","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Frate-limiting\u002FSKILL.md",true,[],[54,70,82,94,102,127],{"skillNo":55,"name":56,"nameZh":6,"description":57,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":58,"categories":59,"keywords":60,"publishedAt":24},"01M6HAZSAQK1S27CEZYAYJTQDX","wireless-communications","Wireless systems, mobile networks, and 5G\u002F6G","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fwireless-communications\u002FSKILL.md",[],[61,62,63,64,65,66,67,68,21,69],"communications","wireless communications","wireless","systems","engineering","networks","5G","students","mobile",{"skillNo":71,"name":72,"nameZh":6,"description":73,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":76,"publishedAt":24},"01M6HAZFX6E8NK3WZWDX5YCKYY","websockets","WebSocket implementation and best practices","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fwebassembly\u002Fwebsockets\u002FSKILL.md",[],[72,77,78,22,21,79,80,81],"websocket implementation","time","real-time","websocket","best practices",{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":24},"01M6HAZ6DAXBQ7QHXXM1EM7715","vulnerability-auditing","Vulnerability assessment and auditing","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvulnerability-auditing\u002FSKILL.md",[],[89,90,20,91,21,92,93],"vulnerability","vulnerability auditing","vulnerability assessment","cybersecurity","assessment",{"skillNo":95,"name":96,"nameZh":6,"description":97,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":98,"categories":99,"keywords":100,"publishedAt":24},"01M6HAZ3FKF3CS9Z3J96RVE2ZE","vulnerability-assessment","Finding and assessing security vulnerabilities","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvue\u002Fvulnerability-assessment\u002FSKILL.md",[],[91,89,93,20,101,21],"vulnerabilities",{"skillNo":103,"name":104,"nameZh":6,"description":105,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":106,"categories":107,"keywords":118,"publishedAt":24},"01M6HAYSHM6HKRKEHFP0SGZQX7","vlsi-design","Very-Large-Scale Integration circuit design and semiconductor engineering","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvlsi-design\u002FSKILL.md",[108,113],{"categoryNo":109,"categoryName":110,"taxonomyType":111,"taxonomyTypeDesc":112},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":114,"categoryName":115,"taxonomyType":116,"taxonomyTypeDesc":117},"01JBSEEDCAT000000000000032","设计师","PROFESSION","适用职业",[119,120,121,122,123,65,124,21,125,68,126],"vlsi design","VLSI","design","hardware","integration","computer","scale","circuit",{"skillNo":128,"name":129,"nameZh":6,"description":130,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":131,"categories":132,"keywords":133,"publishedAt":24},"01M6HAYPQ30FFE2JXD7WQJ8R6C","unsupervised","Unsupervised learning concepts","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvisualization\u002Funsupervised\u002FSKILL.md",[],[129,134,21,135,136,137,138,139],"learning","intelligence","unsupervised learning","machine","concepts","machine-learning"]