Strata documentation

Strata: an excavation as one graph

Strata holds an archaeological excavation as a single Relate graph file. Every find is connected to the layer it came from, the layers above and below it, its period and its site. Checks that run as Cypher inside the file show where the excavators' own records disagree.

The store in the repository, data/strata.rl, holds the complete published record of Kenan Tepe, a mound on the Upper Tigris in south-eastern Turkey, excavated from 1998 to 2007 and published openly on Open Context:

  • 3,280 stratigraphic units
  • 14,576 recorded relations between them
  • 19,742 finds, with animal bones linked to GBIF taxa
  • 268 open issues where the records disagree

The same graph can be used in five ways:

WhereWhat you getSection
BrowserThe viewer: Harris matrix per trench, unit records, issues, a Cypher console. Relate runs in the tab.Viewer
Browser agentNine WebMCP tools an AI agent in the browser can call.WebMCP
Claude DesktopA one-click extension with 19 tools, including checked edits.Desktop
Claude Code, other MCP hostsThe same MCP server over stdio.Claude Code
Terminal, PythonThe strata command and the strata package.CLI, Python

Getting started

In the browser

Open the viewer. The matrix is usable after about five seconds; the finds load behind it. Two good places to start:

  • Area F / Trench 1 / Locus 1032: dated Late Chalcolithic but lying above an Early Bronze Age I unit. The excavator's note says the bricks "may have been ancient trash", that is, redeposited older material.
  • Area A / Trench 9 / Locus 2: recorded both above and below Locus 4. The note explains why: "we separated L2 and L4 earlier in the season but found that they were equal".

In Claude Desktop

Download strata.mcpb from the latest release and open it. Then ask, for example, "What does Locus 20 in Area D, Trench 6 seal?" See Claude Desktop.

From a clone

You need Python 3.11+ and uv.

git clone https://github.com/openhistorymap/strata
cd strata
uv sync
uv run strata ask overview
uv run strata ask describe "Area F/Trench 1/Locus 1032"
uv run strata query "MATCH (i:Issue) RETURN i.kind, count(*) ORDER BY count(*) DESC"

The data: Kenan Tepe

Kenan Tepe (Wikidata Q6098540) was excavated by the Upper Tigris Archaeological Research Project. Its records were published as Bradley Parker and Peter Cobb (eds.), Kenan Tepe, Open Context, 2012, doi:10.6078/M7H41PBJ, under CC BY 4.0.

strata fetch kenan-tepe downloads every locus record and finds record through the Open Context API. It reduces them to three CSV files under data/sources/kenan-tepe/, one row per relation as recorded, with the record that states it. strata build turns those into the graph and runs every check.

In the storeCount
Contexts (loci, the stratigraphic units)3,280
Trenches68
Finds19,742
Periods7
Taxa (GBIF)66
:ABOVE relations (after merging reciprocal records)4,993
:CONTESTED claims set aside316
:SAME_AS / :ABUTS / :WITHIN559 / 3,699 / 258
Rows in the site's Harris matrix37
Open issues268

The graph model

Every node and relationship type, as stored in data/strata.rl and in the browser:

(:Site)<-[:IN_SITE]-(:Trench)<-[:IN_TRENCH]-(:Context)           a Context is a stratigraphic unit (locus, layer, cut, fill, wall)
(:Context)-[:IN_SITE]->(:Site)                                    a unit recorded without a trench
(:Context)-[:ABOVE {verbs, stated_by, sources, redundant}]->(:Context)   later -> earlier
(:Context)-[:CONTESTED]->(:Context)                              an ABOVE claim set aside: it contradicts another
(:Context)-[:REJECTED {rejected_by}]->(:Context)                 a claim an archaeologist ruled out (kept, not deleted)
(:Context)-[:SAME_AS|ABUTS|WITHIN]->(:Context)
(:Find)-[:FROM {bag}]->(:Context)      (:Find)-[:IDENTIFIED_AS]->(:Taxon {uri})
(:Context)-[:DATED_TO {basis}]->(:Period)-[:OF_SITE]->(:Site)
(:Context)-[:IN_PHASE]->(:Phase)-[:OF_SITE]->(:Site)
(:Issue {kind, severity, detail, records, status})-[:INVOLVES {position}]->(:Context)
(:Edit {op, args, note, author, ts, status})-[:TOUCHED]->(:Context)

Nodes

