Dust Elasticsearch logo

Dust Elasticsearch

OrganizationPopular
dust-tt
dust-elasticsearch

Create, migrate, or query Elasticsearch indices in `front`. Use when adding a new front Elasticsearch index, changing mappings or settings, wiring indexing logic, or exposing Elasticsearch-backed analytics/search endpoints.

Overview

Publisherdust-tt
Repositorydust
Skill namedust-elasticsearch
Stars
1.5K
Forks
370
Bundled files
5
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 5 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by dust-tt on GitHub. Read the source before you install it.

Installation

Install the Dust Elasticsearch AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/dust-tt/dust/tree/main/.claude/skills/dust-elasticsearch
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/dust-tt/dust.git /tmp/dust
mkdir -p .claude/skills
cp -r /tmp/dust/.claude/skills/dust-elasticsearch .claude/skills/dust-elasticsearch
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Dust Elasticsearch in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Dust Elasticsearch on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Dust Elasticsearch is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Front Elasticsearch

Use this skill when working on Elasticsearch-backed features in front. SKILL.md covers the default path for routine work. You should only load the supporting references when you need deeper material such as analyzer design, full curl verification, query recipes, or relocation details.

Default Workflow

  1. Decide whether you are:
    • adding a brand-new index
    • shipping a new version of an existing index
    • only changing indexing or querying logic on top of an existing alias
  2. Define the document type under front/types/....
    • Extend ElasticsearchBaseDocument for workspace-scoped indices instead of redeclaring workspace_id.
    • Keep a stable primary identifier in the document and include a migration-friendly timestamp such as updated_at when backfills or version bumps are likely.
  3. Create versioned mappings and per-region settings under front/lib/<feature>/indices/.
    • Prefer keyword for ids and enums, date for timestamps, numeric field types for metrics, nested only when array element relationships matter, and text only when full-text search is actually required.
  4. Register the stable alias and index directory in front/lib/api/elasticsearch.ts.
    • App code should read and write through the alias, not a concrete versioned index name.
  5. Create the physical index with tsx front/scripts/create_elasticsearch_index.ts.
    • The normal shape is front.<index_name>_<version> behind alias front.<index_name>.
  6. Add indexing helpers using deterministic document ids and alias-based writes.
    • The common pattern is ${workspaceId}_${entityId} or an equivalent deterministic key.
    • Use withEs(...) and client.index, client.update, or client.bulk.
  7. Add query helpers or endpoints.
    • Start with bool.filter.
    • Include workspace_id for workspace-scoped indices.
    • Use size: 0 for aggregation-only queries.
  8. If indexing is asynchronous or retry-prone, wire it through the shared Temporal ES queue.
  9. If the index must survive workspace relocation between regions, add the relocation activity and workflow hook.

Core Rules

  • Keep one mappings file per index version and one settings file per region.
  • Use version bumps for incompatible mapping or analyzer changes rather than mutating a live index in place.
  • Simple analytics indices usually do not need custom analyzers or Elasticsearch plugins.
  • If you need prefix search, multi-field mappings, ICU analyzers, or email-aware tokenization, read references/create-index.md before editing mappings.
  • Prefer async indexing through front/temporal/es_indexation/* when the write path does not need to block on Elasticsearch freshness.
  • Check relocation requirements for any workspace-scoped index that is expected to remain available after workspace region moves.

Current Architecture

This skill focuses on Elasticsearch indices managed in front, especially analytics-style indices, but the patterns also match the broader Dust Elasticsearch setup.

Current examples to copy from:

  • front.agent_message_analytics
    • version 2
    • write alias front.agent_message_analytics
    • basic mappings, no custom analyzers
  • core.data_sources_nodes
    • version 4
    • write alias core.data_sources_nodes
    • advanced analyzers, edge n-grams, multi-field mappings, and normalizers

The general pattern is:

  • versioned physical indices such as front.<index_name>_<version>
  • one stable alias such as front.<index_name> for app reads and writes
  • mappings and region-specific settings stored alongside the feature code

Primary Files

  • front/lib/api/elasticsearch.ts
  • front/scripts/create_elasticsearch_index.ts
  • front/lib/*/indices/*.mappings.json
  • front/lib/*/indices/*.settings.{region}.json
  • front/temporal/es_indexation/*
  • front/temporal/relocation/activities/destination_region/front/es_indexation.ts
  • front/temporal/relocation/workflows.ts

Existing References In Code

  • front/lib/user_search/indices/
  • front/lib/user_search/index.ts
  • front/lib/analytics/indices/
  • core/src/search_stores/indices/data_sources_nodes_4.*

Validation

  • The document type and mappings agree on field names and field kinds.
  • The index has a stable alias constant and an INDEX_DIRECTORIES entry.
  • The version in the script invocation matches the versioned mappings/settings filenames.
  • Writes target the alias constant rather than a concrete versioned index name.
  • Query helpers filter by workspace_id when the index is workspace-scoped.
  • Aggregation-only queries use size: 0.
  • Temporal integration exists when indexing is asynchronous or needs retries.
  • Relocation support exists when the index must be rebuilt in a destination region.

Supporting References

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Dust Elasticsearch AI skill do?

Create, migrate, or query Elasticsearch indices in `front`. Use when adding a new front Elasticsearch index, changing mappings or settings, wiring indexing logic, or exposing Elasticsearch-backed analytics/search endpoints.

Why use Dust Elasticsearch on TypingMind?

Because you install it once and use it with any model. Dust Elasticsearch is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Dust Elasticsearch in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/dust-tt/dust/tree/main/.claude/skills/dust-elasticsearch. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Dust Elasticsearch?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Dust Elasticsearch?

As many as you like. As long as a model supports skills, you can use Dust Elasticsearch with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Dust Elasticsearch AI skill free?

Yes. It is published on GitHub by dust-tt under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