agentleFS
flowleap-aiflowleap-ai/flowleap-cli/skills/flowleap/SKILL.md

flowleap

Skill1 starsChanged 4 months agoMITView on GitHub

Start here — the umbrella skill for the FlowLeap Patent AI CLI. Maps every command family (patent/USPTO/OPS/academic/NPL/legal/citation reads, analytics, OCR, one-call patent verbs, the tools facade, and the raw API escape hatch) and routes to the specialist skills. Trigger when a user asks an agent to use FlowLeap, query the FlowLeap backend, verify local or deployed FlowLeap API health, run patent research commands, or debug FlowLeap CLI/API behavior.

  • Pipes a download into a shell
  • Installs packages

The file

We split this skill into the rules it gives an agent

3 rules. About 0 are common, 0 are distinctive, and 3 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈0

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Always pass --json for agent parsing.

    line 10
  2. Very specific:

    Every data command — patent, ops, uspto, citation, npl, academic, analytics, ocr, patstat, and the one-call verbs — runs on the

    line 140
  3. Very specific:

    Only auth/OAuth, key validation and the raw api request escape hatch run outside the facade.

    line 147

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

FlowLeap CLI

flowleap is the command layer for the FlowLeap Patent AI backend. This is the entry-point skill: it verifies the setup and routes to the specialist skills. Always pass --json for agent parsing; use --dry-run before protected calls.

In a chat client with the FlowLeap connector (claude.ai, Claude Desktop and mobile, Cowork, ChatGPT) or in the FlowLeap Patent AI app (firm OS and desktop), never run a flowleap command: skip the install, doctor, and command steps below, and call the tool of the same name. In a chat client sign-in is the connector's OAuth and keys are the stored keys from the Patent-data keys page. In the app the office tools are native on the firm's or the desktop's own keys, and paid tools carry the mcp__flowleap__ prefix. The command-to-tool table and the rules for both hosts are in flowleap-shared ("Chat clients and the FlowLeap Patent AI app"). The one-call verbs map like this:

VerbTool
summaryget_patent_summary
comparecompare_patents
timelineget_prosecution_timeline
patent term (no verb; tools run get_patent_term)get_patent_term
figuresget_patent_image
convert-numberconvert_patent_number

Through MCP, get_patent_image with include_images: true returns each PNG or JPEG page as an image content block the client shows you directly; the JSON text block keeps the page metadata only.

Start Here

command -v flowleap || true
flowleap --json doctor

Just checking the backend is up? flowleap --json health api is the public readiness probe and reports the backend's apiVersion — no subscription, no patent-data key, no provider call. Never probe reachability with a search command: a search costs a provider call and fails for reasons unrelated to reachability (no subscription, a key gate, a bad query), so it answers a different question than the one you asked.

Doctor exits 0 iff the machine is ready to work (backend reachable, authenticated, nothing blocking); otherwise it exits 1 and its JSON lists the pending blocking steps in nextSteps, each tagged with an actor. Drive onboarding agent-mediated from that list:

  1. Execute every actor: "agent" step yourself via its run command (e.g. mint-personal-token, store-epo-keys, verify-keys).
  2. Relay every actor: "human" step to the user — its title plus url (provider signups) or the verification link from flowleap --json auth login (see flowleap-auth).
  3. Re-run flowleap --json doctor until ready is true (empty nextSteps).

Server-covered patent-data keys never appear in nextSteps — the list is only what actually blocks work. Full contract: flowleap-shared.

CLI not installed? Install it first — npm when Node is present, the install script otherwise:

npm install -g flowleap
curl -fsSL https://raw.githubusercontent.com/flowleap-ai/flowleap-cli/main/install.sh | sh

