io.github.kedu21-beep/passage-data

Tools

• add_document

  One file held on a site and read, as a file dropped on the site's page is: its text layer page by page, its summary and, for a laboratory table, its result rows, all kept in the account and searched by ask_site. Give the file as `content_base64`, or a text as `text`. The same bytes added twice are one document. The answer gives the document's id, its state (read, or refused with a code and why), its pages, and `not_done`: each step of the read not made in this call. At most 8 MiB a file here; a larger one goes on the site's page (up to 200 MiB).

  shallow
• ask_site

  What do a project's own documents say about a question, cited to the page? A question answered from one site's own read documents, by Claude, and checked before it is shown: every statement carries quotes, each quote is found again on the page it names, and a statement whose quote or number is not on its page is cut and counted (`n_cut`). `quotes` give the document, its id and the page; `reasoning` is Claude's own and not from the documents; `not_searched` names the documents not read yet. Priced before any call and refused over $0.25 a question (`ask.over_cap`); an account asks at most 100 questions and spends at most $5 with Claude a UTC day (`ask.over_ceiling`, `spend.daily_cap`). `cost` says what the answer spent; the same question over the same pages is answered from memory at $0.

  shallow
• audit_archive

  A file this tool reads, sent or fetched from the address given, is read as one dropped on our website: what the read finds (column headings, the shape of its rows, the terms they became, refusal codes) is kept so the reader learns, never the file or its values. Names and contacts are dropped or replaced by a code, and protected species' locations are made coarser. What is wrong with a Darwin Core archive already published on GBIF? The defects in a published Darwin Core archive, found by the audit our website runs on an archive dropped on it: give a GBIF dataset key (the archive is fetched from the endpoint GBIF's registry lists), the archive's address, or the archive itself as base64. Each defect is coded (FS_...), with the check that found it (each check's words once, in `checks`; a finding names it by index), its count over the rows read, and the file and lines it stands on (at most 5 lines a finding; `not_located` says why when a check names neither a cell nor a row). `bdq` names every test of TDWG's BDQ TG2 suite: ran, with compliant and not_compliant counts and lines, or not run under a code (bdq.terms_absent, bdq.authority_absent, bdq.does_not_reproduce, bdq.not_implemented): a test not run is not a test passed. `annex: true` adds the audit as a markdown document to attach to a report. A large archive answers `pending` with a `call_id`: call again with only that call_id to collect it. Refusals are coded: dataset.not_found, dataset.no_archive, archive.unreachable, archive.not_dwca, archive.too_large, url.refused.

  shallow
