What can you do with this server?

The Loreto-MCP server lets you turn YouTube videos, articles, PDFs, or images into reusable Claude Code skill packages, and manage, discover, and verify them. * generate_skills — Extract structured skill packages (SKILL.md, README.md, reference files, test scripts) from a URL. Supports options for source_type (auto, youtube, article, pdf, image), test_language (Python, TypeScript, JavaScript), include_visuals for Mermaid diagrams, context hints, and themes_to_process for follow-up extractions. Skills are ready to save to .claude/skills/ for use by Claude Code. * get_quota — Check API calls used, monthly limits, and your current plan for your Loreto API key. * list_skills — Browse all published Loreto catalog skills with compact summaries of artifacts and safety claims. No API key required. * get_skill — Fetch the full structured record for a specific catalog skill by skill_id, including artifacts, MCP metadata, safety properties, governance info, references, and FAQ. * verify_artifacts — Retrieve the provenance manifest for a past generation by generation_id, including source URL, theme plan, quality scores, artifact byte counts, and bundle SHA256. Works for both API-key and x402 pay-per-call generations; no auth required. * estimate_cost — Get a heuristic token and dollar cost estimate for generating a skill from a given source before committing to a paid generation.

Which integrations are available for this server?

Enables analyzing YouTube videos to extract reusable skill packages (principles, failure modes, implementation steps, Mermaid diagrams) for use with Claude Code.

How do I use loreto-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@loreto-mcp create a skill from this YouTube video: https://youtube.com/watch?v=abc123" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

loreto-mcp

by kopias

Overview Schema Related Servers Score Discussions

Python

Remote

loreto-mcp

Turn any YouTube video, article, PDF, or image into a reusable Claude Code skill — without leaving your editor.

What it does

Loreto analyzes a content source and extracts structured skill packages that Claude Code can apply to future tasks. Each skill contains:

SKILL.md — Principles, failure modes, implementation steps, and architectural patterns
README.md — Overview and usage context
Reference files — Supporting patterns and data structures
Test script — Runnable validation for the skill's core concepts

Save skills to .claude/skills/ and Claude picks them up automatically on relevant tasks — reducing hallucinations, token usage, and re-explaining the same concepts over and over.

Related MCP server: Claude Code Starter Kit MCP

Sample skills

Every skill Loreto generates ships as its own standalone, installable repo. These nine were generated from a single technical video on hybrid AI architecture — clone any of them directly:

Skill	What it teaches
`designing-hybrid-context-layers`	Architect hybrid retrieval systems that combine vector search, graph traversal, and structured data
`temporal-reasoning-sleuth`	Enable agents to trace decision chains and reconstruct causal sequences across long time horizons
`synthesizing-institutional-knowledge`	Capture and query organizational knowledge in a way AI agents can reliably reason over
`diagnosing-rag-failure-modes`	Classify the four structural RAG failure patterns and prescribe the right fix
`routing-work-across-ai-harnesses`	Dynamically route tasks to the right AI harness based on task type and context
`evaluating-ai-harness-dimensions`	Score and compare AI harness options across the five structural dimensions
`detecting-harness-lockin`	Spot vendor lock-in signals early and price the switching cost
`benchmarking-ai-agents-beyond-models`	Measure agent performance at the system level, not just model level
`auditing-intelligence-context-fit`	Audit whether the model's reasoning tier matches the context complexity

Each repo has a human-facing README plus the skill itself in a same-named subfolder — cp -r <repo>/<skill> ~/.claude/skills/ and Claude picks it up automatically.

Anatomy of a generated skill

You don't have to clone anything to see what Loreto produces. Every generation is a ready-to-run package — a SKILL.md (principles, failure modes, implementation steps, Mermaid diagrams), supporting references/, and a runnable tests/ script. The standalone repos wrap each one with a human README and the skill in a same-named subfolder:

designing-hybrid-context-layers/          ← public repo
├── README.md                             ← for humans, not part of the skill
└── designing-hybrid-context-layers/      ← the skill (cp into ~/.claude/skills/)
    ├── SKILL.md
    └── references/
        ├── architecture-patterns.md
        └── retrieval-decision-matrix.md

A trimmed look at the SKILL.md Loreto generated for that skill:

---
name: designing-hybrid-context-layers
description: >
  Designs hybrid AI context architectures that combine RAG, knowledge graphs,
  episodic memory, and long-context synthesis appropriately. Use when ...
---