LabelKeyMain properties
Siteidname, description, country, location (point), wikidata, source, source_uri, license, license_label, recording_system
Trenchuidname ("Area F/Trench 1"), site
Contextuidlabel, path ("Area F/Trench 1/Locus 1032"), area, trench, type, description (the excavator's note), period_label, start_year, end_year, excavated_from/to, top_depth, bottom_depth, location (point), uri, citation, depth (row in the matrix, 0 = top)
Finduidlabel, category, material, type, taxon, start_year, end_year, uri, thumbnail
Perioduidname, start_year, end_year, site
Phaseuidname, site
Taxonuri (GBIF)name
Issueidkind, severity, detail, records, status ('open')
Editidop, args (JSON), note, author, ts, status

Every key has a uniqueness constraint. Context is also indexed on site, label and depth, Find on label, and Issue on kind. The schema is strata/schema.cypher.

Conventions

  • Direction. (a)-[:ABOVE]->(b) means a is later than b: it lies over it, cuts it, fills it or seals it. r.verbs says which; r.stated_by lists the unit records that state it, and r.sources their Open Context URIs.
  • Reciprocal records merged. "A above B" in A's record and "B below A" in B's record become one edge with both records in stated_by.
  • Years are astronomical. -3099 is 3100 BCE; year 0 is 1 BCE.
  • Dates are tentative. Kenan Tepe's periods come from field phasing. Units labelled "A / B" are linked to both periods with basis: 'either'.
  • Contradictions are kept. Nothing a record says is deleted. Claims that contradict others are retyped :CONTESTED so the rest is a clean matrix, and claims ruled out by a person become :REJECTED.

How Strata uses Relate

Mode: single file. An excavation archive is a document: it is deposited, cited, copied to a field laptop and handed to the next specialist. One .rl file is all of that. Relate opens it in-process, with no server.

WhereRelate buildStore
CLI, Python, MCP server, Claude DesktopPython wheel relate-db 1.2 (import relate)data/strata.rl or your copy, read-write
Official relate CLINative binary 1.2The same file: relate --database data/strata.rl "MATCH …"
Browser viewer@relate/relate-wasm 1.2.0 in a Web WorkerIn memory, loaded from a JSON export (the WASM build cannot open .rl)
  • Transactions. Every proposed edit is one transaction. The new relationship and a loop check run together; it commits with its :Edit log entry, or rolls back and leaves no trace.
  • Read-only access. The query tool and strata query refuse write clauses and run in a transaction that is always rolled back. The CLI opens the store read-only, so reading never changes the file.
  • One writer. Relate connections belong to the thread that opened them. The MCP server opens the store on one worker thread and hands every tool call to it, so two agents calling at once are serialised.
  • All reasoning is Cypher. Matrix rows, contradictions, redundancy, date brackets and provenance are queries; see checks.py and queries.py. A full rebuild, import plus every check, takes about 20 seconds; questions answer in milliseconds.

Stratigraphic reasoning

An excavation records stratigraphy one unit at a time: "this is above 17, 49 and 53; it is cut by 29". Together those statements form a directed graph that should be acyclic: the Harris matrix. strata check (also run by build and the recheck tool) does this, in order:

  1. Two-way contradictions. Pairs ordered both ways are found by pattern matching. Both claims are retyped :CONTESTED and the pair becomes an issue (self-contradiction, enclosed, cut-or-cover or conflicting records).
  2. Matrix rows and longer loops. Context.depth is computed by peeling the :ABOVE graph one layer per statement (Kahn's algorithm). Units left unplaced sit on a loop: shortestPath finds it, its closing edge is contested, and peeling resumes (up to 25 rounds).
  3. Other checks. Same-as conflicts, elevation conflicts (5 cm tolerance; cuts excluded) and period inversions.
  4. Redundant edges. An :ABOVE edge implied by a longer path is flagged redundant: true. The rest, the transitive reduction, is what a Harris matrix draws.
  5. Issues. Results are written as :Issue nodes linked to their units, replacing the previous run's.

Date brackets

A unit cannot be earlier than anything it seals, nor later than anything sealing it:

  • Not earlier than (terminus post quem): the latest start year among dated units below it.
  • Not later than (terminus ante quem): the earliest end year among dated units above it.

The viewer compares the recorded date with the bracket. It says whether the date fits, contradicts the stratigraphy, or fits only at the very edge of its range, as Locus 1032 does.

Issue kinds

KindSeverityMeaningKenan Tepe
self_contradictionerrorOne unit's record lists the same unit as both above and below it.86
same_as_conflicterrorTwo units recorded as one, yet one lies above the other.66
conflicting_recordserrorTwo records order the same pair in opposite directions.23
cycleerrorA longer loop: A above B above C above A.16
elevation_conflictwarningRecorded above a unit whose bottom elevation is higher than its own top.28
cut_or_coverwarningA "cuts" B by one record, B lies "above" A by another: the classic cut/fill ambiguity.26
period_inversionwarningAn earlier period lying above a later one: residual material, an intrusive unit, or a wrong relation.8
enclosedinfoAbove, below and within the same unit: an inclusion, not an order.15

Ask an agent to explain_issue to see every claim recorded between the units and which record made it.

The browser viewer

The viewer runs the whole graph (23,432 nodes, 40,796 relationships) in Relate's WebAssembly build, in a Web Worker in your tab. There is no server behind it.

What it shows

  • Trenches (left): each with its units and open issues. Units recorded without a trench form one matrix, "Units without a trench".
  • Harris matrix (centre): rows are Context.depth. Boxes are coloured by period and outlined red when the unit has open issues. Contested claims are red dashes and same-as links are dotted. Implied relations shows redundant edges. Drag to pan, scroll to zoom, Fit to see it all.
  • Unit (right): the excavator's note, open issues, date bracket and verdict, relations, contested claims with the records that make them, finds by category with taxa, and a link to the Open Context record. Everything it seals is outlined brown, everything sealing it blue.
  • Issues tab: all issues by kind. Click one to open its trench with every unit involved highlighted.
  • Cypher console (Ctrl+`): any Cypher, run with Ctrl+Enter, plus seven example queries. Every panel has a Cypher link that opens the query behind it.
  • Theme: Auto (follows your system), Light or Dark, remembered.

Links

URLOpens
…/strata/#Area F/Trench 1/Locus 1032A unit (URL-encode the path)
…/strata/#Area F/Trench 1A trench
…/strata/?dataset=kenan-tepeA dataset on the site, listed in data/datasets.json
…/strata/?data=https://…/my-dig.strata.jsonA Strata export at any URL that allows cross-origin requests (CORS)

Other datasets

The chip next to the title always says what is loaded and where it came from. Click it to open a dataset on the site, one at a URL, or a .strata.json file from your computer. You can also drop the file on the page. A local file is read in the tab and never uploaded; while it is loaded, the chip says Local file with its name, size and date. To make one, see Bundles.

Speed

Relate's WASM build loads about 3,000 nodes or relationships a second. The core graph (sites, trenches, units, periods, issues, the matrix) takes about five seconds and is usable at once; finds, taxa and abutments follow in about ten more. Queries take milliseconds.

Browser agents (WebMCP)

The viewer registers tools with WebMCP, so an AI agent running in your browser can work with the graph in the page. It uses document.modelContext.registerTool from the W3C draft, or navigator.modelContext where the browser provides that instead (Chrome 146+, the MCP-B extension). A WebMCP · 9 tools badge appears in the header when the browser supports it, and a toast shows each call an agent makes.

ToolDoesArguments
strata_datasetWhat is loaded and from where (built-in, URL, local file), its size, whether loading is complete, other datasets on the site.none
strata_trenchesEvery trench with units, open issues and matrix rows.none
strata_issuesOpen issues, most severe first, with their units.kind?, limit?
strata_describeA unit's record, note, periods, relations, contested claims, issues, date bracket and finds.unit
strata_relationWhether a is later, earlier or unrelated to b, with the chain of records and any contested direct claims.a, b
strata_queryRead-only Cypher against the graph in the tab.cypher, params?, limit?
strata_show_unitOpens a unit in the matrix and its record in the side panel.unit
strata_show_queryRuns a read-only query in the console, for the user to see.cypher, params?
strata_open_datasetReplaces the graph with a built-in dataset or one at a URL (marked consequential).dataset? or url?

Units are named by full path. A bare label works when it is unique, or unique in the trench on screen; otherwise the tool returns the candidates. Browser agents never edit the graph: the page's tools only read or navigate. Edits are what the MCP server is for.

MCP server and tools

strata mcp serves the store over MCP (stdio) with 19 tools. These are what the Claude Desktop extension and Claude Code use. The server's instructions tell agents to answer from the graph, cite unit paths and the records behind each claim, never invent a relation, and ask before settling a dispute.

Reading

ToolReturns
store_infoWhich .rl file is read and written (path, size, last change), why that file, its sites, and how many edits it holds.
overviewEvery site: contexts, relations, contested claims, finds, open issues.
queryRead-only Cypher (always rolled back): columns, rows (at most limit), whether rows were cut.
describeOne unit: record, matrix depth, what lies directly above and below, same-as units, contested claims, finds, open issues.
below / aboveEvery unit earlier than this one (everything it seals) / later than it.
relationEarlier, later, same, contested or unknown, with the chain of records that proves it.
date_bracketTerminus post quem and ante quem from dated units below and above, and whether the recorded date fits.
provenanceFind → bag → unit → period → site, the units sealing it, caveats, its date bracket.
issuesOpen problems, most severe first; filter by site and kind.
explain_issueAn issue's units and every claim recorded between them, with the record that made it.
period_sequenceWhich period lies directly over which, counted over the matrix.
historyInterpretive edits, newest first.

Writing

ToolDoes
propose_relationRecords that upper is later than lower (verb above, cuts, fills or seals). Refused, with the chain of records, if lower is already later than upper. Warns about period inversions, elevations and same-as links.
resolve_orderSettles a disputed pair: contrary claims become :REJECTED (kept), a contested claim in the chosen direction is restored. Agents must confirm with the user first.
assign_phasePuts units into a phase; warns when units of other phases lie between its members.
add_noteAttaches an interpretive note to a unit.
revertUndoes an edit; the reversal is logged too.
recheckRecomputes matrix depth, contested claims and issues for a site.

Try asking:

  • "Which finds come from units whose date is contradicted by the stratigraphy?"
  • "Locus 7042 and 7044 in F7 disagree. Show me both records and what else orders them."
  • "Record that Locus 53 lies above Locus 20 in Trench D6." This is refused, and the answer is the record chain that makes it impossible.

Edits, history and revert

Every change an agent or a person makes goes through a tool, never through raw Cypher:

  1. A transaction opens and the change is written, marked pending.
  2. The loop check runs: is there already a path from lower back to upper? If so, the transaction rolls back and the answer is {accepted: false, refused, chain, records}. The records are the ones that forbid the edit, with paths and Open Context URIs.
  3. Otherwise an :Edit node is written (op, arguments, note, author, timestamp) and linked to every unit it touched, the transaction commits, and the checks rerun.

history lists edits; revert undoes one and logs the reversal. Edits live in the store file, so they travel with it. A rebuild from source (strata build) starts from the published record again; keep your working store separate (see Claude Desktop, or set STRATA_DB).

Claude Desktop

Install

  1. Download strata.mcpb from the latest release.
  2. Open it, or drag it onto Claude Desktop's Settings → Extensions.
  3. Claude Desktop installs Python and the two dependencies (relate-db, fastmcp) itself.

Where your data is

The extension carries the Kenan Tepe store as a read-only seed and never writes to it. The server picks its store in this order:

  1. The extension's Strata store setting, a .rl file you choose (or STRATA_DB in the environment).
  2. Documents/Strata/strata.rl. On first run it is created from the seed; after that it is reused, so your edits survive extension updates and the file is yours to see, copy and back up.

Ask for store_info at any time: it reports the path, why it was chosen, its size, last change and number of edits.

Without the extension

From a clone, add this to claude_desktop_config.json. STRATA_DB is optional.

{
  "mcpServers": {
    "strata": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/strata", "strata", "mcp"],
      "env": { "STRATA_DB": "/path/to/my/strata.rl" }
    }
  }
}

Build the extension

uv run python desktop/build.py                                   # -> dist/strata-desktop/
npx -y @anthropic-ai/mcpb pack dist/strata-desktop dist/strata.mcpb

desktop/build.py copies the server modules and the store, writes a pyproject.toml with only the server's dependencies, and fills the manifest (MCPB 0.4, uv server type) with the version from pyproject.toml and the tool list from the server. Pushing a v* tag builds and attaches it to the release.

Claude Code and other hosts

claude mcp add strata -- uv run --directory "$PWD" strata mcp

Any MCP host that runs stdio servers works the same way: run uv run --directory /path/to/strata strata mcp, with STRATA_DB or --db to choose the store.

Relate's own MCP surface also works on the same file, offering raw Cypher instead of Strata's domain tools:

relate serve --database data/strata.rl --mcp stdio

Command line

strata [--db FILE] COMMAND. The store is --db, else $STRATA_DB, else data/strata.rl.

CommandDoes
fetch SITEDownloads a site from Open Context and normalises it into data/sources/SITE/ (Kenan Tepe: about 5 minutes; raw JSON cached in data/raw/).
build [SITE…]Rebuilds the store from data/sources/, runs every check, and refreshes the viewer's data in web/data/ (about 20 s).
import-matrix PATH --site ID [--name --format --license --license-label --source --source-uri]Adds a Harris-matrix file, in any format harris-mcp reads, then runs the checks.
check [SITE…]Recomputes matrix depth, contested edges and issues.
ask QUESTION ARGS [--site --kind --limit]Named questions (below).
query CYPHER [--params JSON] [--limit N]Read-only Cypher; the store is opened read-only.
statsNode and relationship counts.
export-web [--out DIR]Every site as DIR/SITE/{core,finds}.json, plus DIR/datasets.json (default web/data).
export-web --site ID --bundle FILEOne site as a single .strata.json the viewer opens from disk or a URL.
mcpServes the store over MCP (stdio).

strata ask

QuestionArgumentsExample
overviewstrata ask overview
issues--site --kind --limitstrata ask issues --kind period_inversion
describeunitstrata ask describe "Area F/Trench 1/Locus 1032"
below / aboveunitstrata ask below "Area D/Trench 6/Locus 20"
relationunit unitstrata ask relation "Area F/Trench 7/Locus 7042" "Area F/Trench 7/Locus 7044"
bracketunitstrata ask bracket "Area D/Trench 6/Locus 111"
provenancefindstrata ask provenance "Bone-ID KT00090"
periodssitestrata ask periods kenan-tepe

Units can be named by uid, full path, label, or the end of a path ("Trench 6/Locus 20"); --site narrows the search.

File formats

Relate store (.rl)

Relate's single-file format. Inspect it with relate info --database data/strata.rl, query it with the relate CLI or strata query.

Normalised sources (data/sources/SITE/)

FileColumns
site.jsonid, name, description, country, location [lat, lon], wikidata, source, source_uri, license, license_label, recording_system; optionally matrix (a Harris-matrix file to read instead of the CSVs)
contexts.csvuid, site, label, area, trench, path, type, period_label, start_year, end_year, excavated_from, excavated_to, top_depth, bottom_depth, context_rating, recorded_by, latitude, longitude, description, uri, citation
statements.csvsubject, verb, object, source: one row per relation as recorded. Verbs: above, below, cuts, cut_by, fills, filled_by, seals, sealed_by (→ ABOVE); equals, equal, contemporary (→ SAME_AS); abuts; within, contains.
finds.csvuid, site, label, category, context, bag, material, type, taxon, taxon_uri, start_year, end_year, uri, thumbnail

Harris-matrix files

strata import-matrix reads whatever harris-mcp reads: HMDP JSON, Harris Matrix Composer .hmc/.hmcx, the Harris Matrix Data Package (folder, datapackage.json or zip), CSV and XLSX.

Viewer export (strata-web, version 1)

The browser can't open .rl, so the graph travels as JSON. A part is:

{
  "meta":  {"part": "core", "dataset": "kenan-tepe", "built": "2026-11-22T12:49:59Z", "schema": ["CREATE CONSTRAINT …", …]},
  "nodes": [{"label": "Context", "key": "uid", "rows": [{"p": {…properties}, "pt": {"location": {"latitude": …, "longitude": …}}}]}],
  "edges": [{"type": "ABOVE", "from": ["Context", "uid"], "to": ["Context", "uid"], "rows": [[fromKey, toKey, {…properties}]]}]
}

A site is two parts: core (site, trenches, units, periods, phases, issues and their relationships) and finds (finds, taxa, FROM, IDENTIFIED_AS, ABUTS). On the site they are separate files listed in datasets.json:

{"format": "strata-web", "version": 1, "datasets": [
  {"id": "kenan-tepe", "name": "Kenan Tepe", "source": "…", "license": "CC BY 4.0", "built": "…", "store": "strata.rl",
   "parts": [{"path": "kenan-tepe/core.json", "bytes": …, "nodes": 3624, "relationships": 12448}, …]}]}

A bundle (.strata.json) is one site in one file, for local files and URLs:

{"format": "strata-web", "version": 1, "dataset": {…as in datasets.json}, "parts": [core, finds]}

Make one from any excavation Strata can import:

uv run strata --db my-dig.rl import-matrix my.hmcx --site my-dig --name "My dig"
uv run strata --db my-dig.rl export-web --site my-dig --bundle my-dig.strata.json

The viewer rebuilds the graph with UNWIND $rows AS r CREATE (n:Label {…}) in batches of 1,000. Labels, keys and property names must be plain identifiers; values are passed as parameters, and only http(s) links become clickable.

Python API

from strata.store import Store
from strata import queries as Q, edits as E

with Store("data/strata.rl", read_only=True) as s:
    Q.describe(s, "Area F/Trench 1/Locus 1032")
    Q.relation(s, "Area F/Trench 7/Locus 7042", "Area F/Trench 7/Locus 7044")
    s.run("MATCH (i:Issue) RETURN i.kind AS kind, count(*) AS n")       # autocommit
    s.read("MATCH (c:Context) RETURN c.path LIMIT 5")                   # always rolled back

with Store("my-copy.rl") as s:
    try:
        E.propose_relation(s, "Area D/Trench 6/Locus 53", "Area D/Trench 6/Locus 20", note="…")
    except E.Rejected as r:
        print(r.reason, r.evidence["chain"])
ModuleContents
strata.storeStore: run, one, value, read, transaction(), apply_schema, stats
strata.queriesresolve, describe, below, above, relation, date_bracket, provenance, issues, overview, period_sequence, explain_issue
strata.editspropose_relation, resolve_order, assign_phase, add_note, history, revert, Rejected
strata.checksrun_checks, compute_depth, mark_redundant, contest
strata.importersOpen Context fetch and normalise, CSV and Harris-matrix loaders, import_site
strata.web_exportexport_web, export_bundle
strata.desktopresolve_store, the extension's entry point

Development and deployment

uv run pytest                                                              # Python: import, checks, queries, edits, desktop store
docker run --rm -v "$PWD":/app -w /app node:22-slim node tests/web_smoke.mjs  # every viewer query, in Relate WASM under Node
python3 -m http.server -d web 8000                                         # the viewer at http://localhost:8000
PathWhat
strata/The package: store, schema, importers, checks, queries, edits, MCP server, CLI, exports, desktop entry.
data/strata.rl, data/sources/The store and the normalised sources it is built from.
web/The viewer: app.js, worker.js (Relate in a worker), loader.js, queries.js, matrix.js (layout), webmcp.js, docs/ (this page), vendor/relate-wasm/ (unmodified 1.2.0), data/.
desktop/Manifest template, icon, build script and release notes for the extension.
.github/workflows/pages.yml publishes web/; desktop.yml builds strata.mcpb on version tags.

Cache safety. Scripts and styles are referenced with ?v=51a6f97350, which the Pages workflow replaces with the commit hash, so a browser never mixes two deploys. Data parts are versioned by their build time. New imports in web/ must keep the suffix.

Limits and known issues

  • The browser loads a copy. Relate's WASM build runs in memory and cannot open .rl files, so the viewer loads a JSON export, which takes a few seconds. Changes made in the page are not saved.
  • Rebuilds start from the published record. strata build recreates data/strata.rl from the sources; edits in it are lost. Work in a copy (the desktop extension does).
  • Relate 1.2 query shapes. Strata avoids a few patterns that are slow or unsupported in this version: shortestPath with a filter on its relationships hangs when no path exists (hence :CONTESTED as its own type); shortestPath with a minimum length; nested pattern comprehensions; and, in the WASM build, COUNT { … } over a variable-length path.
  • Dates are field phasing. Kenan Tepe's periods are tentative. A period inversion is a question for a specialist, not an error in itself.
  • WebMCP is new. The API is a draft and changes between browser versions. The viewer supports both current spellings.

Data, licences, credits

  • Code: Apache-2.0.
  • Kenan Tepe data: Bradley Parker and Peter Cobb (eds.), Kenan Tepe, Open Context, 2012, doi:10.6078/M7H41PBJ, CC BY 4.0. Records were reduced to the fields Strata uses and their stratigraphic statements merged into graph relationships; each keeps the record that stated it and its URI. See NOTICE.
  • Taxa: linked to GBIF.
  • Relate (Python wheel, CLI and WASM build, Apache-2.0): relatedb/relate.
  • Harris-matrix readers: harris-mcp, part of Open History Map.

Strata was built for the Relate by Neo4j hackathon. Source, issues and releases: github.com/openhistorymap/strata.