• build_dwc_archive

  A file this tool reads, sent or fetched from the address given, is read as one dropped on our website: what the read finds (column headings, the shape of its rows, the terms they became, refusal codes) is kept so the reader learns, never the file or its values. Names and contacts are dropped or replaced by a code, and protected species' locations are made coarser. How do I publish a species file on GBIF? A Darwin Core archive (DwC-A) for GBIF, built from a species occurrence or checklist file (CSV, TSV, Excel, a zipped shapefile, ...) given as `file_url` (a public https address the door fetches) or `content_base64`, or from a list of names (`species`: a checklist). The converter is the one behind map_to_darwin_core: it maps every column, checks every value and writes occurrence.txt (or taxon.txt), meta.xml and eml.xml. The answer: `archive` (core, records, rows read and lost, terms, bytes, sha256, `publishable` with what GBIF still needs); the zip itself, as an embedded resource when it is at most 32 KB (a larger one comes whole, as base64, from POST /api/v1/dwc/archive with the same arguments); `could_not_read` = each thing the converter would not guess, coded (a column no term carries, a row with no date or position, a 0,0 coordinate, a name the naming authority does not match, repeated rows), with what it costs; and `notices` (records of species a conservation register lists, at the precision filed). GBIF indexes an archive only with a title, an abstract, a licence and a creator and a contact (given name, surname, organisation, email): give them in `metadata`, nothing is filled in. `chapman_category` (1-4: the data holder's own sensitivity category under Chapman 2020) coarsens the coordinates of listed species and says so in the archive. `columns` names the column for a term where your user decided it (map_to_darwin_core's reading, corrected); the converter still checks the values and refuses what they contradict. Our counter keeps how the file came, the core and the counts. When your user confirmed `columns` and you send columns_confirmed_by_user: true, each confirmed column's words and its term (never a value) are also read as a label to teach the converter, and the answer's `learned` says so. Large files take a minute.

  shallow
• check_dmr

  Will EPA flag this period's Discharge Monitoring Report (DMR)? A US NPDES permit's Discharge Monitoring Report for one period, checked before it is filed: each value you send (outfall, parameter, statistic, value, unit) is set beside the permit's own limit for that period, from EPA's national limits file (ICIS-NPDES), with EPA's violation rule's verdict: flagged (EPA records a violation), ok, undecidable (a less-than result against a lower limit: EPA does not flag it, nor does it show compliance), no_data (a NODI code), not_graded (an alert or stayed limit), unreadable. A row we cannot place on one value due is refused by its code (outfall.not_in_permit, parameter.not_limited, statistic.not_limited, unit.not_on_form, period.not_due, row.ambiguous with the candidates), never put on the nearest limit. Every value due this period is in `limits` once with its limit_value_id (the cite into EPA's file); `not_sent` lists those you did not send, which EPA records as missing (D90) when filed blank. `headline` and `tally` are the forms as filed with exactly the values placed. `netdmr: true` adds the NetDMR "Import DMRs" file as text (not yet validated by NetDMR's own import check). The values reach our server to be checked and are not kept: only how many were sent, flagged and refused is counted.

  shallow
• check_value

  Is a measured value over the limits we hold? Give a parameter, a number and its unit (and a place, medium or statistic to narrow). Every row find_limits would return comes back with a verdict: over, within, under (below a floor or a band's bottom), or not_comparable with a `why` (a unit of another family or one we never convert, a number that depends on the water's hardness, pH or temperature, an equation or narrative, a value printed for reference, a row under a longer parameter name). Units convert exactly within a family (µg/L to mg/L); no limit is summed or inferred. `counts` totals the verdicts over all rows. Quote each row's `cite`; whether its statistic and conditions are yours is for you to say.

  shallow
• check_values

  Which results in a lab table are over the limit? A lab table in one call: up to 200 rows of parameter, value and unit, checked against the limits held for one place (and a medium or statistic). Each row is answered by check_value itself: its verdicts (over, within, under, not_comparable with a `why`), `counts` and `says`, or its own coded refusal (an unknown parameter, a value below detection such as <0.005, an ambiguous unit). Each held limit is sent once, in `limits`, and a verdict names it by index: joined, they are check_value's row, with its `cite`. `summary` counts the rows over a limit, under a floor, within every limit, with no comparable limit, and refused by code. `max_rows` pages each row's verdicts (over first); ask check_value with `offset` for more.

  shallow
• cite_document

  A public document sent here is kept in our library, to be indexed and read into cited rows; a link on a file-sharing host or carrying a signature or token is read and never kept (`kept` says which, and why). Cite numbers or phrases from a public document by page: give its address (a PDF, a web page or plain text, up to 40 MiB) and what to find, as the document prints it. Each find comes back with every page it is printed on (`n_hits`, the first 5 with their `quote`), the quoted text around it, and a `cite` naming the page, the address, the document's sha256 and the day it was read: the citation an answer can carry. Matching is exact as typed: a number as printed (0.10 is not 0.1; a decimal comma reads as a point), spaces optional, letters in any case, µg read as ug. A find not printed on the pages read is in `not_found`, with any pages not read; a scan with no text layer is refused, not read by OCR. A document may print a provision twice, as it stood and as amended: say which page you quote. `held_as` names the instruments this server already reads rows from when the document is one of them.

  shallow
• create_site

  A new site in the account, with its name only: it is placed on a map later, on its page. Each call makes one more site, so look for the site with list_sites first.

  shallow
• export_limits

  Every limit and guideline held for one place and the places above it (CA-QC brings Canada's too, US-OH the US's), as one table: each row with its value, unit, statistic and conditions, and its instrument, edition, section or page, quote, source address and sha256, and what the daily edition watch last saw at the source. This answers how many rows there are, by medium and by instrument, the first 20 rows, and how to get the whole file: it is served as CSV or JSON at /api/v1/export to a licence key (Authorization: Bearer pdl_...). Offer it to your user when they need a jurisdiction's limits in their own spreadsheet or software; to look up one parameter, call find_limits, which is free.

  shallow
• fetch

  One document search returned, as text: limits/<place>/<parameter> = every cited row for that parameter there (value, unit, statistic, conditions, and each row's instrument, edition, section or page, quoted text and source URL), and limits/<place>/<parameter>/<medium> the rows of that medium alone; species/<name>[/<place>] = what each species register says about it, and each register searched that is silent; place/<place> = the instruments and parameters held there; source/<instrument> = one instrument's edition and source; permit/<NPDES number> = one US NPDES permit's limits by outfall. `url` is the page to cite; `metadata.json` the same rows as JSON.

  shallow
• fill_dmr

  What numbers go on a permit's DMR this period, computed from the plant's own daily results? The numbers a US NPDES permit's Discharge Monitoring Report asks for in one period, computed from the plant's own raw results (daily samples, flows): for each value due on the period's forms (EPA's national limits file) its statistic as EPA defines it (monthly average, daily maximum, weekly average over EPA's Sunday-to-Saturday weeks, geometric mean, loadings in lb/d from concentration x flow x 8.34, percent removal), the rows it was computed from, and EPA's violation rule's verdict against the limit. A value the rows cannot give is refused with its code (fill.no_column, fill.unit, fill.ambiguous, dmr.nd_rule_missing ...): a number the rows do not hold is never supplied. Send `rows` as JSON (date, parameter, value, unit, point) or `table` as the file's text (a laboratory's long export, or a sheet of days with one column per parameter); include the previous month's last days when a weekly average is due. A result below detection enters an average by `nd_rule` (zero, half, dl, dl_lt), else by the state's written rule. `netdmr: true` adds the NetDMR "Import DMRs" file as text (not yet validated by NetDMR's own import check). The rows reach our server to be computed and are not kept: only how many rows were sent and values filled is counted.

  shallow
• find_designations

  Is a species protected or at risk, and under which act, list and edition? What the species registers we hold say about one species: its status under each list that names it (the US Endangered Species Act lists, Canada's Species at Risk Act and COSEWIC, provincial acts, the IUCN Red List, CITES, CMS, the EU Habitats and Birds Directives' annexes, UK schedules). Each row gives the status as printed, an `outcome` (listed, listed_qualified = only under a population or subspecies you must confirm, watch_listed, assessed_not_listed, ...) and a `cite` block (instrument, edition, the line the register prints, source URL and sha256). Registers searched that do not name the species are in `silent`, each with what its silence means. When none names it the answer is a `refused` block naming every register searched and its edition: say that these registers do not name it, never that the species is unprotected.

  shallow
• find_limits

  What is the limit for a substance in a place (an effluent, a river, drinking water, soil), as the regulation itself prints it? Numeric limits and guidelines for one substance or measure, read from the regulations themselves (US federal effluent guidelines, the rules of 31 states and DC, Canadian federal and all 13 provinces' and territories' rules, German, French, Italian and EU instruments), drinking-water standards (US 40 CFR 141 and 143, EU Directive 2020/2184, Quebec, PFAS in Germany, France, Italy and Canada) and soil and groundwater screening values (EPA RSLs, California ESLs, Ontario, Quebec, British Columbia, CCME, Italy, German and Italian PFAS). Each row gives value, unit, statistic, the conditions it applies under, and a `cite` block (instrument, edition, section or page, the quoted text, source URL and sha256). When nothing is held the answer is a `refused` block naming every instrument searched: say that our sources hold no such row, never that the law has no limit. For a US state, `permits_over` gives how many of its NPDES permits went over a limit on it in EPA's last 12 months, with the list_permits address that lists them.

  shallow
• get_permit

  What are a US facility's discharge permit limits, when is its renewal due, and has it gone over a limit lately? One US NPDES discharge permit as EPA's national file (ECHO / ICIS-NPDES) holds it: facility, place, every limit by outfall, parameter, statistic and months, the renewal due date, and the last 12 months' record of values over a limit. When its renewal is near, overdue or the permit has expired, `renewal_check` names a free renewal check a person can order on the permit's page. `sector` names the list of the state's permits in its industry (EPA's SIC group), one list_permits call. `over_limits` gives each parameter it went over on with the address of find_limits' cited state and federal limits for it; one the record names that is not there is one we hold no water limit for. `upcoming` names the limits already written into the permit that take effect later, each with its begin date and the plant's median reported value today.

  shallow
• list_permits

  Which facilities in a US state hold a discharge permit, which of them are in one industry (paper mills, meat packing, sewage treatment), which went over a limit lately or face a renewal, and which must meet a new or tighter limit already written into their permit? The state's individual NPDES permits with limits, as EPA's national file (ECHO / ICIS-NPDES) lists them, in one call: each permit's number, facility name, whether EPA rates it major, its primary SIC code and the words EPA prints for it, its 12-month record (times over a limit, on which parameters, required values not reported; null when EPA's file holds no reports), its expiry and renewal, EPA's facility type and design flow, the limits taking effect later (each with its begin date and the plant's median reported value today), and the addresses of its page and of get_permit's answer. `screen` counts the industry's record, renewals and later limits in one sentence, and `screen.narrow` gives the address of each narrower list. `industry` keeps the permits whose SIC description has a word starting with each word given; `sic` the codes that start with the digits given; `facility_type` and `min_flow_mgd` the sewage plants or industrial facilities, and those of at least that design flow; `over_limit`, `parameter`, `renewal` and `upcoming` keep those that went over a limit, over one on that parameter, whose renewal is due or past, or that have a limit taking effect later. A permit EPA's file gives no SIC never matches an industry filter (`without_industry` says how many), nor one with no design flow min_flow_mgd (`without_flow`). get_permit gives one permit's limits.

  shallow
