Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Knowledge Adapter

    1

    Turns one sentence — "I want to learn diffusion models" — into a curated set of papers, tutorials and repos, then renders a self-contained multi-chapter HTML course with MathJax derivations, quizzes and dark-mode toggle.

    Free

    Security scanned
    knowledge-adapter

    knowledge-adapter

    Example session with this skill installed

    I want to properly learn video generation models — I've seen Sora demos but I don't
    actually understand how any of this works under the hood.

    Can you collect the foundational papers on video generation, plus a hands-on tutorial
    and the main open-source implementation, then build me a tutorial I can work through
    end to end? I'm comfortable with calculus and linear algebra but I haven't done
    probability in a while, so tell me upfront what I should brush up on rather than
    teaching it to me.

    I want to actually be tested on whether I understood it, not just read through it.

    • Read your context and instructions
    • Compiled the knowledge-adapter

    Collected 7 materials for "video generation models"

    #TypeMaterialWhy this one
    1PaperVideo Diffusion Models (Ho et al., 2022)Foundational — first general video diffusion framework
    2PaperMake-A-Video (Meta, 2022)Trains text-to-video without paired text-video data
    3PaperDiT: Scalable Diffusion with Transformers (2023)Replaces U-Net with a transformer backbone; the architectural basis for Sora
    4PaperAlign your Latents / Video LDM (2023)Latent-space video diffusion; precursor to Stable Video Diffusion
    5PaperAnimateDiff (2023)Image-to-video via plug-in motion module; most practical of the five
    6TutorialText to Video Generation with HuggingFace DiffusersRunnable AnimateDiff walkthrough
    7Repoguoyww/AnimateDiff (12.2k stars)Official implementation — README + core source, shallow clone

    Downloaded as arXiv e-print source packages: 5 × .tex + .bib + figures/,
    not PDFs. Output at target/papers/, target/tutorials/, target/repos/.
    Manifest: harvest_manifest.json.


    Built a 10-chapter course — tutorial/

    Prerequisite self-check (listed on the index page, not taught):

    SubjectYou should be comfortable with
    CalculusDerivatives, gradient ∇, chain rule, partial derivatives
    ProbabilityRandom variables, Gaussian distribution, expectation & variance, conditional probability, sampling
    Linear algebraVectors, matrices, matrix multiplication, norms
    ML basicsLoss functions, gradient descent, backpropagation

    Chapter outline

    #ChapterLevelTime
    1Video generation primer: task, pipeline, symbol table🟢30 min
    2Diffusion fundamentals: DDPM and denoising score matching🟢32 min
    3Latent diffusion and the U-Net backbone🟢32 min
    4Transformers, ViT and LoRA🟢32 min
    5VDM: a space-time factorized 3D U-Net🟡34 min
    6Make-A-Video: pseudo-3D without video data🟡32 min
    7DiT: replacing the U-Net with a transformer🟡32 min
    8Video LDM: temporal layers over a frozen image model🟡34 min
    9AnimateDiff: motion module and LoRA🔴32 min
    10Comparing the five approaches🟣20 min

    Total ~310 minutes.

    What each chapter contains

    第5章: 视频扩散模型 VDM——时空分解的 3D U-Net        ← nav: prev / index / next / 🌙
    ⏱ ~34 分钟   🟡 进阶   前置: 第2、3章
    
    📝 前置小测 — 3 questions, each with a toggle answer
       Q1: 为什么把 2D 卷积改成 1×3×3 就能处理视频?
       Q2: 时序注意力与空间注意力的 batch 轴有何不同?
    
    📖 教学内容
       5.1 从图像扩散到视频扩散
           The 2D U-Net from Chapter 3 processes one frame. To handle a video we
           keep the spatial path unchanged and add a second, orthogonal path over time.
    
           $$(f * g)[i,j] = \sum_m \sum_n f[i+m, j+n] \cdot g[m,n]$$
    
           💡 Key point — factorized space-time attention: spatial attention treats
              the frame axis as batch; temporal attention treats the spatial axes as
              batch. Cost stays linear in frames instead of quadratic.
    
       5.2 联合训练图像与视频
           ⚠ Masking the temporal attention turns the model back into an image model,
             which is what makes joint image-video training possible at all.
    
           🔍 Reconstruction-guided sampling (click to expand)
              Step 1 — the replacement method substitutes exact forward-process
              samples for the conditioning block…
              Step 2 — but the score term ∇ log q(x^a | z_t) is missing, so the two
              blocks drift apart…
              Step 3 — approximating that term with a Gaussian gives
              $$\tilde{x}^b_\theta(z_t) = \hat{x}^b_\theta(z_t)
                - \frac{w_r \alpha_t}{2}\nabla_{z^b_t}\|x^a - \hat{x}^a_\theta(z_t)\|^2$$
    
           Concrete check: FVD 295 on UCF101 vs 3431 for TGAN-v2 — a 11.6× gap.
    
    ✅ 后置自测 — 4 questions, each with answer + explanation of why
    

    Files

    tutorial/
    ├── index.html          learning path, prerequisite self-check, chapter cards
    ├── chapter_01.html     … chapter_10.html
    ├── json/               content JSON per chapter — enables free re-rendering
    └── (396 KB total)
    

    Open tutorial/index.html in a browser — no server, no build step.


    Next steps

    1. Open the index page first. Check the prerequisite table against what you
      actually remember. If probability is shaky, brush up before Chapter 2 — the
      diffusion derivation assumes you're comfortable with Gaussians and expectation.
    2. Work chapters 1→10 in order. The dependency chain is real: Ch.5 assumes Ch.2
      and Ch.3; Ch.10 assumes you've read 5–9.
    3. Don't skip the quizzes. The pre-quiz tells you whether a chapter is worth
      your time; the post-quiz explanations are where the "why" lives.
    4. Want different coverage? Edit generation_input.json and re-run
      gen_chapters.py. Only want to restyle? rerender.py rebuilds all chapters
      from saved JSON with no API calls.
    
    ---
    

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Knowledge Adapter

    Most of the work in learning a new field isn't the learning — it's the material wrangling before it. Which papers actually matter? Where does this one paper sit in the field? What prerequisite am I missing? And after reading, how do I check whether it stuck?

    Knowledge Adapter automates both halves of that problem with two coordinated skills.

    What it does

    Stage 1 — topic-harvest (collect). Give it a topic in one sentence. It searches arXiv, Semantic Scholar and OpenAlex via their public APIs, ranks results by citation count, and downloads the arXiv e-print source packages (.tex + .bib + figures) rather than PDFs — much cleaner input for downstream processing. It also finds hands-on tutorials and shallow-clones the canonical open-source implementation (README + core source, not the whole repo). Collection is deliberately bounded: 4–6 papers, 2–4 tutorials, 1–2 repos. You get a ranked manifest to approve before anything expensive happens.

    Stage 2 — knowledge-adapter (teach). It reads the materials in full, extracts the concept graph, and — this is the part most tools skip — identifies prerequisites the source material uses but never explains. Those become dedicated opening chapters. The syllabus is topologically sorted and each chapter is capped at 20–35 minutes of reading.

    Every chapter follows a fixed three-part structure: pre-quiz (should you even read this?) → teaching content → post-quiz (with explanations of why, not just what).

    What you get

    Self-contained single-file HTML. CSS and JS inlined, MathJax the only CDN call. Double-click to read. Light/dark toggle in the nav bar, choice persisted in localStorage with no flash on reload. Prints cleanly.

    A real generated example (10 chapters on video generation models) ships in the repo at examples/video-generation-models/tutorial/index.html.

    Design decisions worth knowing

    Content and presentation are decoupled. The LLM produces only structured content JSON — block types are pinned by schema. A deterministic Python renderer (render_chapter.py) is the only thing that writes HTML. This exists because an earlier version let each chapter be written independently by an agent, and the chapters drifted apart: different CSS systems, different MathJax configs, different quiz markup. Now consistency is structural, not a matter of good behavior. Change a style once, every chapter updates.

    Your math background is your business. The course does not re-teach probability, calculus, linear algebra or ML fundamentals — that's a textbook's job. Instead the index page lists a "prerequisite self-check" (e.g. probability — Gaussian distribution, expectation, conditional probability) so you know what to brush up on. The course itself covers only domain knowledge: task definition, the abstract pipeline, the research landscape, and a symbol table so you know what x_t means when you meet it.

    API keys never touch the command line. CLI arguments leak into shell history and process lists. Keys come from environment variables or a chmod 600 config file — --api-key deliberately does not exist. Any OpenAI-compatible endpoint works; it is not tied to one vendor.

    Re-rendering is free. Chapter content JSON is saved to tutorial/json/. After you tweak the renderer, rerender.py rebuilds every chapter with zero LLM calls.

    Requirements

    Claude Code · Python 3.8+ · any OpenAI-compatible API (DeepSeek, OpenAI, OpenRouter, or local Ollama). pip install -r requirements.txt — only requests is required, json5 optional.

    Honest limitations

    • Phases 1–3 (material analysis, knowledge graph, syllabus design) run inside the Claude Code conversation, not as standalone scripts. Phases 4–5 are standalone Python. The full pipeline needs Claude Code.
    • Generation quality tracks the model you configure. Reasoning models produce noticeably better derivations but cost more.
    • Material relevance and download success rate have not been systematically benchmarked.

    MIT licensed.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 17 days ago

    • Free with an Agensi account

    Requires

    GitHub
    OpenAI
    Arxiv
    Deepseek
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables

    Allowed Hosts

    export.arxiv.org
    arxiv.org
    api.github.com
    api.deepseek.com
    api.openai.com
    Listed17 days ago

    What's inside

    Frequently Asked Questions

    Turns one sentence — "I want to learn diffusion models" — into a curated set of papers, tutorials and repos, then renders a self-contained multi-chapter HTML course with MathJax derivations, quizzes and dark-mode toggle.

    This skill uses the open SKILL.md standard. Use it through an MCP-compatible agent connected to Agensi, and check the compatibility information on this page for confirmed agents and required capabilities.

    Connect your AI agent to Agensi through MCP, then ask it to use knowledge-adapter on your task. Your agent loads the latest approved version each time. Paid skills require a purchase or active subscription. Skill files are not available for download; your licence does not allow you to save, copy or export any part of a skill.