loreto-mcp
The schema exposes Loreto’s skill-generation and catalog API, not the newer harness/Gitology tools described in the README.
Generate structured skill packages from YouTube videos, articles, PDFs, or image URLs, producing SKILL.md, README, references, and test scripts.
Guide extraction with optional context, source type, test language, Mermaid visuals, and follow-up theme names.
Check API quota, monthly limit, and plan for the configured
LORETO_API_KEY.List published catalog skills and fetch a single skill’s full record: artifacts, MCP/safety/governance details, references, and FAQ.
Verify provenance for a past generation using
generation_id, including source URL, theme plan, quality scores, artifact sizes, and bundle sha256.Estimate token and dollar cost before generating a skill from a source.
Use API-key billing via
LORETO_API_KEY; schema descriptions also document an x402 pay-per-call path outside the MCP server.
Enables analyzing YouTube videos to extract reusable skill packages (principles, failure modes, implementation steps, Mermaid diagrams) for use with Claude Code.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
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
Your code is your context. Loreto reads your repository's code and git history and finds the four mistakes a coding agent keeps making there:
Anti-patterns: code your team already added and reverted, and the "never" rules in your decision records. Guard rails block them.
Abstractions: the modules the rest of the code imports. Your agent reuses them instead of writing a second one.
Deprecated code: what is retired, what replaced it, and who still calls it. A new call gets a warning.
Simplification: blocks copied between files, helpers defined many times, modules nothing imports.
Plus the rules nobody wrote down: where code goes, how big a change is, what has to change together. It installs all of it as a harness your coding agent loads, so every pull request it opens reads like your team wrote it.
Then, before your agent writes a line, Gitology tells it whether to build it that way in this repository, with the commits to prove it.
Works with Claude Code, Codex, Muse Code, OpenCode, Hermes, Cursor, DeepSeek Harness, Antigravity and GitHub Copilot.
Start in 30 seconds
claude mcp add loreto -- uvx loreto-mcpThen tell your agent:
Read github.com/your-org/your-repo with Loreto.
That's it. No account, no key, no config for a public repository (five free reads without an account; a free account lifts the limit). The read is free and shows what it found (anti-patterns, abstractions, deprecated code, duplication) before anything costs money. Say "buy it" and the agent hands you a checkout link; after you pay, it installs the files into your repo itself.
Related MCP server: Claude Code Starter Kit MCP
What the harness holds
Written from the repository's own history, with the figure behind every rule:
File | Claude Code path | What it does |
Root file |
| Read on every session: what the repo is and the rules that matter most. Merged between |
Conventions skill |
| How a change is made here: where code goes, sizing, naming, testing. |
Reviewer |
| Checks a change against the repo's own thresholds before a human has to. |
References |
| The evidence: conventions, the files the work lands in, what moves together, what had to be undone, what not to put back, and what to reuse, retire and simplify. |
Scripts |
| Python, nothing to install. |
Each agent gets its own layout (AGENTS.md + .agents/skills/ for Codex and Muse Code, .cursor/rules/ for Cursor, ~/.hermes/skills/ for Hermes). list_agents shows them.
Pricing
Reading a repository and seeing what its harness would hold is free. The harness is $5, or $2 a file (three files cost the same as all of them). No subscription. Each purchase includes 25 questions to the repository.
Install
claude mcp add loreto -- uvx loreto-mcpOr in any MCP client config:
{
"mcpServers": {
"loreto": { "command": "uvx", "args": ["loreto-mcp"] }
}
}No API key is needed for public repositories. To keep purchases on your Loreto account, and to read private repositories you have connected to Loreto through GitHub (read-only), add your key from loreto.io/dashboard:
"env": { "LORETO_API_KEY": "lor_..." }Private repositories
Public repositories need nothing. A private one is read through your own GitHub connection, so Loreto only ever sees what you chose to share:
Sign in at loreto.io and press the GitHub button. Loreto's GitHub App is read-only, and you pick the repositories it can see (change them any time at github.com/settings/installations).
Create a key at loreto.io/dashboard/developer and give it to the server:
claude mcp add loreto -e LORETO_API_KEY=lor_... -- uvx loreto-mcpAsk your agent to read the repository as usual.
If a repository isn't reachable, read_repo says which of these steps is missing instead of failing. Private reads belong to your account and are never shown to anyone else. The repository is cloned read-only on Loreto's server to read its history and code, and the evidence your files are written from (figures from git, plus the first lines of a few of the busiest source files) goes to the model provider that writes them; nothing is published.
Want the code to stay on your machine? check_approach and plan_change run Gitology locally and need no account at all.
Tools
Tool | Cost | What it does |
| free | The supported agents and where each reads its files. |
| free | Reads the history; returns what it says, the files, the prices and a |
| $5 / $2 a file | Returns a Stripe checkout link for the person to pay. The agent cannot pay. |
| — | After payment: waits for the files and installs them into the repository at |
| included | Why was this reverted? Who knows this code? Answered from the history. |
| free, local | Should I build it this way here? Good to go, risky or don't merge, with the evidence and a better route. Runs Gitology. |
| free, local | A change kit: |
A typical session:
You: arm Claude Code with this repo
Agent: (read_repo) Half of the last 400 commits touch 2 files or fewer…
src/api/routes.pyandsrc/api/schema.pychanged together 17 times… The harness is $5. (buy_harness) Here is the checkout link.You: paid
Agent: (get_harness) Armed Claude Code:
~ CLAUDE.md (kept yours, added the Loreto section),+ .claude/skills/…
Gitology: ask before you build
Gitology maps a repository on your machine into a graph of what exists (modules, files, symbols, endpoints, tests, decision records, owners) and how it holds together (imports, changes-with, reverted-by, tested-by), and keeps it current through git hooks. check_approach and plan_change call it:
You: add retries to PaymentClient.capture
Agent: (check_approach) DON'T MERGE. This exact change was made in
823cc78, captured cards twice, and was reverted infac848a; ADR-014 says retries belong in workers. Better route: wrap the call inCaptureWorkerwithwith_backoff. (plan_change) Kit written: 4 steps.
Install it once (Python 3.9+), and the tools find it:
curl -fsSL https://loreto.io/gitology/install.sh | shThe graph is built locally. Only the verdict and the change kit call a model, they send it the excerpts and history that bear on the question, and the model can be local: set GITOLOGY_MODEL=ollama:<model>, or ANTHROPIC_API_KEY / OPENAI_API_KEY in the MCP server's env. Gitology also runs on its own as a CLI and MCP server: see loreto.io/gitology.
For agents with a wallet: x402
An agent holding USDC on Base can buy without a person or a browser, over x402. The harness is written before anyone pays, and the paid call answers with the files, so a payment settles only on a delivery:
POST https://api.loreto.io/api/v1/harness/prepare {"repo": "...", "agent": "claude-code"} free
GET https://api.loreto.io/api/v1/harness/prepare/{id} poll until "ready" free
POST https://api.loreto.io/api/v1/harness/x402 {"prepare_id": "..."} $5
POST https://api.loreto.io/api/v1/harness/x402/file {"prepare_id": "...", "file": "skill"} $2Public repositories only. A harness that is not ready yet answers 409 and nothing is charged. Full walkthrough with a Python x402 client: loreto.io/docs#x402. This MCP server does not sign payments.
Changes in 1.2.0
Every agent the site writes for, including DeepSeek Harness, Antigravity and GitHub Copilot (checked against the live list).
read_repoleads with what it found: anti-patterns it will block, abstractions to reuse, deprecated code still in use, duplication worth simplifying.A private repository gets the three steps to read it (connect GitHub, create a key, set
LORETO_API_KEY) instead of an error.Descriptions say what a harness holds now: six references and the skill's guard-rail scripts.
Changes in 1.1.1
check_approach speaks plain words: good to go, risky, don't merge, not sure (from Gitology's new labels).
Changes in 1.1
check_approach and plan_change, through Gitology. Nothing else changed.
Changes in 1.0
loreto-mcp used to wrap Loreto's skill generator and marketplace. Loreto is now about one thing, the harness, and the generator is no longer public. The generate_skills, catalog, marketplace_* and agent_* tools are gone; pin loreto-mcp<1 if you depended on them.
Available Tools
6 toolsestimate_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.
Inputs: source_url, source_kind. Returns: result
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.
Inputs: source (required), source_type, test_language, include_visuals, +2 more. Returns: result
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.
Inputs: no named parameters. Returns: result
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).
Inputs: skill_id (required). Returns: result
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).
Inputs: no named parameters. Returns: result
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.
Inputs: generation_id (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
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.
All tool names follow a consistent verb_noun pattern with underscores (e.g., estimate_cost, list_skills). The naming is uniform and predictable.
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.
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.
Related MCP Connectors
Your YouTube library in Claude, ChatGPT and Cursor: transcripts, breakdowns, summaries, search.
Your YouTube library in Claude, ChatGPT and Cursor: transcripts, breakdowns, summaries, search.
Your YouTube library, in the AI tools you already use: Claude, ChatGPT, Cursor, any MCP client.
Bring meeting decisions, tasks and user stories into your AI editor (Claude, Cursor, Copilot).
Related MCP Servers
- AlicenseBqualityBmaintenanceTransform 17 source types into AI-ready skills and RAG knowledge, directly from Claude Code.40993 PyPI15,338MIT
- AlicenseCqualityDmaintenanceEnables AI-powered automated testing, security scanning, code review, and maintenance tasks directly within Claude Code or desktop.1252 PyPI4MIT
- AlicenseNot gradedqualityDmaintenanceEnables all IDEs to access Claude Code Skills capabilities with skill discovery, search, and management tools.24MIT
- FlicenseNot gradedqualityDmaintenanceTurns Claude Desktop into a Cursor-like assistant for code browsing, editing, searching, linting, formatting, and version control.-