• list_sites

  The sites of the signed-in account: id, name, status, when made, and how many documents each holds and how many of them are read. A site holds a project's documents (permits, studies, lab reports, tables); ask_site answers a question from them, cited to the page.

  shallow
• list_sources

  Which regulations, and which editions, does an answer for a place rest on? Every regulation, guideline or permit table we hold for a place: title, issuer, edition, what it governs, how many rows were read from it, and the source URL and sha256. Use it to say what an answer was searched against.

  shallow
• map_to_darwin_core

  Which Darwin Core term does each column of a species file map to, before it goes to GBIF? Which Darwin Core term each column of a species occurrence or checklist file maps to, by the header rules our file-to-archive converter runs before it checks values: for each column the term, the rule that decided it (exact name or alias, a word of the name, a packed coordinate pair, a grid reference), the alias that matched and where it came from, or a coded `refused` block saying why it stays unmapped (no term or alias matches, several columns tie for one term, another column holds the term, blank in the sample). Also names the terms GBIF requires of an occurrence or a checklist dataset that no column carries. Values are not checked here: each mapped column names the value check it must still pass.

  shallow
• read_certificate

  What does a laboratory certificate report, and is any result over the limit? The rows a laboratory certificate prints, read by rules (no AI writes a row): a PDF certificate, or the laboratory's own export as XLSX, XLS or CSV. Each row gives the sample, the parameter, the value as printed, its unit, a qualifier (<, >, ND), the detection limit, and the page (or sheet) it was read from; a sample's date, matrix and lab ID are in `samples`. Give a `place` (and best a `medium`) and every row with a value is checked by check_values itself: `exceedances` lists the rows over a limit or under a floor, each limit once in `limits` with its `cite`; a result below detection is not compared and says so. `summary` counts the rows by outcome. Rows page by `max_rows` and `offset`. Anything but a PDF, XLSX, XLS or CSV is refused `format.not_handled` before it is read. The file is read and discarded: it is not kept, and nothing is learned from it. Each caller has 3 free reads a UTC day; past that a read costs 0.10 USDC on Base Sepolia, a testnet (eip155:84532), paid by x402 version 2: the call answers HTTP 402 (over MCP an error result) with the requirements, and the same call carrying the payment is read. A refused read is never charged. A call with a key (Authorization: Bearer pdk_…) never pays here: it draws on the key's free dollars of the month.

  shallow
