[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6EE9ETSR0X91X3E2GGG2P9P":3,"skill-same:01M6EE9ETSR0X91X3E2GGG2P9P":62},{"skillNo":4,"name":5,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":22,"publishedAt":25,"linkOnly":26,"markdownContent":27,"markdownBody":27,"frontMatter":28,"refName":29,"commitSha":30,"skillDirectory":31,"forksCount":32,"repositoryHtmlUrl":33,"repositoryHomepageUrl":34,"ownerHtmlUrl":35,"ownerBlogUrl":6,"ownerDescription":36,"updatedAt":37,"install":38,"resources":51},"01M6EE9ETSR0X91X3E2GGG2P9P","agent-memory",null,"ComeOnOliver\u002Fskillshub","ComeOnOliver","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F43215937?v=4","01M6E5JNFECJAAVFE0W7SMWWD2","Haoran Shu","01M6E5JNNDQS7AJZDYFQ8TPZCK",67,"MIT","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002FTerminalSkills\u002Fskills\u002Fagent-memory\u002FSKILL.md",[17],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[23,24],"memory","agent memory","2026-11-10 10:12:30",false,"# Agent Memory\n\n## Overview\n\nAI agents forget everything between sessions. This skill builds persistent memory systems — from simple file-based approaches to full vector-search architectures — so agents retain context, learn from past interactions, and make better decisions over time.\n\n## When to Use\n\n- User wants the agent to remember decisions, preferences, or project context\n- Building a coding assistant that needs to recall past conversations\n- Creating a knowledge base the agent can query semantically\n- Agent needs to learn from mistakes and not repeat them\n- Implementing memory consolidation (daily notes → long-term memory)\n\n## Instructions\n\n### Strategy 1: File-Based Memory (Zero Dependencies)\n\nThe simplest approach — write memories to structured markdown files. No database, no embeddings, no API keys. Works with any agent that can read\u002Fwrite files.\n\n#### Architecture\n\n```\nmemory\u002F\n├── MEMORY.md              # Long-term curated knowledge\n├── 2026-02-24.md          # Daily session logs\n├── 2026-02-23.md\n├── entities\u002F\n│   ├── projects.md        # Known projects and their state\n│   ├── people.md          # People, preferences, relationships\n│   └── decisions.md       # Key decisions and reasoning\n└── heartbeat-state.json   # Periodic check state\n```\n\n#### Memory File Format\n\n```markdown\n# MEMORY.md — Long-Term Agent Memory\n\n## Projects\n### Terminal Skills\n- Repo: https:\u002F\u002Fgithub.com\u002FTerminalSkills\u002Fskills\n- Stack: Next.js, TypeScript\n- Status: Active, 295 skills published\n- Key decision: Use-cases always come first, skills serve use-cases\n\n## Preferences\n- Language: TypeScript over JavaScript\n- Testing: Vitest over Jest\n- Deployment: Vercel for frontend, Railway for backend\n\n## Lessons Learned\n- Sub-agents limited to 5-6 tasks max (context window overflow at 10+)\n- Always check for duplicates before creating new content\n- Git branches from upstream\u002Fmain, never local main\n```\n\n#### Implementation\n\n```python\n# agent_memory.py — File-based agent memory with search\n\"\"\"\nFile-based memory system for AI agents.\nStores memories as structured markdown, supports fuzzy search\nacross all memory files without any external dependencies.\n\"\"\"\nimport os\nimport re\nfrom datetime import datetime, timedelta\nfrom pathlib import Path\nfrom typing import Optional\n\nclass FileMemory:\n    \"\"\"Persistent file-based memory for AI agents.\"\"\"\n\n    def __init__(self, memory_dir: str = \"memory\"):\n        self.memory_dir = Path(memory_dir)\n        self.memory_dir.mkdir(parents=True, exist_ok=True)\n        self.long_term_file = self.memory_dir \u002F \"MEMORY.md\"\n        self.entities_dir = self.memory_dir \u002F \"entities\"\n        self.entities_dir.mkdir(exist_ok=True)\n\n    def log_today(self, content: str, section: str = \"Notes\") -> str:\n        \"\"\"Append to today's daily log file.\n\n        Args:\n            content: The memory content to log\n            section: Section header within the daily file\n\n        Returns:\n            Path to the updated file\n        \"\"\"\n        today = datetime.now().strftime(\"%Y-%m-%d\")\n        daily_file = self.memory_dir \u002F f\"{today}.md\"\n\n        if not daily_file.exists():\n            daily_file.write_text(f\"# {today}\\n\\n\")\n\n        with open(daily_file, \"a\") as f:\n            f.write(f\"\\n## {section}\\n{content}\\n\")\n\n        return str(daily_file)\n\n    def remember(self, key: str, value: str, category: str = \"General\") -> None:\n        \"\"\"Store a key-value memory in long-term storage.\n\n        Args:\n            key: Short identifier for the memory\n            value: The content to remember\n            category: Section to file it under (Projects, Preferences, etc.)\n        \"\"\"\n        content = self.long_term_file.read_text() if self.long_term_file.exists() else \"# Long-Term Memory\\n\"\n\n        # Find or create category section\n        section_header = f\"## {category}\"\n        if section_header not in content:\n            content += f\"\\n{section_header}\\n\"\n\n        # Append the memory entry\n        entry = f\"- **{key}**: {value}\\n\"\n        insert_pos = content.index(section_header) + len(section_header) + 1\n        content = content[:insert_pos] + entry + content[insert_pos:]\n\n        self.long_term_file.write_text(content)\n\n    def search(self, query: str, max_results: int = 10) -> list[dict]:\n        \"\"\"Search all memory files for relevant content.\n\n        Args:\n            query: Search terms (supports multiple words)\n            max_results: Maximum number of matching lines to return\n\n        Returns:\n            List of dicts with 'file', 'line_number', 'content', 'score'\n        \"\"\"\n        terms = query.lower().split()\n        results = []\n\n        for md_file in self.memory_dir.rglob(\"*.md\"):\n            lines = md_file.read_text().splitlines()\n            for i, line in enumerate(lines):\n                line_lower = line.lower()\n                score = sum(1 for term in terms if term in line_lower)\n                if score > 0:\n                    results.append({\n                        \"file\": str(md_file.relative_to(self.memory_dir)),\n                        \"line_number\": i + 1,\n                        \"content\": line.strip(),\n                        \"score\": score \u002F len(terms),  # Normalize 0-1\n                    })\n\n        results.sort(key=lambda x: x[\"score\"], reverse=True)\n        return results[:max_results]\n\n    def get_recent_context(self, days: int = 3) -> str:\n        \"\"\"Load recent daily logs for context injection.\n\n        Args:\n            days: Number of recent days to include\n\n        Returns:\n            Combined content from recent daily files\n        \"\"\"\n        context_parts = []\n        for i in range(days):\n            date = (datetime.now() - timedelta(days=i)).strftime(\"%Y-%m-%d\")\n            daily_file = self.memory_dir \u002F f\"{date}.md\"\n            if daily_file.exists():\n                context_parts.append(daily_file.read_text())\n\n        return \"\\n---\\n\".join(context_parts)\n\n    def consolidate(self) -> str:\n        \"\"\"Review recent daily logs and extract key learnings into long-term memory.\n\n        Returns:\n            Summary of what was consolidated\n        \"\"\"\n        recent = self.get_recent_context(days=7)\n        # In practice, you'd send this to an LLM to extract key points\n        # Here we return the raw content for manual review\n        return f\"Review these notes and update MEMORY.md:\\n\\n{recent}\"\n```\n\n### Strategy 2: SQLite + Embeddings (Local Vector Search)\n\nFor agents that need semantic search — \"find memories similar to X\" rather than keyword matching. Uses SQLite for zero-infrastructure persistence and OpenAI embeddings for semantic similarity.\n\n```typescript\n\u002F\u002F memory-store.ts — SQLite-backed semantic memory with vector search\n\u002F**\n * Semantic memory store using SQLite + OpenAI embeddings.\n * Stores memories with vector embeddings for similarity search.\n * No external database required — everything in a single .db file.\n *\u002F\nimport Database from \"better-sqlite3\";\nimport OpenAI from \"openai\";\n\ninterface Memory {\n  id: number;\n  content: string;\n  category: string;\n  embedding: number[];\n  created_at: string;\n  metadata: Record\u003Cstring, unknown>;\n}\n\ninterface SearchResult {\n  content: string;\n  category: string;\n  similarity: number;\n  created_at: string;\n}\n\nexport class MemoryStore {\n  private db: Database.Database;\n  private openai: OpenAI;\n  private model = \"text-embedding-3-small\"; \u002F\u002F $0.02\u002F1M tokens\n\n  constructor(dbPath: string = \"agent-memory.db\") {\n    this.db = new Database(dbPath);\n    this.openai = new OpenAI();\n    this.initSchema();\n  }\n\n  private initSchema(): void {\n    this.db.exec(`\n      CREATE TABLE IF NOT EXISTS memories (\n        id INTEGER PRIMARY KEY AUTOINCREMENT,\n        content TEXT NOT NULL,\n        category TEXT DEFAULT 'general',\n        embedding BLOB,                    -- Serialized float32 array\n        metadata TEXT DEFAULT '{}',        -- JSON metadata\n        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP\n      );\n      CREATE INDEX IF NOT EXISTS idx_category ON memories(category);\n      CREATE INDEX IF NOT EXISTS idx_created ON memories(created_at);\n    `);\n  }\n\n  \u002F**\n   * Store a memory with its embedding vector.\n   *\u002F\n  async store(content: string, category: string = \"general\", metadata: Record\u003Cstring, unknown> = {}): Promise\u003Cnumber> {\n    const embedding = await this.embed(content);\n    const embeddingBlob = Buffer.from(new Float32Array(embedding).buffer);\n\n    const result = this.db.prepare(`\n      INSERT INTO memories (content, category, embedding, metadata)\n      VALUES (?, ?, ?, ?)\n    `).run(content, category, embeddingBlob, JSON.stringify(metadata));\n\n    return result.lastInsertRowid as number;\n  }\n\n  \u002F**\n   * Semantic search — find memories most similar to the query.\n   * Uses cosine similarity between embedding vectors.\n   *\u002F\n  async search(query: string, limit: number = 5, category?: string): Promise\u003CSearchResult[]> {\n    const queryEmbedding = await this.embed(query);\n\n    let rows = this.db.prepare(\n      category\n        ? `SELECT content, category, embedding, created_at FROM memories WHERE category = ? ORDER BY created_at DESC LIMIT 1000`\n        : `SELECT content, category, embedding, created_at FROM memories ORDER BY created_at DESC LIMIT 1000`\n    ).all(...(category ? [category] : [])) as Array\u003C{\n      content: string; category: string; embedding: Buffer; created_at: string;\n    }>;\n\n    \u002F\u002F Calculate cosine similarity for each memory\n    const scored = rows.map((row) => {\n      const memoryEmbedding = Array.from(new Float32Array(row.embedding.buffer));\n      const similarity = this.cosineSimilarity(queryEmbedding, memoryEmbedding);\n      return { content: row.content, category: row.category, similarity, created_at: row.created_at };\n    });\n\n    scored.sort((a, b) => b.similarity - a.similarity);\n    return scored.slice(0, limit);\n  }\n\n  private async embed(text: string): Promise\u003Cnumber[]> {\n    const response = await this.openai.embeddings.create({\n      model: this.model,\n      input: text,\n    });\n    return response.data[0].embedding;\n  }\n\n  private cosineSimilarity(a: number[], b: number[]): number {\n    let dot = 0, normA = 0, normB = 0;\n    for (let i = 0; i \u003C a.length; i++) {\n      dot += a[i] * b[i];\n      normA += a[i] * a[i];\n      normB += b[i] * b[i];\n    }\n    return dot \u002F (Math.sqrt(normA) * Math.sqrt(normB));\n  }\n}\n```\n\n### Strategy 3: ChromaDB Vector Database (Production Scale)\n\nFor agents handling thousands of memories or needing advanced filtering. ChromaDB runs locally or as a service, handles embedding and search automatically.\n\n```python\n# chroma_memory.py — Production agent memory with ChromaDB\n\"\"\"\nVector-based agent memory using ChromaDB.\nHandles embedding generation, similarity search, and metadata filtering.\nScales to millions of memories with persistent storage.\n\"\"\"\nimport chromadb\nfrom chromadb.config import Settings\nfrom datetime import datetime\nfrom typing import Optional\n\nclass ChromaMemory:\n    \"\"\"Production-grade agent memory backed by ChromaDB.\"\"\"\n\n    def __init__(self, persist_dir: str = \".\u002Fchroma_db\", collection_name: str = \"agent_memory\"):\n        self.client = chromadb.PersistentClient(\n            path=persist_dir,\n            settings=Settings(anonymized_telemetry=False)\n        )\n        self.collection = self.client.get_or_create_collection(\n            name=collection_name,\n            metadata={\"hnsw:space\": \"cosine\"}  # Cosine similarity for search\n        )\n\n    def store(self, content: str, category: str = \"general\",\n              metadata: Optional[dict] = None) -> str:\n        \"\"\"Store a memory with automatic embedding.\n\n        Args:\n            content: Text content to remember\n            category: Category for filtering (project, preference, lesson, etc.)\n            metadata: Additional metadata (source, confidence, etc.)\n\n        Returns:\n            Generated memory ID\n        \"\"\"\n        memory_id = f\"mem_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}\"\n        meta = {\n            \"category\": category,\n            \"created_at\": datetime.now().isoformat(),\n            **(metadata or {})\n        }\n\n        self.collection.add(\n            documents=[content],\n            metadatas=[meta],\n            ids=[memory_id]\n        )\n        return memory_id\n\n    def recall(self, query: str, n_results: int = 5,\n               category: Optional[str] = None) -> list[dict]:\n        \"\"\"Semantic search for relevant memories.\n\n        Args:\n            query: Natural language query\n            n_results: Number of results to return\n            category: Optional category filter\n\n        Returns:\n            List of matching memories with similarity scores\n        \"\"\"\n        where_filter = {\"category\": category} if category else None\n\n        results = self.collection.query(\n            query_texts=[query],\n            n_results=n_results,\n            where=where_filter,\n            include=[\"documents\", \"metadatas\", \"distances\"]\n        )\n\n        memories = []\n        for doc, meta, dist in zip(\n            results[\"documents\"][0],\n            results[\"metadatas\"][0],\n            results[\"distances\"][0]\n        ):\n            memories.append({\n                \"content\": doc,\n                \"category\": meta.get(\"category\"),\n                \"similarity\": 1 - dist,  # Convert distance to similarity\n                \"created_at\": meta.get(\"created_at\"),\n            })\n\n        return memories\n\n    def forget(self, memory_id: str) -> None:\n        \"\"\"Delete a specific memory.\n\n        Args:\n            memory_id: ID of the memory to remove\n        \"\"\"\n        self.collection.delete(ids=[memory_id])\n\n    def count(self) -> int:\n        \"\"\"Return total number of stored memories.\"\"\"\n        return self.collection.count()\n```\n\n## Examples\n\n### Example 1: Add persistent memory to a Claude Code agent\n\n**User prompt:** \"Set up a memory system for my coding agent so it remembers project decisions, coding preferences, and lessons learned between sessions.\"\n\nThe agent will:\n\n- Create a `memory\u002F` directory structure with MEMORY.md, daily logs, and entity files\n- Implement the FileMemory class with search and consolidation\n- Add session start hook that loads recent context (last 3 days + long-term memory)\n- Add session end hook that saves key decisions and new information\n- Set up periodic consolidation from daily logs into long-term memory\n\n### Example 2: Build semantic search over past conversations\n\n**User prompt:** \"I want my agent to search past conversations by meaning, not just keywords. It should find relevant memories even if the exact words don't match.\"\n\nThe agent will:\n\n- Set up SQLite database with embedding storage\n- Configure OpenAI text-embedding-3-small for low-cost vector generation\n- Build search function with cosine similarity ranking\n- Add automatic memory extraction from conversation turns\n- Implement relevance threshold to avoid surfacing weak matches\n\n### Example 3: Scale agent memory for a production chatbot\n\n**User prompt:** \"Build a memory system that can handle 100K+ memories for our customer support bot. It needs to remember past tickets, solutions, and customer preferences.\"\n\nThe agent will:\n\n- Deploy ChromaDB with persistent storage\n- Design memory schema: categories for tickets, solutions, customer prefs, product docs\n- Implement metadata filtering for fast category-scoped queries\n- Add memory deduplication to prevent storing near-identical entries\n- Build memory aging — reduce relevance weight for old memories\n\n## Guidelines\n\n- **Start with file-based memory** — it works everywhere, has zero dependencies, and is human-readable\n- **Use embeddings when keyword search fails** — \"deployment issues\" should find \"CI\u002FCD pipeline broken\"\n- **Consolidate regularly** — daily logs accumulate noise; distill into long-term memory weekly\n- **Category separation matters** — searching \"preferences\" shouldn't return \"bug reports\"\n- **Set memory limits** — without pruning, memory grows until it overwhelms context windows\n- **Privacy by default** — never store API keys, passwords, or PII in memory files\n- **Test recall quality** — bad embeddings return irrelevant results; validate with real queries\n- **Embedding cost** — text-embedding-3-small is $0.02\u002F1M tokens; budget ~1M tokens\u002Fmonth for active agents\n- **ChromaDB vs Pinecone** — use ChromaDB for local\u002Fself-hosted, Pinecone for managed cloud at scale\n- **Memory injection** — prepend relevant memories to agent system prompt, not user messages\n",{},"main","def8531e65114c0fca8fb8551c1871ee0eed705c","skills\u002FTerminalSkills\u002Fskills\u002Fagent-memory",24,"https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub","https:\u002F\u002Fskillshub.wtf","https:\u002F\u002Fgithub.com\u002FComeOnOliver","AI & Blockchain Engineer\r\n","2026-06-24 22:07:19",{"source":7,"skillName":5,"commands":39,"prompt":49,"zipAvailable":50},[40,43,46],{"tool":41,"command":42},"npx","npx skills add ComeOnOliver\u002Fskillshub --skill agent-memory",{"tool":44,"command":45},"bunx","bunx skills add ComeOnOliver\u002Fskillshub --skill agent-memory",{"tool":47,"command":48},"pnpm","pnpm dlx skills add ComeOnOliver\u002Fskillshub --skill agent-memory","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002FTerminalSkills\u002Fskills\u002Fagent-memory\u002FSKILL.md",true,[52,58],{"path":53,"resourceType":54,"resourceTypeDesc":55,"sizeBytes":56,"sourceHtmlUrl":57},"scripts\u002Flist_customizable_skills.py","SCRIPT","脚本",8061,"https:\u002F\u002Fgithub.com\u002Fjsacko\u002FOpenDFIR\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fbmad-customize\u002Fscripts\u002Flist_customizable_skills.py",{"path":59,"resourceType":54,"resourceTypeDesc":55,"sizeBytes":60,"sourceHtmlUrl":61},"scripts\u002Ftests\u002Ftest_list_customizable_skills.py",9245,"https:\u002F\u002Fgithub.com\u002Fjsacko\u002FOpenDFIR\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fbmad-customize\u002Fscripts\u002Ftests\u002Ftest_list_customizable_skills.py",[63,73,83,92,98,105],{"skillNo":64,"name":65,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":69,"publishedAt":25},"01M6FKJN13GMG4KY57J3QD8GY5","model-hierarchy-skill","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzscole\u002Fmodel-hierarchy-skill\u002Fmodel-hierarchy-skill\u002FSKILL.md",[68],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},[70,71,72],"model","model hierarchy","model hierarchy skill",{"skillNo":74,"name":75,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":79,"publishedAt":25},"01M6FKJJJ6GCAMR4PPPRD12M5X","zoom-mcp","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-mcp\u002FSKILL.md",[78],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},[80,81,82],"MCP","zoom","zoom mcp",{"skillNo":84,"name":85,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":25},"01M6FKJE3KYT3KPEZMEEHYKA6K","zoom-apps-sdk","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-apps-sdk\u002FSKILL.md",[],[89,90,91,81],"sdk","zoom apps sdk","apps",{"skillNo":93,"name":94,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":95,"categories":96,"keywords":97,"publishedAt":25},"01M6FKJ9EDH9Q5VWDF8HAJRSP0","windows","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwindows\u002FSKILL.md",[],[94],{"skillNo":99,"name":100,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":101,"categories":102,"keywords":104,"publishedAt":25},"01M6FKJ666BEEFC3AE9GJ72Q93","whiteboard","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwhiteboard\u002FSKILL.md",[103],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},[100],{"skillNo":106,"name":107,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":108,"categories":109,"keywords":110,"publishedAt":25},"01M6FKJ21WFCDGTJQ2Q91T9DVW","websockets","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwebsockets\u002FSKILL.md",[],[107]]