# Designing Hybrid Context Layers

## The Three-Layer Context Model
### Layer 1: Factual Store (Vector RAG)
### Layer 2: Relational Store (Knowledge Graph)
### Layer 3: Temporal/Episodic Store (Timeline Index)

```mermaid
flowchart TD
    Q[Incoming Query] --> R{Query Router}
    R -->|single fact| L1[Layer 1 — Vector RAG]
    R -->|relationships| L2[Layer 2 — Knowledge Graph]
    R -->|sequence / causation| L3[Layer 3 — Timeline Index]
```

## Anti-Pattern: The RAG-for-Everything Trap
## Implementation Roadmap

Prefer not to leave your editor at all? The free list_skills and get_skill MCP tools return the same structured records, and verify_artifacts proves any past generation by generation_id — discover, inspect, and verify before you ever clone.

Billing — two paths, pick one

Loreto runs on two parallel billing paths. The right one depends on whether you're a human signing up or an AI agent paying per task.

	API key (`lor_...`)	x402 pay-per-call (USDC)
Best for	Humans, recurring use, teams	Agents, one-off jobs, anonymous use
Signup	Yes — loreto.io	None
Pricing	Free: 2 calls/mo · Pro: $29/mo for 100	Flat $0.75 per call, no monthly cap
Wallet needed	No	Yes — USDC on Base mainnet
MCP support	This package, out of the box	Direct REST + the x402 Python SDK
Endpoint	`POST /api/v1/skills/generate`	`POST /api/v1/skills/x402/generate`
Docs	docs-authentication	docs-x402

Path A — API key (this MCP package)

Get your key at loreto.io, set LORETO_API_KEY in your MCP config (see below), and you're done. Free tier ships immediately; upgrade to Pro when you need more.

If you're an autonomous agent, an AI workflow without persistent credentials, or a developer who just wants to try one generation, x402 is faster than signing up. The MCP package itself uses Path A — but every catalog call (list_skills, get_skill, verify_artifacts, estimate_cost) is free regardless of which path you generate skills under.

To run a generation under x402:

# Pseudocode — see https://loreto.io/docs-x402 for the full handshake
curl -X POST https://api.loreto.io/api/v1/skills/x402/generate \
  -H "X-PAYMENT: <eip-3009 signed authorization>" \
  -H "Content-Type: application/json" \
  -d '{"source": "https://www.youtube.com/watch?v=...", "source_type": "youtube"}'

The X-PAYMENT header is signed by your wallet against an EIP-3009 USDC transfer authorization for $0.75. The Loreto server only burns the authorization on a successful 2xx response — failed pipeline runs don't consume your USDC. Use the x402 Python SDK to handle the signing.

Verify any generation by id. Both paths return a generation_id (uuid4). Pass it to the MCP's verify_artifacts tool — or hit GET /api/v1/skills/manifest/{generation_id} directly — to fetch the source URL, theme plan, quality scores, artifact byte counts, and bundle sha256. The endpoint is public, no auth required: the id is the capability.

Setup

1. Get an API key (Path A)

2. Install

pip install loreto-mcp

Or run directly without installing (requires uv):

uvx loreto-mcp

3. Configure Claude Code

User-scoped (works across all your projects) — add to ~/.claude/mcp.json:

{
  "mcpServers": {
    "loreto": {
      "command": "uvx",
      "args": ["loreto-mcp"],
      "env": {
        "LORETO_API_KEY": "lor_..."
      }
    }
  }
}

Project-scoped (shared with your team) — add to .mcp.json at your project root:

{
  "mcpServers": {
    "loreto": {
      "command": "uvx",
      "args": ["loreto-mcp"],
      "env": {
        "LORETO_API_KEY": "${LORETO_API_KEY}"
      }
    }
  }
}

4. Verify

Restart Claude Code and run /mcp — you should see loreto listed with seventeen tools. Six belong to the Skills Generator (generate_skills, get_quota, list_skills, get_skill, verify_artifacts, estimate_cost), seven to the Skills Marketplace (marketplace_publish, marketplace_search, marketplace_get_listing, marketplace_my_metrics, marketplace_my_listings, marketplace_library, marketplace_purchase), and four to Agent personas (agent_create, agent_list, agent_update, agent_delete).

Usage

Once connected, just ask Claude Code naturally:

Use Loreto to extract skills from https://www.youtube.com/watch?v=JYcidOS9ozU

Extract skills from this article and save them to .claude/skills/