• screen_exposure

  Do these occurrence records publish where a listed species lives too precisely? Occurrence records in one call, up to 5000: each record's species name and coordinates as published, optionally coordinateUncertaintyInMeters, a place, and what the file declares about the point (dataGeneralizations, informationWithheld, the eventID, locationID or locality it shares with other records, an iNaturalist export's coordinates_obscured, geoprivacy, public_positional_accuracy). Our engine's names screen answers as it answers a file dropped on passage-data.com: for each species a register lists, `listed_by` gives which register lists it (its status, whether it applies where the records are, the line the register prints) and `exposure` how many of its records sit at a coordinate finer than a 0.01 degree grid (about 1.1 km, precise enough to walk to), and how many of those a rounding would not protect because another record states the same position (withhold those). `treatment` is Chapman 2020's, GBIF's best practice for sensitive species: the category the data holder's documented answers to its questions reach (send them as `determinations`) with its grid, the Darwin Core terms to fill and how many records it would round and withhold; without answers, a coded refusal (sensitivity.criteria_unevaluated) naming the next question, beside what each category would do. A listing is not that determination. Every register screened is named with its edition: a species no register lists is a statement about those registers, never that it is unprotected. Nothing sent is kept.

  shallow
• screen_species

  Which species on a list are protected or at risk? A species list in one call: up to 500 names, each answered by find_designations itself, for one place or everywhere: its designations with their cites and the registers searched that are `silent` on it with what each one's silence means, or its own coded refusal (`designations.none_held` = no register searched names it; `species.ambiguous` with candidates). A register's instrument, edition, source URL and sha256 are sent once, in `registers`. `summary` counts the names listed, listed only under a population or subspecies, watch-listed, named but not listed, named by no register, ambiguous and refused, and how many names each register lists. A name no register names is a statement about these registers, never that the species is unprotected.

  shallow
