convez.ai
SkillIntegração & APIsAvançado
alps-asd

Semantic Web Fetch

alps-asd/semantic-web-fetch

Lê HTML conforme seu perfil semântico declarado, sem inferências

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill 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-fetch

1 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

Estrelas
0
Forks
0
Acompanhando
0
Saúde
50%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
2

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-fetch reads 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-write writes 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

  1. Authority — meaning is grounded in the declared profile, not in Claude's contextual inference.
  2. Binding — only elements that can be bound to declared descriptors count as grounds for meaning; def references (e.g. to schema.org) are followed and included as authority.
  3. 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, undefined data-semantic values, 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) and reserveObject (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):

  1. /plugin marketplace add https://github.com/alps-asd/semantic-web-fetch.git — register the marketplace
  2. /plugin install semantic-web-fetch@semantic-web-fetch — install the plugin, including both semantic-web-fetch and semantic-web-write
  3. /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" and def fetches URLs the page picked. Restrict to http/https, refuse loopback/link-local/private addresses and file:/data:, and surface unexpected cross-origin targets before following them.
  • type: safe is a claim, not a guarantee. A hostile page can mislabel a state-changing action as safe. Report type as 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.

Ver o original no GitHub

Bom para

Relacionados