Registry & Defaults

Every swappable slot in indx — parser, LLM, VLM, embedder, store, output writer, and even pipeline stages — is bound by a short name. This page is the authoritative reference for how those names resolve to concrete classes, what registries hold them, how third-party plugins join in, and exactly which defaults you get out of the box.

For the protocol contracts each registered class must satisfy, see the protocols reference. To ship your own registrable component, see Authoring a plugin.

How resolution works

Each sub-package (indx.parsers, indx.llm, indx.embed, indx.store, indx.output, …) keeps a registry that maps a short name to a class. A component can be bound two ways:

• By object — you pass an instance that structurally satisfies the slot’s protocol.
• By name — you pass a string (in indx.toml, on the CLI, or to use()), and the registry resolves it to a class and constructs it.

Names may carry an optional :model suffix. The part before the colon selects the adapter class; the part after selects a model that adapter loads. For example, openai:gpt-5-mini picks OpenAILLM with gpt-5-mini; ollama:qwen2.5 picks OllamaLLM with the local qwen2.5 model.

The resolve() pattern

Each registry exposes the same small resolver shape (from technical-spec §4.7):

indx/llm/__init__.py

REGISTRY = {"openai": OpenAILLM, "ollama": OllamaLLM, "none": NullLLM}

def resolve(name: str) -> LLM:
    base, _, model = name.partition(":")
    cls = REGISTRY[base]               # raises ConfigError (exit 3) if the name is unknown
    return cls(model=model or None)

The base name selects the class; the optional model suffix is passed to the constructor. Slots without a model concept (such as store) ignore the suffix.

Lazy, import-safe builtins

First-party classes are registered with lazy imports (registry/builtins.py). Looking a name up never imports a backend you are not using, so resolution stays fast and an absent optional extra never breaks an unrelated run. The import only happens when that slot is actually selected — at which point a missing dependency raises an actionable MissingDependencyError pointing at the right pip install "indx[...]".

Resolution order

For each slot, the effective value is chosen by precedence — the first source that supplies a value wins:

explicit code argument / use() or CLI flag  >  indx.toml  >  documented default

Concretely: an instance or name passed in code (constructor argument or use()) and a CLI flag override the configuration file, which overrides the built-in default. See Configuration for the full precedence rules across all keys.

Unknown names fail fast

An unrecognized name is a fatal error, raised before any stage runs — not midway through a long build. A bad component name surfaces as configuration error exit code 3; see errors and exit codes.

Slot registry table

Each row lists the slot, the name strings the built-in registry accepts, and the default class indx constructs when nothing else is specified.

Slot	Name strings	Default class
parser	docling, plaintext	DoclingParser
llm	openai:<model>, ollama:<model>, none	OpenAILLM (gpt-5-mini)
vlm	none, <adapter>	NullVLM
embedder	openai:<model>, bge-m3, e5, cohere	OpenAIEmbedder (text-embedding-3-small)
store	qdrant, pgvector, chroma, lancedb, jsonl	QdrantStore
output	.indx, jsonl, langchain, llamaindex	IndxWriter

Notes on individual slots:

• llm — the model suffix pins the model for cloud and local adapters. The documented default is openai:gpt-5-mini; none selects a null LLM so the Enrich stage produces no LLM-derived metadata. Local and alternate adapters (ollama, anthropic, azure, vllm) become available with the matching extra.
• vlm — defaults to none (vision enrichment off). Adapter names like qwen-vl, gpt-4o, or a local served endpoint enable it.
• store — jsonl is the zero-dependency fallback that ships in core; the others require their client extra. See choosing a store.
• output — .indx is the sealed portable archive; jsonl is the zero-dependency writer; langchain and llamaindex emit framework-native objects. See output formats.

Local-first, offline-capable

The zero-dependency fallbacks shipped in core — the plaintext parser, jsonl store, none VLM, and the .indx + jsonl writers — mean a full build can run offline with no extras installed. The cloud-backed default uses OpenAI for model calls, while the local profile (docling + ollama:qwen2.5 + bge-m3 + qdrant) remains one install away. See local & air-gapped.

Entry-point groups (plugin discovery)

Third-party packages extend indx without modifying it by advertising Python packaging entry points. At runtime the registry discovers them via importlib.metadata and merges them into the per-slot registries — so installing a plugin package is enough to make its name usable anywhere a built-in is.

Entry-point group	Slot	Protocol
indx.parsers	parser	Parser
indx.llms	llm	LLM
indx.vlms	vlm	VLM
indx.embedders	embedder	Embedder
indx.stores	store	Store
indx.outputs	output	OutputWriter
indx.stages	pipeline	Stage

A plugin registers under the relevant group in its own pyproject.toml:

# pyproject.toml of a third-party package "indx-weaviate"
[project.entry-points."indx.stores"]
weaviate = "indx_weaviate.store:WeaviateStore"

After pip install indx-weaviate, the registry finds the entry point on first resolution, validates that the class satisfies the Store protocol, and registers it under the name weaviate. The name then works everywhere a built-in does:

[store]
backend = "weaviate"

DirectoryPipeline(store="weaviate")

First-party builtins win on collisions

If a plugin advertises a name that a first-party built-in already owns (e.g. qdrant), the built-in wins — a plugin may not silently shadow a core backend. To override a built-in, register your component under a distinct name.

Canonical defaults

The complete set of defaults applied when nothing is overridden in code, on the CLI, or in indx.toml:

Slot	Default name	Default class	Notes
parser	docling	DoclingParser	High-fidelity local parser; extra indx[docling].
llm	openai:gpt-5-mini	OpenAILLM (gpt-5-mini)	Cloud enrichment; none to disable, ollama:qwen2.5 for local.
vlm	none	NullVLM	Vision enrichment off by default.
embedder	openai:text-embedding-3-small	OpenAIEmbedder	Vector dimensionality 1536.
store	qdrant	QdrantStore	Embedded or server; jsonl is the zero-dep fallback.
output	.indx	IndxWriter	Sealed portable ZIP archive.

These map directly to the indx.toml keys [parser].engine, [enrich].llm, [enrich].vlm, [embed].model, [store].backend, and [output].format. The full configuration schema and per-backend sub-tables are documented in the configuration reference.

The resolved choices are recorded in the produced archive’s manifest and in index.json metadata, so a knowledge space is self-describing — a consumer can confirm exactly which embedder (and dimensionality) produced its vectors before querying. See the .indx archive and index.json references.

See also

• Protocols reference — the contract every registered class implements.
• Authoring a plugin — ship a registrable component via entry points.
• Configuration reference — names, precedence, and sub-tables.
• Bring your own stack — the design behind swappable slots.