Skip to main content
Glama

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-mcp

Then 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

CLAUDE.md (or AGENTS.md)

Read on every session: what the repo is and the rules that matter most. Merged between loreto markers; your own file is kept.

Conventions skill

.claude/skills/<repo>-conventions/SKILL.md

How a change is made here: where code goes, sizing, naming, testing.

Reviewer

.claude/agents/<repo>-conventions-reviewer.md

Checks a change against the repo's own thresholds before a human has to.

References

…/references/conventions.md, hotspots.md, coupling.md, lessons-from-reverts.md, anti-patterns.md, code-health.md

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

…/scripts/guardrails.py, check-change.py, about.py

Python, nothing to install. guardrails.py blocks reverted code and warns on deprecated calls; check-change.py --strict fails a git hook or CI run.

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-mcp

Or 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:

  1. 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).

  2. 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-mcp
  3. Ask 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

list_agents

free

The supported agents and where each reads its files.

read_repo(repo, agent)

free

Reads the history; returns what it says, the files, the prices and a read_id.

buy_harness(read_id, agent, files?)

$5 / $2 a file

Returns a Stripe checkout link for the person to pay. The agent cannot pay.

get_harness(path)

—

After payment: waits for the files and installs them into the repository at path.

ask_repo(question)

included

Why was this reverted? Who knows this code? Answered from the history.

check_approach(approach, path?)

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.

plan_change(request, path?)

free, local

A change kit: SPEC.md, and STEPS.md small enough for a small model to build. Runs Gitology.

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.py and src/api/schema.py changed 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 in fac848a; ADR-014 says retries belong in workers. Better route: wrap the call in CaptureWorker with with_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 | sh

The 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"}     $2

Public 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_repo leads 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.


loreto.io · Gitology · Pricing · MIT licence

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.

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

    A4.5/5.0

    Scored across 6 tools

    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.

    Related MCP Connectors

    Related MCP Servers