Semantic Web Fetch
alps-asd/semantic-web-fetch
Lê HTML conforme seu perfil semântico declarado, sem inferências
Ver no GitHubSkill que lê páginas web respeitando o perfil semântico que elas declaram (ALPS, RDFa, microdata, schema.org). Extrai significado baseado na autoridade declarada, não em inferência, e recupera affordances de operações HTTP que a renderização superficial perde.
Instalação
npx convez-ai alps-asd/semantic-web-fetch1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Extrair dados estruturados de APIs que usam ALPS ou RDFa
- Integrar web scraping semântico em agents que precisam de dados com autoridade declarada
- Processar documentos HTML com perfis complexos mantendo precisão de significado
Veredito

Ferramenta sofisticada para quem trabalha com web semântica e precisa de leitura confiável além da superfície. Excelente para arquiteturas que usam ALPS ou microdata; curva de aprendizado íngreme.
README
A tradução para o português deste README ainda está na fila.
semantic-web-fetch
A Claude Skill plugin for profile-declared HTML.
semantic-web-fetchreads a web page in conformance with the profile it declares about itself — deferring the authority over meaning to that declaration instead of inferring it from the rendered surface.semantic-web-writewrites human-readable HTML artifacts that also declare a semantic profile, so tools can read the result as raw HTML plus its profile instead of guessing from the surface.
The three principles
- Authority — meaning is grounded in the declared profile, not in Claude's contextual inference.
- Binding — only elements that can be bound to declared descriptors count as grounds for
meaning;
defreferences (e.g. to schema.org) are followed and included as authority. - No inferred bindings — elements absent from the profile are reported as unbound, never filled in by inference.
The skill also recovers affordances the extracted surface loses: which links are operations, of what kind (safe / idempotent / unsafe), and which state each transitions to.
The write-side counterpart
semantic-web-write is the companion skill for producing profile-declared HTML. Given data or
source material, it helps generate:
- a static HTML artifact with visual hierarchy, navigation, tables, diagrams, or lightweight interaction when HTML is more useful than Markdown
- an ALPS profile that defines the document vocabulary
- a
<link rel="profile" href="...">declaration in the HTML - stable bindings from meaningful elements to descriptor IDs via classes or attributes
- a small local validation pass for
rel="profile", representative descriptor bindings, nested parent-child bindings, duplicate IDs, undefineddata-semanticvalues, and optional coverage warnings - a self-review gate so substantial artifacts are revised after the first valid draft
For ALPS profile authoring itself, use the alps skill from
alps-asd/alps-skills when available. This repository's
write-side skill focuses on the HTML/profile binding contract and local paired-file validation.
ALPS profiles should be checked with asd --validate before finalizing when asd is available.
The result should be readable in two ways: humans read the HTML; agents read the raw HTML through
the declared profile. See
docs/examples/semantic-web-write-report.html and
docs/examples/semantic-web-write-report.alps.json
for a minimal paired example.
For a fuller demo, see the
Cache-Control directive index and its
ALPS profile. It uses a plain report/table style
for source-backed technical reference material.
The same row, read both ways
Row HV·001 of the demo. What the surface yields as plain text:
Brass Astrolabe — made 1710, originated in Florence, maker G. Vanni, Featured. Links: the name, and Reserve.
Conformed to the declared profile:
Brass Astrolabe (
itemTitle).entryDate= 1710 → the date it was listed in the catalogue (datePublished), not when it was made; the period of manufacture is absent from the page.displayCity= Florence → the current showroom (contentLocation), not origin; origin is absent.makerNote= G. Vanni. "Featured" → unbound (decorative). Affordances:goRecord(safe, view → record page) andreserveObject(unsafe,ReserveAction→ reservation hold).
Same bytes over the wire; opposite conclusions about what is true, what is missing, and what is safe to click. The point isn't that Claude cannot guess — it often guesses right — but that guessing and trusting are different layers.
いつ起動するか
The skill should trigger when a page declares a profile with rel="profile", or when the user asks
to read a URL by a declared semantic vocabulary such as ALPS, microformats, RDFa, microdata, or
schema.org.
Natural prompts include:
https://example.com/page の意味を読んでhttps://example.com/page のALPSを読んでRead this page in conformance with its declared profile.Read it as raw HTML plus its profile. Do not fill gaps by inference.
The short Japanese phrases "URLの意味を読んで" and "URLのALPSを読んで" are intentional: "meaning" here refers to the profile's authority over meaning, not Claude's contextual guess.
Try it (no install)
Clone the repo and load it as a plugin for one session of Claude Code:
git clone https://github.com/alps-asd/semantic-web-fetch
claude --plugin-dir ./semantic-web-fetch
Then, inside Claude, point at the demo (an instrument catalogue whose surface deliberately lies):
https://alps-asd.github.io/semantic-web-fetch/
Read this page in conformance with its declared profile. Do not fill gaps by inference.
Claude should fetch both index.html and registry.alps.json, then report in the declared
structure / bindings / transitions / unbound form. If the answer treats "1710" as a manufacture
date or "Florence" as a place of origin, the skill did not fire.
For a real ALPS-marked page in the wild, try the same prompt against the Vermeer works
list, which declares <link rel="profile" href="vermeer.alps.json"> in its head.
Install (keep it across sessions)
Codex
From the Codex CLI, add this repository as a marketplace and install the plugin:
codex plugin marketplace add https://github.com/alps-asd/semantic-web-fetch.git
codex plugin add semantic-web-fetch@semantic-web-fetch
Start a new Codex session after installing so the skill metadata is loaded.
Claude Code
This repo is its own plugin marketplace. Inside Claude Code, run these three slash commands one at a time (each on its own submission — pasting all three together makes Claude Code treat the later lines as arguments to the first):
/plugin marketplace add https://github.com/alps-asd/semantic-web-fetch.git— register the marketplace/plugin install semantic-web-fetch@semantic-web-fetch— install the plugin, including bothsemantic-web-fetchandsemantic-web-write/reload-plugins— activate it
(The shorter owner/repo form resolves to SSH and requires a GitHub-registered SSH key; the
explicit HTTPS URL above clones over HTTPS and works without one.)
Claude.ai
Upload semantic-web-fetch.skill or semantic-web-write.skill (the packaged archives at the repo
root) via your account's skill management UI.
Claude Agent SDK
Register skills/semantic-web-fetch/SKILL.md and/or
skills/semantic-web-write/SKILL.md via the SDK's skill
loader.
Trust boundary
The profile holds authority over meaning, not trust. Two failure modes follow:
- Dereferencing on attacker-chosen input. Following
rel="profile"anddeffetches URLs the page picked. Restrict tohttp/https, refuse loopback/link-local/private addresses andfile:/data:, and surface unexpected cross-origin targets before following them. type: safeis a claim, not a guarantee. A hostile page can mislabel a state-changing action as safe. Reporttypeas declared, cross-check independent signals, and require explicit confirmation before any state-changing action regardless of label.
On llms.txt
This repository ships neither llms.txt nor llms-full.txt. The read-side skill's whole claim is that a
pre-digested Markdown dump loses what a declared profile preserves; carrying that very kind of
dump for our own content would undercut the claim. The demo (index.html) declares its own ALPS
profile; the docs are short, plain Markdown and render as-is.
Background
Inspired by ALPS (Application-Level Profile Semantics) and by
ALPS-marked pages such as the Vermeer works list above, where class names are descriptor IDs
linked to schema.org via def.