Then authenticate: flowleap auth login opens a device-code sign-in (a free FlowLeap account is created at flowleap.co if you don't have one). Headless agents use a fl_pat_ API token instead — see flowleap-auth.

doctor targets the production backend (https://api.flowleap.co) by default — no --base-url needed. Developing the FlowLeap backend itself? Add --base-url http://localhost:8000 to point at a local server.

Where Things Live

  • Auth, global flags, config, output formats → flowleap-shared; login, token minting, and 401 self-heal → flowleap-auth.
  • Patent-data keys (EPO OPS / USPTO ODP BYOK) → flowleap-keys. A provider_keys_required / provider_keys_invalid / trial_budget_exhausted hint — raised from the backend codes data_keys_required, patent_provider_key_invalid, odp_api_key_missing and trial_data_budget_exhausted, never from message text — means a human must sign up in a browser (free at both offices; the budget variant also lifts on its own at the hint's resetsAt). That is a user-action stop for that office, never an exhausted route: do not substitute web-scraped data for it, for searches or single-document reads. Finish the live office, name the gap as a missing-key gap, ask at the end; PATSTAT, legal, and academic/NPL stay live keyless as different data. Full doctrine: flowleap-keys.
  • Patent search & CQL → flowleap-patent; USPTO ODP → flowleap-uspto.
  • EPO document data (biblio, claims, description, family, legal, EP Register representatives and opponents) → flowleap-ops. "How many EP filings does representative X handle" is ops register-search --cql 're=X' there — the one search with a representative index. When a role index returns 0, nm=X (name in any role, surname-first) finds the role.
  • Non-patent literature → flowleap-npl first (OpenAlex search, and npl-work to resolve a paper an office cited), flowleap-academic (Semantic Scholar + arXiv) as the second pass.
  • Patent law (the MPEP, 35 USC, 37 CFR, the EPC, the EPO Guidelines, the PCT rules) → flowleap-legal: the method reads the office's own page with your web tool and quotes it with its URL and edition (the FlowLeap Patent AI app has no web tool; see that skill); enriched citations → flowleap-citation.
  • Examiner Baseline (flowleap --json patent examiner-baseline <pub> — every document cited across a granted patent's family, by office, with gaps) and Find Better (earlier or closer art than the examiners cited) → recipe-find-better.
  • Portfolio Analytics (structured criteria — named applicant, CPC/IPC, office, year, family, grant status) → flowleap-patstat; free-text keyword analytics (flowleap analytics, Topic Analytics) stay below.
  • Graph Analytics (flowleap patstat graph … — a named node and the relationships around it: who cites a patent, the path between two patents, family coverage, an applicant's co-applicant network) → flowleap-patstat-graph. Counts belong to Portfolio Analytics; connections belong here.
  • Tools facade (flowleap tools list|describe|run …) and the one-call verbs summary, timeline, compare → flowleap-tools.
  • Document utilities — flowleap figures <doc>, flowleap convert-number <doc> --to docdb, flowleap analytics --keyword …, flowleap ocr <file>.
  • Search queries and claim decomposition are yours to write — there is no server-side query builder or claim analyzer. flowleap-patent carries the CQL method (term extraction, discriminating term, count probe); recipe-claim-analysis carries the claim-decomposition method.
  • Raw API escape hatch — flowleap --json api request get <path>. It calls whatever path you give it, with no schema and no error contract of its own, so reach for it only when no command and no tool covers what you need. It is not a way back onto a retired endpoint: those answer 410 Gone here too. Never run a live post/put/patch/delete unless the user asked for that specific write, and prefer --dry-run.

One surface for patent data

Every data command — patent, ops, uspto, citation, npl, academic, analytics, ocr, patstat, and the one-call verbs — runs on the Tools facade: named tools invoked through /v1/tools, one success envelope, one error contract, a self-describing registry. The per-source provider routes they used to call are retired endpoints — permanently removed, answering 410 Gone with a machine-readable successor, and never reused.

Only auth/OAuth, key validation and the raw api request escape hatch run outside the facade.

Practical consequence: a command failing with exit 8 (endpoint_gone) means your CLI build is stale, not that the capability is gone. Read endpointGoneHint.successor, run flowleap upgrade, then flowleap skills update — upgrading the binary without refreshing skill files walks straight back into the same 410. Never retry the call itself; retirement is permanent. Exit codes and hints in full: flowleap-shared.

Install Skills

flowleap skills install              # → ~/.claude/skills
flowleap skills install --project    # → .claude/skills
flowleap skills install --dir <path> # any other agent

Keep FlowLeap Updated

One command upgrades the CLI on any install channel (npm, install.sh binary, cargo) — no need to know which one you're on:

flowleap upgrade --check   # channel + versions, no changes (add --json to branch on it)
flowleap upgrade           # upgrade in place
flowleap skills update     # refresh installed skill files (automatic on a raw-binary upgrade)

upgrade --check --json returns { channel, currentVersion, latestVersion, updateAvailable, command } so an agent can decide whether to act.

Skill files are copies, so an upgrade leaves them behind on every channel except the raw binary, which refreshes them with the new build. Stale skill files teach retired commands, so flowleap doctor reports them as a ✗ carrying a refresh-skills next step.

Skill Map

  • Shared reference: flowleap-shared (auth, flags, config), flowleap-auth, flowleap-keys
  • Data sources: flowleap-patent (EPO CQL), flowleap-uspto (ODP Lucene), flowleap-ops (EPO documents), flowleap-academic, flowleap-npl, flowleap-legal, flowleap-citation, flowleap-patstat (Portfolio Analytics), flowleap-patstat-graph (Graph Analytics), flowleap-tools (facade)
  • Personas: persona-patent-attorney, persona-ip-analyst, persona-researcher, persona-startup-founder
  • Recipes (search/analysis): recipe-prior-art-search, recipe-find-better, recipe-patent-landscape, recipe-freedom-to-operate, recipe-claim-analysis, recipe-patent-to-report, recipe-academic-literature-review
  • Recipes (prosecution/litigation, full pack only): recipe-office-action-response, recipe-invalidity-analysis, recipe-infringement-charting, recipe-claim-drafting, recipe-invention-disclosure, recipe-audit-report

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.