Skip to content
Back to search

open-index

Deterministic memory layer for your agents

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/drdroidlab--open-index/badge.svg)](/listings/drdroidlab--open-index)

HTML

<a href="/listings/drdroidlab--open-index"><img src="/api/listings/drdroidlab--open-index/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

pip install -e '.[all]'          # core + explorer UI + MCP server

# Try the bundled example (support brain: products, issues, segments, comments)
open-index index --brain examples/support-brain
open-index ui    --brain examples/support-brain      # open the Map tab, pick an anchor

# Or start your own brain from scratch
open-index init my-brain
open-index add-doc-type customer --brain my-brain
# ...add entities under my-brain/entities/**/*.json...
open-index index --brain my-brain
open-index ui    --brain my-brain

Prefer containers, or need a brain several agents share? → **[`docs/deployment.mdx`](./docs/deployment.mdx)** (`docker compose --profile sqlite up`).

Commands

| Command | What it does | |---|---| | `open-index init <name> [dir]` | Scaffold a new brain directory. | | `open-index add-doc-type <name>` | Add a doc_type schema stub under `doc_types/`. | | `open-index add-entity <file>` | Validate + store an entity JSON file. | | `open-index import <file>` | Bulk-import entities from JSON / JSONL / CSV. | | `open-index index` | (Re)load `entities/**/*.json` into the search index. | | `open-index validate` | Validate `brain.yaml`, schemas, and every entity file (use in CI). | | `open-index ingest <connector>` | Run a connector now to pull entities from an MCP server. | | `open-index run [--force] [--loop N]` | Run every connector whose `schedule` is due (wire into cron/CI). | | `open-index search <query> [-t doc_type]` | Search from the terminal. | | `open-index ui` | Launch the explorer (How to use / Schema / Explore / **Map** / Analytics / Jobs). | | `open-index mcp [--read-only]` | Run the MCP context layer over stdio. **Read+write by default**; `--read-only` opts out of writes. | | `open-index serve [--port --token --read-only]` | Serve the MCP context layer over **HTTP** for remote agents (bearer-token auth). | | `open-index serve --brains <root>` | Serve **every** brain under a directory from one process, each at `/<name>/mcp`. | | `open-index mcp-config [--url --token]` | Print the MCP connection block to paste into your agent. |

A context layer for domain-specialized agents

Open Index is designed to sit behind agents specialized for a domain—legal, marketing, customer support, sales, infrastructure, or a domain of your own. The MCP server gives those agents structured context and a validated way to keep that context current:

- **agent prompt** — dynamic domain navigation is published through MCP server instructions so supporting hosts can inject it before the first turn - **read** — `navigation_guidelines()` refreshes those instructions; `search_brain()` and `get_entity()` retrieve domain context - **write** — `put_entity()` (add/update an entity), `create_doc_type()` (define a concept)

Read and write is the default MCP mode so a domain agent can both use knowledge and maintain it. Add `--read-only` when the agent should consume context without mutating it. Claude Code is supported as one optional MCP client; `open-index init` scaffolds `.mcp.json`, `CLAUDE.md`, and an editing skill as conveniences for it.

Portable agent setup skill

[`skills/setup-open-index/SKILL.md`](./skills/setup-open-index/SKILL.md) follows the portable Agent Skills `SKILL.md` format used by agent runtimes including OpenClaw, Hermes, and Claude Code. Give or install this skill in the selected runtime when the agent should set up Open Index itself. It covers installation, domain-brain initialization, generic MCP wiring, default read/write verification, the `--read-only` opt-out, and production guardrails.

A brain on disk

