Skip to content
Back to search

marmot

Interact with a Marmot data catalog instance. Use this skill when the user wants to search for data assets, view lineage, browse glossary terms, check pipeline runs, manage tags or owners, view metrics, query catalogued data, or do anything related to their data catalog. Covers the Marmot CLI, REST API and MCP server.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026. Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/marmotdata/marmot with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/marmotdata/marmot'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/marmotdata--marmot/badge.svg)](/listings/marmotdata--marmot)

HTML

<a href="/listings/marmotdata--marmot"><img src="/api/listings/marmotdata--marmot/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 320 lines
  1. ---
  2. name: marmot
  3. description: Interact with a Marmot data catalog instance. Use this skill when the user wants to search for data assets, view lineage, browse glossary terms, check pipeline runs, manage tags or owners, view metrics, query catalogued data, or do anything related to their data catalog. Covers the Marmot CLI, REST API and MCP server.
  4. ---
  5. This skill helps you interact with a Marmot data catalog. Marmot catalogs data assets (databases, tables, topics, APIs, dashboards) across an organisation's data stack and tracks lineage between them.
  6. ## Setup
  7. The user needs the Marmot CLI installed and authenticated. If not already set up, prefer Homebrew:
  8. ```bash
  9. brew install marmot
  10. ```
  11. Otherwise use the installer attached to a release, checked against that release's checksums. Never pipe a remote script into a shell. Set `VERSION` to the latest release from https://github.com/marmotdata/marmot/releases:
  12. ```bash
  13. VERSION=x.y.z
  14. BASE=https://github.com/marmotdata/marmot/releases/download/v$VERSION
  15. curl -fsSLO "$BASE/install.sh"
  16. curl -fsSLO "$BASE/marmot_${VERSION}_checksums.txt"
  17. grep ' install.sh$' "marmot_${VERSION}_checksums.txt" | sha256sum -c -
  18. ```
  19. If `cosign` is installed, also verify the checksum file came from Marmot's release workflow:
  20. ```bash
  21. curl -fsSLO "$BASE/marmot_${VERSION}_checksums.txt.sigstore.json"
  22. cosign verify-blob \
  23. --bundle "marmot_${VERSION}_checksums.txt.sigstore.json" \
  24. --certificate-identity "https://github.com/marmotdata/marmot/.github/workflows/release.yaml@refs/tags/v$VERSION" \
  25. --certificate-oidc-issuer https://token.actions.githubusercontent.com \
  26. "marmot_${VERSION}_checksums.txt"
  27. ```
  28. Stop if either check fails. Show the user `install.sh` and get their go-ahead before running it. The installer verifies the binary it downloads against the same checksums, and checks their signature too when `cosign` is available:
  29. ```bash
  30. MARMOT_VERSION=$VERSION sh install.sh
  31. marmot login https://marmot.example.com
  32. ```
  33. `marmot login` opens a browser for OAuth 2.0 PKCE authentication and caches the token locally. The token expires after 24 hours and carries the user's roles and permissions as claims. Login also registers the token with the Docker credential store for the instance's host, so `oras push`, `crane push` and `docker push` can publish plugins to the registry the instance serves. This goes through the `docker-credential-marmot` helper, a symlink to the marmot binary that `install.sh` creates; if the helper is not on your PATH, login writes the token itself into `~/.docker/config.json` the way `docker login` does. Alternatively, use an API key:
  34. ```bash
  35. export MARMOT_HOST=https://marmot.example.com
  36. export MARMOT_API_KEY=<key>
  37. ```
  38. Or pass `--host` and `--api-key` as flags on any command.
  39. `marmot skills install` refreshes this skill to match the installed CLI.
  40. ## MCP Server
  41. Marmot has a built-in MCP (Model Context Protocol) server. If the user has configured MCP, you can interact with the catalog directly using these tools instead of the CLI:
  42. Reading the catalog:
  43. - **discover_data**: unified data discovery. Supports natural language queries, lookups by ID or MRN (e.g. `postgres://db/schema/table`), filtering by type, provider and tags, and metadata-based queries.
  44. - **find_ownership**: ownership in both directions. "Who owns this asset?", "What does this user own?", "Show all data owned by the data-eng team". Works for assets and glossary terms.
  45. - **lookup_term**: business glossary lookups. Search for terms by name or retrieve definitions.
  46. - **explore_data_products**: curated collections of assets that serve a business purpose, and what they contain.
  47. - **explore_teams**: teams and their members.
  48. - **trace_lineage**: what feeds an asset (upstream) and what it feeds (downstream).
  49. Changing the catalog (only offered to callers allowed to make the change):
  50. - **update_documentation**: write or clear the human-authored description on an asset.
  51. - **manage_tags**: add or remove tags on an asset.
  52. - **manage_owners**: add or remove a user or team as an owner of an asset.
  53. Querying data (only offered to callers with `assets:query`):
  54. - **list_queryable_sources**: the sources that answer queries, searchable by name.
  55. - **query_data**: run one read-only SQL statement against a source. The answer carries the rows plus what the catalog knows about every table read, and the id the query was recorded under.
  56. Ask before calling the tools that change the catalog, even when the user's request implies the change. Say what you are about to write and to which asset.
  57. MCP configuration lives in `~/.claude.json` (user-level) or `.mcp.json` (project-level):
  58. ```json
  59. {
  60. "mcpServers": {
  61. "marmot": {
  62. "type": "http",
  63. "url": "https://<marmot-server>/api/v1/mcp",
  64. "headers": {
  65. "X-API-Key": "<api-key>"
  66. }
  67. }
  68. }
  69. }
  70. ```
  71. Prefer MCP tools when available. Fall back to the CLI or REST API for operations MCP doesn't cover (e.g. glossary writes, metrics, admin).
  72. ## Driving the CLI as an agent
  73. ```bash
  74. marmot agent schema # every command, flag, example, exit code and setting as JSON
  75. export MARMOT_READ_ONLY=true # refuse every command that is not a read (or pass --read-only)
  76. ```
  77. Load `marmot agent schema` once rather than walking `--help`. Each command carries `access`: `read`, `write` (changes the server) or `local` (changes local config or credentials). Unless the user wants you to change things, work with `MARMOT_READ_ONLY=true`; a blocked command exits with code 9 and changes nothing.
  78. Branch on the exit code, not the message:
  79. | Code | Meaning | What to do |
  80. |---|---|---|
  81. | 0 | Success | |
  82. | 1 | Other failure | Read the message |
  83. | 2 | Usage: wrong arguments or flags | Fix the command line |
  84. | 3 | Not authenticated | Ask the user to run `marmot login` or set `MARMOT_API_KEY` |
  85. | 4 | Forbidden, including a query you may not run | Don't retry or work round it; tell the user what access is missing |
  86. | 5 | Not found | Check the id or name |
  87. | 6 | Rejected as invalid, including SQL the source cannot run | Fix the request |
  88. | 7 | Rate limited | Wait, then retry |
  89. | 8 | Server failed or unreachable | Retry later |
  90. | 9 | Blocked by read-only mode | Ask the user before turning it off |
  91. | 10 | Needs confirmation and there is no terminal | Show the user the change; pass `--yes` only once they agree |
  92. | 11 | Confirmation declined | Stop |
  93. ## CLI Reference
  94. All commands follow the pattern `marmot <resource> <action> [args] [flags]`. Use `--output json` (or `-o json`) to get machine-readable output. Supported output formats: `table` (default), `json`, `yaml`.
  95. ### Assets
  96. ```bash
  97. marmot assets list # list assets (paginated)
  98. marmot assets search <query> # search assets
  99. marmot assets get <id> # get asset details
  100. marmot assets summary # counts by type, provider, tag
  101. marmot assets tags add <id> <tag> # add a tag
  102. marmot assets tags remove <id> <tag> # remove a tag
  103. marmot assets owners <id> # list owners
  104. marmot assets delete <id> # delete (prompts for confirmation)
  105. ```
  106. Filters: `--types`, `--providers`, `--tags`. Pagination: `--limit`, `--offset`.
  107. ### Search
  108. ```bash
  109. marmot search <query> # unified search (assets, glossary, teams, users)
  110. ```
  111. Filter by type with `--types asset,glossary`.
  112. ### Glossary
  113. ```bash
  114. marmot glossary list
  115. marmot glossary get <id>
  116. marmot glossary create --name "Term" --definition "What it means"
  117. marmot glossary update <id> --definition "New definition"
  118. marmot glossary delete <id>
  119. marmot glossary search <query>
  120. ```
  121. ### Lineage
  122. ```bash
  123. marmot lineage get <asset-id> # view upstream/downstream graph
  124. ```
  125. Use `--depth` to control traversal depth.
  126. ### Runs
  127. ```bash
  128. marmot runs list # list pipeline runs
  129. marmot runs get <id> # run details and summary
  130. marmot runs entities <id> # entities processed in a run
  131. ```
  132. Filter with `--pipelines` and `--statuses`.
  133. ### Querying data
  134. `marmot query` runs read-only SQL against catalogued sources as the caller, checks the caller may query every table the statement reads and records the query. It needs the `assets:query` permission.
  135. ```bash
  136. marmot query sources [--search <text>] # sources you can query
  137. marmot query tables <source> [--search <text>] # catalogued tables on a source, busiest first
  138. marmot query run <source> --table <name> # preview a table in the source's own dialect
  139. marmot query run <source> "SELECT ..." # run a statement
  140. marmot query run <source> --file q.sql # ... from a file
  141. marmot query run <source> - < q.sql # ... from stdin
  142. marmot query history [--decision denied] [--source <name>] [--mrn <mrn>]
  143. marmot query show <query-id> # one recorded query, with the reason if denied
  144. marmot query stats [--since 7d] # totals, busiest tables and callers
  145. ```
  146. - `query run` prints rows on stdout and the row count, query id and catalog context on stderr, so the table pipes cleanly. `-o json` returns everything in one document, including `truncated` when the row limit was hit (raise it with `--max-rows`).
  147. - A denial gives the reason. Don't rewrite the query to get round it; tell the user what access is missing.
  148. - `--since` takes `30m`, `24h`, `7d`, `2w` or an RFC 3339 time.
  149. ### Authentication
  150. ```bash
  151. marmot login # authenticate via browser (OAuth PKCE); reuses a valid cached token
  152. marmot login https://marmot.example.com # authenticate to a specific instance
  153. marmot login <url> --force # sign in again even if a token is cached
  154. marmot login <url> --print-token # print the access token on stdout (status goes to stderr)
  155. marmot login <url> --no-launch-browser # print the sign-in URL; paste the callback URL back to finish
  156. marmot logout # remove cached token and registry credential
  157. marmot context list # list contexts (* = active)
  158. marmot context use <name> # switch active context
  159. marmot context delete <name> # remove context and token
  160. ```
  161. ### Users and API Keys
  162. ```bash
  163. marmot users me # current authenticated user
  164. marmot users list
  165. marmot apikeys list
  166. marmot apikeys create <name> # key shown once at creation
  167. marmot apikeys delete <id>
  168. ```
  169. ### Teams
  170. ```bash
  171. marmot teams list
  172. marmot teams get <id>
  173. marmot teams members <id>
  174. ```
  175. ### Metrics
  176. ```bash
  177. marmot metrics summary # total assets + by-type breakdown
  178. marmot metrics by-type # asset counts by type
  179. marmot metrics by-provider # asset counts by provider
  180. marmot metrics top-assets --start <RFC3339> --end <RFC3339>
  181. marmot metrics top-queries --start <RFC3339> --end <RFC3339>
  182. ```
  183. `top-assets` and `top-queries` require a time range. `--start` and `--end` accept RFC3339 timestamps (e.g. `2026-01-01T00:00:00Z`). If omitted, defaults to the last 30 days. Use `--limit` to control how many results are returned (default 10).
  184. `summary`, `by-type` and `by-provider` do not require a time range.
  185. ### Admin
  186. ```bash
  187. marmot admin reindex # trigger search reindex
  188. marmot admin reindex-status # check progress
  189. ```
  190. ### Config
  191. ```bash
  192. marmot config init # interactive setup
  193. marmot config set <key> <value> # set a config value
  194. marmot config get <key> # get a config value
  195. marmot config list # list all config values (incl. active context)
  196. ```
  197. ## REST API
  198. The Marmot API is available at `{host}/api/v1/`. Authenticate with either the `X-API-Key` header or `Authorization: Bearer <token>` (from `marmot login`).
  199. ### Key Endpoints
  200. | Endpoint | Method | Description |
  201. |---|---|---|
  202. | `/api/v1/assets/search?q=...` | GET | Search assets |
  203. | `/api/v1/assets/{id}` | GET | Get asset by ID |
  204. | `/api/v1/assets/{id}` | DELETE | Delete asset |
  205. | `/api/v1/assets/summary` | GET | Asset summary stats |
  206. | `/api/v1/lineage/assets/{id}` | GET | Asset lineage graph |
  207. | `/api/v1/glossary/list` | GET | List glossary terms |
  208. | `/api/v1/glossary/{id}` | GET | Get glossary term |
  209. | `/api/v1/glossary/` | POST | Create glossary term |
  210. | `/api/v1/glossary/{id}` | PUT | Update glossary term |
  211. | `/api/v1/glossary/{id}` | DELETE | Delete glossary term |
  212. | `/api/v1/runs` | GET | List pipeline runs |
  213. | `/api/v1/runs/{id}` | GET | Get run details |
  214. | `/api/v1/search?q=...` | GET | Unified search |
  215. | `/api/v1/metrics` | GET | Aggregated metrics (requires `start` and `end` query params, RFC3339) |
  216. | `/api/v1/metrics/assets/total` | GET | Total asset count |
  217. | `/api/v1/metrics/assets/by-type` | GET | Assets by type |
  218. | `/api/v1/metrics/assets/by-provider` | GET | Assets by provider |
  219. | `/api/v1/metrics/top-queries` | GET | Top search queries (requires `start`, `end`) |
  220. | `/api/v1/metrics/top-assets` | GET | Top viewed assets (requires `start`, `end`) |
  221. | `/api/v1/users/me` | GET | Current user |
  222. | `/api/v1/users/apikeys` | GET | List API keys |
  223. | `/api/v1/users/apikeys` | POST | Create API key |
  224. | `/api/v1/teams` | GET | List teams |
  225. | `/api/v1/teams/{id}` | GET | Get team |
  226. | `/api/v1/teams/{id}/members` | GET | Team members |
  227. | `/api/v1/query/sources` | GET | Sources you can query |
  228. | `/api/v1/query/sources/{name}/tables` | GET | Catalogued tables on a source |
  229. | `/api/v1/query/run` | POST | Run a read-only statement (`source`, `statement`, `max_rows`) |
  230. | `/api/v1/query/history` | GET | Query log (`mine=true` for your own) |
  231. | `/api/v1/admin/search/reindex` | POST | Trigger reindex |
  232. | `/api/v1/admin/search/reindex` | GET | Reindex status |
  233. ### Time-range endpoints
  234. `/api/v1/metrics`, `/api/v1/metrics/top-queries` and `/api/v1/metrics/top-assets` require `start` and `end` query parameters in RFC3339 format. The maximum range is 30 days. Example:
  235. ```
  236. GET /api/v1/metrics/top-queries?start=2026-03-01T00:00:00Z&end=2026-03-26T00:00:00Z&limit=10
  237. ```
  238. ## Tips
  239. - Prefer MCP tools when the user has MCP configured. Fall back to the CLI for operations MCP doesn't cover.
  240. - Prefer the CLI over raw API calls when the user has it installed.
  241. - Use `-o json` and pipe through `jq` when the user needs to extract or transform data.
  242. - Asset IDs are UUIDs. Asset MRNs (Marmot Resource Names) look like `mrn://type/provider/name`.
  243. - Destructive commands (`assets delete`, `apikeys delete`) ask for confirmation, and refuse when there is no terminal to ask on. Pass `--yes` only once the user has agreed to that specific change.
  244. - To answer a question from the data itself, find the table first (`discover_data` or `marmot query tables`), check its description and tags, then query it. Quote the query id with the answer so the user can find it in the log.
  245. - All list commands support `--limit` and `--offset` for pagination.
  246. - When using the REST API directly, authenticate with either `X-API-Key` or `Authorization: Bearer <token>` header.