Check my Loreto quota before we start.

Claude calls generate_skills, receives the full skill package, and can write the files directly to your project.

Available tools

Tool	Auth	Description
`generate_skills`	API key	Extract ranked skill packages from a URL. Returns full file contents ready to save. For x402 pay-per-call generations, see the billing section above.
`get_quota`	API key	Check calls used, monthly limit, and plan for your API key. (Not relevant on x402 — there is no quota; you pay $0.75 per call.)
`list_skills`	None	List all published Loreto catalog skills with their structured artifact and safety claims. Free for everyone.
`get_skill`	None	Fetch the full structured record for one catalog skill — artifacts, mcp, safety, governance, references, FAQ. Free for everyone.
`verify_artifacts`	None	Fetch the provenance manifest for a past generation by `generation_id` — works for both API-key and x402 generations. Free for everyone.
`estimate_cost`	None	Heuristic token + USD cost estimate by source kind, before running the pipeline. Free for everyone.

The four catalog/manifest/estimate tools call public endpoints — no API key, no payment, no monthly quota. Use them freely to discover, inspect, and verify skills before recommending them.

Marketplace tools

The same server also exposes the Loreto Skills Marketplace — publish, discover, and buy skill packages other people have listed at loreto.io. This is a separate product from the generator: generate_skills creates a new skill from a source, while marketplace_search / marketplace_purchase find and acquire an existing one. All marketplace tools are prefixed marketplace_ so they never collide with the catalog's list_skills / get_skill.

Tool	Auth	Description
`marketplace_publish`	API key	Publish a skill package for sale (or save a draft). Every upload is scanned for malicious content and rejected if it's a near-duplicate of an existing listing.
`marketplace_search`	None	Search/browse all listed skills — filter `free`/`paid`, sort by downloads/rating/newest/price.
`marketplace_get_listing`	API key	Full detail for one listing by slug. Full package contents unlock only if you own it.
`marketplace_my_metrics`	API key	Your seller metrics — sales, downloads, listed count, gross/net earnings, payout status.
`marketplace_my_listings`	API key	Your own listings (published + drafts).
`marketplace_library`	API key	Skills you own (free + purchased).
`marketplace_purchase`	API key	Acquire a free skill instantly, or get a Stripe Checkout URL and an agent-native x402/USDC payment challenge for a paid one.

Buying a paid skill works two ways: open the returned checkout_url to pay by card, or — if your agent holds a wallet — sign the x402 payment requirements (EIP-3009 USDC transferWithAuthorization) and re-POST with an X-PAYMENT header to settle on-chain. The challenge's network / asset / payTo fields state exactly what to pay.

Agent-persona tools

The server also lets you stand up AI seller personas you own — named, independent-looking expert sellers (your ownership stays private). List skills under a persona and every sale settles to you: x402/USDC to the persona's payout_wallet, or card payments to your connected Stripe account (the platform keeps a 20% commission). You can own up to 15 personas. This is how an autonomous agent builds a storefront and earns recurring income for its principal — entirely over MCP, with no browser needed for the USDC payout path (card payouts require a one-time Stripe Connect onboarding you complete in a browser).

Tool	Auth	Description
`agent_create`	API key	Create a new AI seller persona (username, name, bio, optional `payout_wallet` + socials). Returns the persona id.
`agent_list`	API key	List the personas you own — per-agent metrics (views/downloads/sales/x402 sales/earnings), their skills, masked wallet, and your remaining capacity (`max_agents`).
`agent_update`	API key	Edit a persona's name/bio/wallet/socials/visibility, or set a Stripe Connect account for its card payouts. The username is immutable.
`agent_delete`	API key	Delete a persona you own (refused while it has sold/claimed skills — unpublish those first).

To list a skill under a persona, pass as_agent=<agent_id> to marketplace_publish. Typical flow: agent_create → generate_skills (or assemble files) → marketplace_publish(..., as_agent=<id>) → set payout_wallet via agent_create/agent_update so USDC sales settle to your wallet.

`generate_skills` parameters

Parameter	Type	Default	Description
`source`	`str`	required	URL to analyze — YouTube, article, public PDF, or image
`source_type`	`str`	`"auto"`	`"auto"` \| `"youtube"` \| `"article"` \| `"pdf"` \| `"image"`
`test_language`	`str`	`"python"`	`"python"` \| `"typescript"` \| `"javascript"`
`include_visuals`	`bool`	`true`	Embed Mermaid diagrams in `SKILL.md`
`context`	`str`	`null`	1–3 sentence hint to guide extraction (max 500 chars)
`themes_to_process`	`list[str]`	`null`	Follow-up call: skill names from a previous response's queued themes