my-brain/
  brain.yaml            # name + storage/search backend
  doc_types/*.yaml      # one schema per doc_type (fields, boosts, display color)
  entities/**/*.json    # entities, with related_to edges
  connectors/*.py       # optional ingestion scripts (MCP → entities)

Storage defaults to **SQLite + FTS5** (zero external services). The backend sits

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.

README.md · README · 405 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ### Open Index
  2. [![tests](https://github.com/DrDroidLab/open-index/actions/workflows/tests.yml/badge.svg)](https://github.com/DrDroidLab/open-index/actions/workflows/tests.yml)
  3. [![Join our Discord](https://img.shields.io/badge/Discord-join%20the%20community-5865F2?logo=discord&logoColor=white)](https://discord.gg/AQ3tusPtZn)
  4. **Open Index** is a tool for building domain specific accurate, structured data that agents can actually operate on — and for keeping that data correct as things change.
  5. You use Open Index to build a **brain**: a searchable, continuously-improving context graph of your domain. A brain is **domain-agnostic** — model a support org (`product → "has common issue" → issue`), a sales pipeline (`customer → order`), your infrastructure (`service → runbook`), or anything else. You define the concepts; Open Index stores them, searches them, and draws the map.
  6. A brain is built from four primitives:
  7. - **doc_type** — a concept you want to track and maintain (e.g. `service`, `customer`, `issue`).
  8. - **doc_schema** — the fields stored for a given doc_type.
  9. - **entity** — one instance of a doc_type, stored per its schema. Every entity can link to others via `related_to` (the target) + `relationship_edge_meaning` (free-text edge semantics).
  10. - **connector** — an optional source you extract entities from (e.g. an MCP server).
  11. ## Quickstart
  12. ```bash
  13. pip install -e '.[all]' # core + explorer UI + MCP server
  14. # Try the bundled example (support brain: products, issues, segments, comments)
  15. open-index index --brain examples/support-brain
  16. open-index ui --brain examples/support-brain # open the Map tab, pick an anchor
  17. # Or start your own brain from scratch
  18. open-index init my-brain
  19. open-index add-doc-type customer --brain my-brain
  20. # ...add entities under my-brain/entities/**/*.json...
  21. open-index index --brain my-brain
  22. open-index ui --brain my-brain
  23. ```
  24. Prefer containers, or need a brain several agents share? →
  25. **[`docs/deployment.mdx`](./docs/deployment.mdx)** (`docker compose --profile sqlite up`).
  26. ### Commands
  27. | Command | What it does |
  28. |---|---|
  29. | `open-index init <name> [dir]` | Scaffold a new brain directory. |
  30. | `open-index add-doc-type <name>` | Add a doc_type schema stub under `doc_types/`. |
  31. | `open-index add-entity <file>` | Validate + store an entity JSON file. |
  32. | `open-index import <file>` | Bulk-import entities from JSON / JSONL / CSV. |
  33. | `open-index index` | (Re)load `entities/**/*.json` into the search index. |
  34. | `open-index validate` | Validate `brain.yaml`, schemas, and every entity file (use in CI). |
  35. | `open-index ingest <connector>` | Run a connector now to pull entities from an MCP server. |
  36. | `open-index run [--force] [--loop N]` | Run every connector whose `schedule` is due (wire into cron/CI). |
  37. | `open-index search <query> [-t doc_type]` | Search from the terminal. |
  38. | `open-index ui` | Launch the explorer (How to use / Schema / Explore / **Map** / Analytics / Jobs). |
  39. | `open-index mcp [--read-only]` | Run the MCP context layer over stdio. **Read+write by default**; `--read-only` opts out of writes. |
  40. | `open-index serve [--port --token --read-only]` | Serve the MCP context layer over **HTTP** for remote agents (bearer-token auth). |
  41. | `open-index serve --brains <root>` | Serve **every** brain under a directory from one process, each at `/<name>/mcp`. |
  42. | `open-index mcp-config [--url --token]` | Print the MCP connection block to paste into your agent. |
  43. ### A context layer for domain-specialized agents
  44. Open Index is designed to sit behind agents specialized for a domain—legal,
  45. marketing, customer support, sales, infrastructure, or a domain of your own. The
  46. MCP server gives those agents structured context and a validated way to keep that
  47. context current:
  48. - **agent prompt** — dynamic domain navigation is published through MCP server
  49. instructions so supporting hosts can inject it before the first turn
  50. - **read** — `navigation_guidelines()` refreshes those instructions;
  51. `search_brain()` and `get_entity()` retrieve domain context
  52. - **write** — `put_entity()` (add/update an entity), `create_doc_type()` (define a concept)
  53. Read and write is the default MCP mode so a domain agent can both use knowledge
  54. and maintain it. Add `--read-only` when the agent should consume context without
  55. mutating it. Claude Code is supported as one optional MCP client; `open-index init`
  56. scaffolds `.mcp.json`, `CLAUDE.md`, and an editing skill as conveniences for it.
  57. ### Portable agent setup skill
  58. [`skills/setup-open-index/SKILL.md`](./skills/setup-open-index/SKILL.md) follows the
  59. portable Agent Skills `SKILL.md` format used by agent runtimes including OpenClaw,
  60. Hermes, and Claude Code. Give or install this skill in the selected runtime when
  61. the agent should set up Open Index itself. It covers installation, domain-brain
  62. initialization, generic MCP wiring, default read/write verification, the
  63. `--read-only` opt-out, and production guardrails.
  64. ### A brain on disk
  65. ```
  66. my-brain/
  67. brain.yaml # name + storage/search backend
  68. doc_types/*.yaml # one schema per doc_type (fields, boosts, display color)
  69. entities/**/*.json # entities, with related_to edges
  70. connectors/*.py # optional ingestion scripts (MCP → entities)
  71. ```
  72. Storage defaults to **SQLite + FTS5** (zero external services). The backend sits
  73. behind a pluggable interface with two implementations: SQLite (default, local/dev)
  74. and **OpenSearch** (select with `search.backend: opensearch` — see
  75. [Using the brain from a cloud agent](#using-the-brain-from-a-cloud-agent-production)).
  76. ### Where entities live — `storage: file | index`
  77. Each doc_type declares its source of truth, so curated and machine-generated data
  78. don't fight over git:
  79. - **`storage: index`** (default) — the search DB owns these entities; they are
  80. **not** written to files. Right for connector-pulled, high-volume, or temporal
  81. data (hundreds of services, memories, alerts) that would otherwise churn the repo.
  82. - **`storage: file`** — JSON files under `entities/<doc_type>/` are the source of
  83. truth, git-tracked and PR-reviewable. Right for curated, human/agent-authored
  84. entities.
  85. `open-index index` reconciles **file**-backed types from disk on each run and
  86. leaves **index**-backed entities (written by connectors/agents) untouched. So
  87. `brain.db` is durable state for index-backed types — back it up or re-ingest;
  88. it's gitignored by default.
  89. # Creating a brain, step by step
  90. `open-index init <name>` scaffolds the directory below; then you author two kinds
  91. of file — **doc_types** (schemas) and **entities** (instances). Sample doc_types:
  92. infra (`service`, `datastore`, `dashboard`, `runbook`, `alert`), sales (`lead`,
  93. `deal`, `account`), lending (`loan`, `borrower`, `application`), or personal
  94. (`goal`, `project`, `person`, `area`, `note`). Three runnable examples ship in
  95. [`examples/`](./examples): `support-brain`, `infra-brain`, and `personal-brain`.
  96. ### 1. Define a doc_type
  97. A doc_type is a concept plus its schema — one YAML file in `doc_types/`:
  98. ```yaml
  99. # doc_types/service.yaml
  100. doc_type: service
  101. description: A deployed service.
  102. storage: file # file = git source of truth · index = DB-owned (default)
  103. display:
  104. label_field: name
  105. color: "#7c3aed"
  106. schema:
  107. fields:
  108. - { name: name, type: string, search: syntactic, boost: 6 } # weighted 6× in ranking
  109. - { name: description, type: text, search: semantic }
  110. - { name: owner, type: string, search: syntactic }
  111. relationships: # the correlations this type uses — optional but recommended
  112. - { name: "writes to", target_doc_type: datastore }
  113. - { name: "is monitored by", target_doc_type: dashboard }
  114. ```
  115. - **`boost`** sets per-field search weight — a hit in a `boost: 6` title outranks a
  116. `boost: 1` description hit 6-to-1. Optional; defaults to 1.
  117. - **`relationships`** declares the edge vocabulary so correlations are discoverable
  118. (shown in the UI + navigation guide) and lightly validated (right target type).
  119. Optional — entities may still use undeclared meanings.
  120. Create one with `open-index add-doc-type service` (writes a stub you edit), or ask your agent.
  121. ### 2. Add entities
  122. An entity is one instance. For `storage: file` types, write one JSON per entity
  123. under `entities/<doc_type>/`:
  124. ```json
  125. // entities/service/checkout.json
  126. {
  127. "doc_type": "service",
  128. "id": "service:checkout",
  129. "name": "Checkout",
  130. "owner": "payments-team",
  131. "related_to": [
  132. { "target": "datastore:postgres-main", "relationship_edge_meaning": "writes to" },
  133. { "target": "dashboard:checkout-latency", "relationship_edge_meaning": "is monitored by" }
  134. ]
  135. }
  136. ```
  137. - `id` must be `<doc_type>:<slug>`.
  138. - **`related_to`** is the reserved correlation field present on **every** entity — it
  139. defines the graph edges (`target` + `relationship_edge_meaning`). This is how you
  140. say "this ticket is about that service" without any graph database.
  141. Then `open-index index` (loads file-backed entities) and `open-index validate`.
  142. ### 3. Populate at scale (four ways, one validated store)
  143. 1. **Manual / agent** — write JSON, or open Claude Code in the folder and let it call
  144. `put_entity` / `create_doc_type` over MCP.
  145. 2. **Bulk** — import a file directly, or let an agent write a batch in one call with
  146. `put_entities`:
  147. ```bash
  148. open-index import issues.csv --doc-type issue --asserted-by import:jira
  149. open-index import export.jsonl --dry-run # validate first, write nothing
  150. ```
  151. JSON arrays, JSONL, and CSV all work. Bare slugs are qualified (`checkout` →
  152. `product:checkout`), CSV scalars are coerced, and a `related_to` column takes
  153. `target|meaning` pairs separated by `;`. A bad row is reported and skipped —
  154. the rest still land. `--asserted-by` / `--confidence` attribute the whole
  155. batch once instead of per row.
  156. 3. **Connectors** — `connectors/*.py` pull from an MCP server on a `schedule`; run with
  157. `open-index ingest <name>` or `open-index run` (cron/CI-friendly).
  158. 4. **Agent write-back** — a Stop hook that records learnings via `put_entity` (the
  159. "continuously improving" loop).
  160. See [Entity Management](./docs/guides/entity-management.mdx) for guidance on cadence and decay.
  161. ### 4. Explore
  162. `open-index ui` opens a read-only explorer. The sidebar always shows every doc_type
  163. with its count and storage policy, so the structure is visible without navigating
  164. anywhere. Four tabs: **Explore** (search + browse + drill into an entity's
  165. relationships), **Map** (auto-anchored on the most-connected entities — click any
  166. node to expand it), **Analytics** (what context CLI/MCP/UI clients fetched, and how
  167. often — zero-result searches show what to model next), and **Jobs** (connectors and
  168. their schedules).
  169. # Using Open Index as your agent's context layer
  170. `open-index mcp` runs an MCP server (stdio) exposing the brain to any MCP client —
  171. **read and write by default**:
  172. - The server publishes dynamic, brain-specific instructions as part of the agent
  173. prompt so supporting hosts can navigate the domain before the first tool call.
  174. - `navigation_guidelines()` — refresh that guide after the index/schema changes.
  175. - `search_brain(query, doc_types, limit)` · `get_entity(id)` — read.
  176. - `put_entity(...)` · `put_entities([...])` · `create_doc_type(...)` — write (validated,
  177. honors the storage policy). `put_entities` writes a whole batch in one call and
  178. takes a shared `provenance` block.
  179. Use `open-index mcp --read-only` (or `open-index serve --read-only`) to opt out
  180. when an agent should retrieve domain context but never maintain it.
  181. ### Local context-fetch analytics
  182. CLI and MCP searches, entity fetches, and navigation-guide reads are recorded in
  183. the user's local state directory (`~/.local/state/open-index/`), outside the brain
  184. checkout. The Analytics tab shows fetch counts
  185. by client/operation, frequently fetched queries or entity IDs, latency, failures,
  186. zero-result searches, and recent activity. This file stays local and is never
  187. sent to Open Index's creators.
  188. `open-index init` also includes optional Claude Code conveniences: `.mcp.json`, a
  189. `CLAUDE.md` describing durable editing workflows (not runtime navigation), and an
  190. **`edit-brain` skill**. They are one client integration, not a requirement for
  191. building legal, marketing, support, or other specialized agents on Open Index.
  192. ## Using the brain from a cloud agent (production)
  193. 📖 **[Full deployment guide → `docs/deployment.mdx`](./docs/deployment.mdx)** — local,
  194. remote (with and without Docker), TLS/proxying, and exactly what to paste into
  195. Claude Code, Claude Desktop, or Cursor.
  196. ### Getting the connection details
  197. Never hand-assemble the config. Ask for it:
  198. ```bash
  199. open-index mcp-config --brain ./my-brain # local (stdio)
  200. open-index mcp-config --url brain.acme.internal:8080 --token $OPEN_INDEX_TOKEN
  201. open-index mcp-config --url https://brain.acme.com --token $TOKEN --cli # `claude mcp add …`
  202. open-index mcp-config --brain ./my-brain > .mcp.json # pipes where it belongs
  203. ```
  204. `open-index serve` prints the same details on startup — including the addresses a
  205. *remote* client can actually reach. (The bind address it listens on, `0.0.0.0`, is
  206. not one of them.) Behind a proxy or tunnel, pass `--public-url` so what's printed
  207. is what agents should use.
  208. ### With Docker (recommended for a shared brain)
  209. ```bash
  210. cp .env.example .env # set OPEN_INDEX_TOKEN + BRAIN_DIR
  211. docker compose --profile sqlite up --build # single writer, no extra services
  212. docker compose --profile opensearch up --build # many writers, incl. the cluster
  213. ```
  214. Both serve `http://localhost:8080/mcp`. Your `brain.yaml` is identical either way —
  215. the profile sets `OPEN_INDEX_SEARCH_BACKEND`, which overrides the file. Add
  216. `--profile ui` for the explorer on `:8501`. The brain directory is mounted, not
  217. baked into the image, so doc_types and entities stay in git.
  218. ### Without Docker
  219. ```bash
  220. pip install 'open-index[serve]' # add ,opensearch for that backend
  221. open-index index --brain /srv/acme-brain # load file-backed entities first
  222. OPEN_INDEX_TOKEN=… open-index serve --brain /srv/acme-brain --port 8080
  223. ```
  224. `serve` exposes the same read+write tools over **streamable HTTP** with
  225. **bearer-token auth**. Without a token the endpoint is unauthenticated — anyone who
  226. can reach the port can write to your brain. Use `--read-only` for a queryable
  227. endpoint that agents can't mutate.
  228. ### Choosing a backend
  229. **SQLite is single-writer.** That, not entity count, is the line: the moment a
  230. second agent needs to write, move to OpenSearch. It also gives native per-field
  231. boosting, **fuzzy** (typo-tolerant) search, and k-NN semantic search that scales
  232. past SQLite's ~10k-entity brute-force ceiling.
  233. Select it per-environment without touching `brain.yaml`:
  234. ```bash
  235. export OPEN_INDEX_SEARCH_BACKEND=opensearch
  236. export OPEN_INDEX_OPENSEARCH_HOSTS=https://opensearch.internal:9200
  237. ```
  238. …or commit it, with secrets as `${ENV}` refs resolved at connect time:
  239. ```yaml
  240. search:
  241. backend: opensearch
  242. hosts: ["https://opensearch:9200"]
  243. index: open_index_acme # optional; defaults to open_index_<name>
  244. username: "${OPENSEARCH_USER}"
  245. password: "${OPENSEARCH_PASSWORD}"
  246. use_ssl: true
  247. verify_certs: true
  248. ```
  249. The doc_type/file-entity part comes from git; index-backed data lives only in the
  250. cluster (or `brain.db`), so give it a persistent home and a backup. Rule of thumb:
  251. **local/dev → SQLite; shared endpoint → OpenSearch + `serve`.**
  252. # Controlling search
  253. 📖 **[Full configuration reference → `docs/guides/search-configuration.mdx`](./docs/guides/search-configuration.mdx)** —
  254. decision tables for `storage: file | index`, SQLite vs OpenSearch, and every search knob.
  255. **Schema** (per field): data `type` (string/number/boolean/timestamp), `processing`
  256. (keyword/text/timestamp), and `search` kind (`syntactic` = keyword+prefix,
  257. `semantic` = vector-backed dense search, `none` = not indexed).
  258. Mark a field `search: semantic` and the backend automatically embeds it at index time.
  259. **Ranking** — genuine **per-field boosters**: each field's `boost` weights how much a
  260. match there counts, so you tune "title matters more than description" with one number.
  261. For hybrid queries, keyword and semantic scores are blended with `search.semantic_weight`
  262. (default `0.3` — keyword matches dominate; semantic similarity rescues queries that use
  263. different words than the text). `semantic_weight: 0` gives keyword-only behavior; `1.0`
  264. gives semantic-only.
  265. Storage defaults to SQLite + FTS5; the OpenSearch backend implements the same
  266. interface with native per-field boosting, fuzzy matching, and k-NN semantic search.
  267. **Embedding model** — install the `[semantic]` extra (`pip install 'open-index[semantic]'`)
  268. to enable local embeddings. The default model is `BAAI/bge-small-en-v1.5` (384-D). Override
  269. it with `search.embedding_model` in `brain.yaml`, or use an OpenAI-compatible API by setting
  270. `OPEN_INDEX_EMBEDDING_BASE_URL`, `OPEN_INDEX_EMBEDDING_API_KEY`, `OPEN_INDEX_EMBEDDING_MODEL`,
  271. and `OPEN_INDEX_EMBEDDING_DIM`.
  272. Changing the embedding dimension (e.g., switching from the local 384-D model to a 512-D API
  273. provider) requires rebuilding the index: `open-index index --reembed` on SQLite, or a full
  274. `open-index index --reembed` on OpenSearch after recreating the index.
  275. **Re-embedding** — the reserved field `embedding` stores the per-entity vector. If you enable
  276. semantic search on an existing index, run `open-index index --reembed` to backfill vectors.
  277. **SQLite semantic ceiling** — the SQLite backend performs a brute-force cosine scan over the
  278. entities in scope. This is fine up to roughly **10,000 entities**; for larger brains, switch to
  279. the OpenSearch backend or a future `sqlite-vec` integration.
  280. _Not yet implemented (declarable seams exist): type-level & temporal boosters._
  281. # Contributing
  282. Contributions are welcome — new doc_type examples, connectors, backends, docs fixes,
  283. or bug reports all help.
  284. **Join the community on [Discord](https://discord.gg/AQ3tusPtZn)** to ask questions,
  285. share the brains you're modelling, or discuss an idea before you build it. It's the
  286. fastest way to get an answer and the best place to sanity-check a bigger change.
  287. ### Getting set up
  288. ```bash
  289. git clone https://github.com/DrDroidLab/open-index
  290. cd open-index
  291. pip install -e '.[all]' # core + explorer UI + MCP server
  292. pytest # run the test suite
  293. ```
  294. Note that `pytest` **skips** the MCP and UI suites when those extras aren't
  295. installed, so a green run on a partial install doesn't mean much — use `[all]`
  296. (or at least `[ui,mcp]`) locally. CI installs them explicitly and fails if they
  297. are missing.
  298. ### Making a change
  299. 1. **Open an issue first** for anything non-trivial (new backend, schema change,
  300. CLI surface) so we can agree on the shape — or bring it to Discord.
  301. 2. Branch off `main` (`feat/…`, `fix/…`, `docs/…`).
  302. 3. Add tests under `tests/` for behaviour changes, and run `pytest`.
  303. 4. If you touched a brain in `examples/`, run `open-index validate --brain examples/<name>`
  304. so schemas and entities stay consistent.
  305. 5. Update the README / the docs under `docs/` when you change user-facing behaviour.
  306. 6. Open a PR describing *what* changed and *why*, and link the issue. CI runs the
  307. test suite on Python 3.10 and 3.13 and validates every brain in `examples/`.
  308. ### Good first contributions
  309. - A new example brain under [`examples/`](./examples) for a domain we don't cover yet.
  310. - A connector in `connectors/` that pulls entities from an MCP server you use.
  311. - Doc_type schemas for a common vertical (support, infra, sales, lending, personal).
  312. - Sharper docs — if something tripped you up while onboarding, that's a bug.
  313. Questions, ideas, or just want to show what you built? → **https://discord.gg/AQ3tusPtZn**

Ratings and comments

Sign in to rate this skill.

Sign in

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