README.md · README · 153 lines
  1. <p align="center">
  2. <img src="./marmot.svg" alt="" height="96">
  3. &nbsp;&nbsp;
  4. <picture>
  5. <source media="(prefers-color-scheme: dark)" srcset="./web/docs/static/img/marmot-wordmark-paper.svg">
  6. <img src="./web/docs/static/img/marmot-wordmark-ink.svg" alt="Marmot" height="72">
  7. </picture>
  8. </p>
  9. <p align="center">
  10. <strong>One governed way in to your data, for people and AI agents.</strong>
  11. </p>
  12. <p align="center">
  13. Marmot catalogs your tables, topics, dashboards and pipelines with 70+ plugins, records their lineage, owners and definitions,
  14. and lets people and agents query the data through it, with every query checked and audited.<br>
  15. Use it from the web UI, the CLI, the SDKs or its built-in MCP server. It runs as one Go binary backed by PostgreSQL.
  16. </p>
  17. <p align="center">
  18. <a href="https://marmotdata.io/docs/quick-start">Quick start</a> ·
  19. <a href="https://marmotdata.io/docs/introduction">Documentation</a> ·
  20. <a href="https://plugins.marmotdata.io">Plugins</a> ·
  21. <a href="https://cloud.marmotdata.io/signup">Marmot Cloud</a> ·
  22. <a href="https://discord.gg/TWCk7hVFN4">Discord</a>
  23. </p>
  24. <picture>
  25. <source media="(prefers-color-scheme: dark)" srcset="./web/docs/static/img/readme-tour-dark.webp">
  26. <img src="./web/docs/static/img/readme-tour-light.webp" alt="A tour of Marmot: Discover narrowed to finance tables, the orders_daily asset page with its owners and glossary terms, a governed query that returns rows and a refused one in the query audit, then the lineage of orders_daily from source to dashboard">
  27. </picture>
  28. ## What you can do with it
  29. Marmot catalogs the tables, topics, dashboards and pipelines you already run, records what each one means and who owns it, and serves that context to everyone from one place:
  30. - **Search every source** in plain words, then narrow the results with the [query language](https://marmotdata.io/docs/queries).
  31. - **Trace lineage** upstream and downstream, from plugins and [OpenLineage](https://marmotdata.io/docs/open-lineage) runs, before you change something. See [lineage](https://marmotdata.io/docs/lineage).
  32. - **Explain what data means** with owners, descriptions, a [glossary](https://marmotdata.io/docs/glossary) and [data products](https://marmotdata.io/docs/data-products) that travel with every asset.
  33. - **Give agents the same context** through the [MCP server](https://marmotdata.io/docs/MCP), the CLI and SDKs for Go, Python and TypeScript.
  34. - **Run SQL through Marmot** against the sources you connect. Each query is checked against the caller's roles and recorded in the [query audit](https://marmotdata.io/docs/query-audit), so an agent never needs a database password of its own.
  35. - **Keep it current** with [70+ plugins](https://plugins.marmotdata.io) for systems such as PostgreSQL, BigQuery, Kafka, dbt and Airflow, or declare assets yourself with [Terraform](https://marmotdata.io/docs/Populating/Terraform) and the [API](https://marmotdata.io/docs/Populating/API).
  36. ## Try it locally
  37. You need Docker with Docker Compose, and port 8080 free. Save this as `docker-compose.yaml`. It's for trying Marmot out, so it stores credentials unencrypted:
  38. ```yaml
  39. services:
  40. marmot:
  41. image: ghcr.io/marmotdata/marmot:latest
  42. ports:
  43. - "8080:8080"
  44. environment:
  45. MARMOT_DATABASE_HOST: postgres
  46. MARMOT_DATABASE_PORT: 5432
  47. MARMOT_DATABASE_USER: marmot
  48. MARMOT_DATABASE_PASSWORD: marmot
  49. MARMOT_DATABASE_NAME: marmot
  50. MARMOT_DATABASE_SSLMODE: disable
  51. MARMOT_SERVER_ALLOW_UNENCRYPTED: true
  52. depends_on:
  53. postgres:
  54. condition: service_healthy
  55. postgres:
  56. image: postgres:16-alpine
  57. environment:
  58. POSTGRES_USER: marmot
  59. POSTGRES_PASSWORD: marmot
  60. POSTGRES_DB: marmot
  61. volumes:
  62. - marmot_data:/var/lib/postgresql/data
  63. healthcheck:
  64. test: ["CMD-SHELL", "pg_isready -U marmot"]
  65. interval: 5s
  66. timeout: 5s
  67. retries: 5
  68. volumes:
  69. marmot_data:
  70. ```
  71. Start it:
  72. ```bash
  73. docker compose up -d
  74. ```
  75. Open [http://localhost:8080](http://localhost:8080) and sign in as `admin` with the password `admin`. Marmot asks you to choose a new password, then you can open **Plugins** and pick a system under **Add a source** to catalog it. The [quick start](https://marmotdata.io/docs/quick-start) walks through the first pipeline.
  76. To skip running it yourself, [Marmot Cloud](https://marmotdata.io/docs/Cloud/getting-started) launches a managed instance. The free plan needs no card.
  77. ## Connect an agent
  78. Create an API key under **Account → API keys**, then add Marmot to your client's MCP configuration. For Claude Code, that's `.mcp.json` in your project's root:
  79. ```json
  80. {
  81. "mcpServers": {
  82. "marmot": {
  83. "type": "http",
  84. "url": "http://localhost:8080/api/v1/mcp",
  85. "headers": {
  86. "X-API-Key": "<api-key>"
  87. }
  88. }
  89. }
  90. }
  91. ```
  92. The agent can then search the catalog, trace lineage and look up owners and glossary terms, with the same permissions as the key it uses:
  93. <picture>
  94. <source media="(prefers-color-scheme: dark)" srcset="./web/docs/static/img/readme-agent-lineage-dark.png">
  95. <img src="./web/docs/static/img/readme-agent-lineage-light.png" alt="Claude answering which upstream service writes to a data warehouse by tracing lineage in Marmot" width="640">
  96. </picture>
  97. The [MCP docs](https://marmotdata.io/docs/MCP) cover Claude Desktop, Cursor, Cline and LibreChat. [Marmot for agents](https://marmotdata.io/docs/Agents) covers skills, LangChain and the Claude Agent SDK.
  98. ## Work from your terminal
  99. The `marmot` CLI searches the catalog, manages assets and runs the server. Install it with Homebrew:
  100. ```bash
  101. brew install marmot
  102. ```
  103. Or with the install script:
  104. ```bash
  105. curl -fsSL get.marmotdata.io | sh
  106. ```
  107. See the [CLI reference](https://marmotdata.io/docs/cli) for every command.
  108. ## Run it for your team
  109. The core is open source under the MIT licence and runs anywhere you can run a container or a binary. [Self-host](https://marmotdata.io/docs/Deploy) covers Docker Compose, Docker, Helm and the binary, with an encryption key for stored credentials. [Marmot Cloud](https://marmotdata.io/docs/Cloud) runs it for you and adds access control per resource, secret stores and keyless pipelines. The data model, query language, plugins and MCP server are the same in both.
  110. ## Get help
  111. - [Discord](https://discord.gg/TWCk7hVFN4) for questions and talking to the team and other people running Marmot.
  112. - [GitHub issues](https://github.com/marmotdata/marmot/issues) for bugs and feature requests.
  113. - [Report a vulnerability](https://marmotdata.io/security) privately, not in an issue.
  114. ## Contributing
  115. Read the [contributing guide](CONTRIBUTING.md) before you open a pull request. [Local development](https://marmotdata.io/docs/Develop/local-development) gets Marmot running from source, and [build a plugin](https://marmotdata.io/docs/Develop/creating-plugins) covers connecting a system that has no plugin yet.
  116. ## Licence
  117. Marmot is open source under the [MIT licence](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.