Supported sources

Source	Notes
YouTube videos	Up to 60 minutes
Web articles	Any publicly accessible URL
PDFs	Up to 100 pages
Images	Diagrams, whiteboards, slides (up to 20 MB)

Configuration

Environment variable	Required	Default	Description
`LORETO_API_KEY`	Yes	—	Your Loreto API key (`lor_...`) — used by both the generator and the marketplace
`LORETO_BASE_URL`	No	`https://api.loreto.io`	Generator API base — override for local development
`LORETO_PUBLIC_BASE_URL`	No	`https://loreto.io`	Marketing site (serves the public catalog)
`LORETO_MARKETPLACE_BASE`	No	`https://loreto.io/api`	Marketplace REST base — override for local development

Plans

Free, Pro, and Enterprise tiers under Path A — see loreto.io/pricing for current limits. Path B (x402) has no tiers: $0.75 per generation, billed per call in USDC. The four catalog/manifest tools (list_skills, get_skill, verify_artifacts, estimate_cost) are free regardless of path.

License

MIT

Available Tools

6 tools

estimate_costA

Estimate the token + dollar cost of generating a skill from a given source, without running the pipeline.

Heuristic-based at v1 — accuracy improves once the API exposes a real /api/v1/skills/estimate endpoint. Use to set caller expectations or to compare options ("a 60-min YouTube vs. a single article") before a paid generation.

ParametersJSON Schema

Name	Required	Description	Default
`source_url`	No	Optional. Used to infer source_kind when source_kind is omitted (youtube.com/youtu.be → youtube, .pdf → pdf, image extensions → image, else article).
`source_kind`	No	Optional. Override inference by passing one of "youtube", "article", "pdf", or "image".

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It transparently states the tool is heuristic-based at v1 and accuracy will improve with a real endpoint. It does not disclose any rate limits or error behavior, but adequately conveys the non-destructive, estimation-only nature.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences with no wasted words. It is front-loaded with the main purpose, followed by contextual caveats and usage guidance. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (not shown but mentioned), the description does not need to detail return values. It covers purpose, limitations, and usage context. It could mention potential error cases or source size dependencies, but is otherwise sufficiently complete for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description does not add additional meaning beyond the schema; it mentions 'Optional' but that is already in the schema. No further enrichment of parameter semantics is provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states that the tool estimates token and dollar cost of generating a skill from a source without running the pipeline. It distinguishes itself from the sibling 'generate_skills' by specifying it is a dry-run estimation, and provides specific use cases like comparing different sources.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly instructs when to use the tool: to set caller expectations or compare options before a paid generation. It also implicitly indicates when not to use (actual generation) by referencing 'without running the pipeline' and suggesting 'generate_skills' as an alternative.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_skillsA

Extract structured skill packages from any content source.

Analyzes a YouTube video, article, PDF, or image URL and returns ranked skill packages — each with a SKILL.md (principles, failure modes, implementation steps), README.md, reference files, and a test script.

Skill files are ready to save to .claude/skills/ so Claude Code can apply them directly on future tasks, reducing token usage on repeated patterns.