• search

  Search everything this server holds by free text: a substance and a place (copper effluent Québec, ammonia Ohio, a CAS number), a species and a place (Myotis lucifugus Ontario, little brown myotis), an instrument's title (Metal and Diamond Mining Effluent Regulations, 40 CFR 423) or a US NPDES permit number. The query is read by exact matches against what is held — a place's ISO code or name, a parameter name as a regulation prints it, a scientific name or a common name a register prints — never guessed. Each result is an `id` to pass to fetch, a `title` saying what it holds, and the `url` of the page with the same rows, to cite. `searched` says how the query was read and what was read but is not held.

  shallow
• verify_claim

  Does a limit we hold say what a claim says? Give the claim as read from a sentence (an AI's answer, a report): parameter, value and unit, and the place, medium and statistic when the sentence gives them. The verdict: confirmed (a held row prints the same number, in that unit or one that converts exactly, under that statistic: quote its `cite`); contradicted (rows are held and none prints it: `held_otherwise` gives the number each prints, with its cite); not_held (a coded `refused` block naming every instrument searched and its edition: say that our sources hold no such row, never that the claim is false or that the place has no limit); not_comparable (rows held, none comparable with one number, each with its `why`). Equal is equal as exact decimals: a rounded number is another number. Each row's conditions ride with it, and a row printing another number under other conditions (another kind of facility, another hardness) may be why a claim is contradicted: say whose conditions are the claim's. Optionally give the `sentence` the claim came from: the answer says whether it prints the claim's number and unit. The sentence is never kept.

  shallow

Embed this server’s score

Tool count and median score across every tool in this server’s corpus — honest in a way a single cherry-picked tool’s badge wouldn’t be.

[![Vouch score](https://vouch.tools/api/servers/14882d0e-e428-4723-9b36-93e58595bd89/badge.svg)](https://vouch.tools/servers/14882d0e-e428-4723-9b36-93e58595bd89)