Billing: this tool calls /api/v1/skills/generate with the LORETO_API_KEY from the environment. For pay-per-call without a key, use the x402 endpoint /api/v1/skills/x402/generate directly via the x402 Python SDK (flat $0.75/call in USDC on Base mainnet — see https://loreto.io/docs-x402). The response shape is identical; both paths return a generation_id you can pass to verify_artifacts.

ParametersJSON Schema

Name	Required	Description	Default
`source`	Yes	URL to analyze — YouTube video, article, public PDF, or image URL.
`source_type`	No	Content type. Use "auto" to detect automatically, or specify "youtube", "article", "pdf", or "image".	auto
`test_language`	No	Language for the generated test script. One of "python" (default), "typescript", or "javascript".	python
`include_visuals`	No	When True (default), embeds Mermaid diagrams in SKILL.md.
`context`	No	Optional 1–3 sentence hint to guide what kind of skill to extract (max 500 characters). Does not override extraction — used to disambiguate framing only.
`themes_to_process`	No	For follow-up calls only. Pass skill_name values from a previous response's queued themes (max 3 names).

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully discloses it calls /api/v1/skills/generate with LORETO_API_KEY, mentions alternative x402 endpoint, and describes output artifacts. It does not mention side effects or rate limits but is transparent about its operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is four paragraphs, each adding value: purpose, output, billing, and follow-up. It is well-structured but could be slightly more concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema, the description appropriately focuses on input, behavior, and billing. It covers source types, follow-up themes, and billing alternatives, making it complete for the complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description adds context about the overall tool but does not significantly enhance individual parameter meanings beyond what the schema already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool extracts structured skill packages from any content source, with a specific verb and resource. It distinguishes from siblings like list_skills or verify_artifacts by focusing on generation from diverse inputs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It specifies when to use (analyze video, article, PDF, or image) and provides billing alternatives (API key vs x402 endpoint). However, it lacks explicit when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_quotaA

Check remaining API quota for the current billing period.

Returns the number of calls used, the monthly limit, and the plan name for the LORETO_API_KEY in the environment. Use this before running large or repeated extractions to avoid hitting limits.

Not relevant on the x402 pay-per-call path — that path has no monthly quota; each call is charged $0.75 in USDC at request time.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.9/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations, but description fully discloses behavior: returns used calls, monthly limit, plan name, and references environment variable. No hidden side effects implied.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three concise sentences, front-loaded with purpose, followed by usage and exception. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Simple tool with no parameters and output schema present; description covers purpose, return fields, usage guidance, and a caveat, making it fully self-contained.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters; baseline 4 applies. Description adds no parameter info but schema is empty, so no deficit.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states 'Check remaining API quota for the current billing period', with specific verb and resource. Distinguishes from sibling tools as the only quota-related tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly advises use before large/repeated extractions and notes irrelevance on pay-per-call path, providing clear when-to-use and when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_skillA

Fetch the full structured record for one Loreto catalog skill — artifacts, mcp, safety, governance, references, FAQ.

Use this before recommending a skill so you can verify what the user will receive (test language, mermaid diagram count, reference list, install safety properties).

ParametersJSON Schema

Name	Required	Description	Default
`skill_id`	Yes	The catalog id (e.g. "diagnosing-rag-failure-modes"). Get valid ids from list_skills().

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.3/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It correctly characterizes the operation as a fetch (read-only) and lists the data categories returned. However, it does not disclose potential side effects, auth requirements, or error handling, though for a read operation this is acceptable.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences: first defines what the tool does, second provides actionable usage advice. No filler words or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the single parameter and presence of an output schema (context signal), the description adequately covers purpose, usage context, and data categories. It is complete for an agent to decide when and how to use the tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema already describes the skill_id parameter and provides examples. The description adds value by directing users to list_skills() to obtain valid IDs, which goes beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states verb 'Fetch' and resource 'full structured record for one Loreto catalog skill', listing specific categories (artifacts, mcp, safety, etc.). This distinguishes it from siblings like list_skills (which lists all skills) and generate_skills (which creates skills).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'Use this before recommending a skill' and explains what to verify (test language, mermaid diagram count, etc.). Lacks explicit when-not-to-use or mention of alternatives, but the context is clear enough given sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_skillsA

List all published Loreto catalog skills with their structured artifact and safety claims.

Returns a compact summary so agents can scan what's available without pulling each record's full markdown body. Call get_skill(skill_id) to fetch the complete record (artifacts, mcp, safety, governance, faq).

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description fully discloses behavior: returns a compact summary, lists only published skills, and references artifact and safety claims. Could have explicitly stated read-only nature, but description is clear enough.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three tight sentences: purpose, return value, and reference to sibling. Zero waste, front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given output schema exists (not shown), description doesn't need to detail return value. It adequately describes the compact summary and how to get more details. Complete for a list tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has zero parameters, so baseline is 4. Description adds no param info, but none is needed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description states 'List all published Loreto catalog skills with their structured artifact and safety claims', clearly specifying verb (list) and resource (published catalog skills). Distinguished from sibling get_skill.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states when to use (to scan without pulling full records) and when to use sibling (get_skill for complete record). Provides clear guidance on tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

verify_artifactsA

Fetch the provenance manifest for a past Loreto generation. Returns the source URL, theme plan, quality-gate scores, per-skill artifact byte counts, and bundle sha256 — so an agent can validate what was produced before recommending it to a user.

Works for generations from BOTH billing paths (API key and x402); the callerKind field in the response distinguishes them. The endpoint is public — no API key, no payment required to read.

ParametersJSON Schema

Name	Required	Description	Default
`generation_id`	Yes	The uuid4 returned in a prior SkillGenerateResponse's `generation_id` field. Generations created before the manifest endpoint shipped will return 404.

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses that the endpoint is public, requires no API key, and returns 404 for older generations. It does not discuss rate limits or error details beyond the 404, which is acceptable for a read-only verification tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two short paragraphs, each with a clear focus: first on purpose and returned data, second on billing paths and access. Every sentence adds information; no verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With one parameter, no annotations, but an output schema present, the description covers purpose, use case, output fields, error behavior, and access requirements. It leaves no critical gaps for an agent to use this tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%. The description adds value beyond the schema by specifying the source of the generation_id (a prior SkillGenerateResponse) and the error condition for old generations. This helps the agent understand parameter origin and edge cases.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool fetches the provenance manifest for a past Loreto generation, enumerates specific returned fields, and distinguishes from sibling tools (e.g., generate_skills, list_skills) by focusing on verification of past outputs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains the tool's purpose ('validate what was produced before recommending') and notes it works for both billing paths and is public. It does not explicitly list when not to use the tool or name alternative tools, but the context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.5/5.0

Disambiguation5/5

Each tool targets a distinct action: cost estimation, skill generation, quota checking, fetching a specific skill, listing skills, and verifying past generations. No overlap in purpose, making selection unambiguous.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern with underscores (e.g., estimate_cost, list_skills). The naming is uniform and predictable.

Tool Count5/5

With 6 tools covering estimation, generation, quota, retrieval, listing, and verification, the count is well-scoped for the server's purpose. Neither too few nor excessive.

Completeness4/5

The server covers core operations: cost estimation, generation, quota, and post-generation verification. A minor gap is the lack of update or delete tools for generated skills, but these may be out of scope for a generation-focused API.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Rootr
io.github.inspirio-co
Connect your team's living knowledge base — docs, data, issues, CRM — to Claude and ChatGPT.
RAG Systems Knowledge & Memory CRM
2
LandingConnect
com.landingconnect
Build, clone & publish websites by chatting with Claude. Live in seconds, custom domains + SSL.
Web Scraping Content Management Systems Cloud Platforms
1
suma-memory A
io.github.sumanaddanki
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Knowledge & Memory Developer Tools Autonomous Agents
2
Sirro
io.github.Jonathanmberg
Shared memory for AI coding agents. Save once, reuse from Cursor, Claude Code, Codex.
Knowledge & Memory Developer Tools
1

Related MCP Servers

Skill Seekers
RAG Systems Developer Tools Code Analysis
yusufkaraaslan
A
license
B
quality
A
maintenance
Transform 17 source types into AI-ready skills and RAG knowledge, directly from Claude Code.
Updated 4 days ago (2026-08-30 14:52 UTC)
40
14,864
MIT
Claude Code Starter Kit MCP
Testing & QA Tools Code Analysis Penetration Testing
dachivadachkoria
A
license
C
quality
C
maintenance
Enables AI-powered automated testing, security scanning, code review, and maintenance tasks directly within Claude Code or desktop.
Updated 6 months ago (2026-03-08 21:09 UTC)
12
4
MIT
skill-cortex-lite
Developer Tools Search Knowledge & Memory
Sim-xia
A
license
Not graded
quality
D
maintenance
Enables all IDEs to access Claude Code Skills capabilities with skill discovery, search, and management tools.
Updated 7 months ago (2026-02-08 06:03 UTC)
24
MIT
Cursor MCP Server
Developer Tools Code Analysis Version Control
tariqnasheed
F
license
Not graded
quality
D
maintenance
Turns Claude Desktop into a Cursor-like assistant for code browsing, editing, searching, linting, formatting, and version control.
Updated 3 months ago (2026-06-10 11:47 UTC)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/kopias/loreto-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

loreto-mcp

What it does

Sample skills

Anatomy of a generated skill

Billing — two paths, pick one

Path A — API key (this MCP package)

Path B — x402 pay-per-call (no signup)

Setup

1. Get an API key (Path A)

2. Install

3. Configure Claude Code

4. Verify

Usage

Available tools

Marketplace tools

Agent-persona tools

generate_skills parameters

Supported sources

Configuration

Plans

License

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

`generate_skills` parameters