Integrations

Each Swiftide integration sits behind its own feature flag. The matrix below shows which flag to add, what the integration plugs into, and where its guide is. An integration is a model provider, storage backend, node cache, loader, transformer, agent tool, token estimator or observability layer that lives behind a feature flag of the swiftide crate.

Feature flags

Name the feature flags of the integrations you use when you add swiftide:

cargo add swiftide@0.34 --features qdrant,fastembed

Feature flags are additive. Each one compiles its integration and the flags it depends on. Without its flag, an integration’s module does not exist: swiftide::integrations::qdrant needs qdrant. Only macros is on by default.

Most integrations live under swiftide::integrations, which re-exports the swiftide-integrations crate with the same feature names. A few sit elsewhere. MCP (Model Context Protocol) tools are in swiftide::agents::tools::mcp, Langfuse is under swiftide::langfuse, and the tree-sitter transformers are also re-exported under swiftide::indexing::transformers.

Some flags turn on other flags:

groq, gemini, ollama, open-router and dashscope each turn on openai. Their clients build on the OpenAI client.
mcp and langfuse each turn on swiftide-agents, which turns on swiftide-tasks. You do not need to add swiftide-agents next to them.

Some flags compile native code or large SDKs (software development kits) and make builds slower:

fastembed downloads ONNX (Open Neural Network Exchange) Runtime binaries at build time.
lancedb compiles an embedded database. It also needs a protoc binary on your PATH at build time.
duckdb links a DuckDB library that is already on your system. Point DUCKDB_LIB_DIR at it, make it findable through pkg-config, or set DUCKDB_DOWNLOAD_LIB=1 to download it during the build.
kafka builds librdkafka from source with CMake.
fluvio compiles the Fluvio client.
aws-bedrock compiles the AWS (Amazon Web Services) SDK.

Turn these on only in the crates that need them.

The all feature

The all flag turns on ten common integrations, but not anthropic, lancedb, mcp or swiftide-agents. It also includes fastembed and aws-bedrock, so it builds slowly. The all bundle lists exactly what it includes.

TLS

The HTTP (Hypertext Transfer Protocol) clients use rustls for TLS (Transport Layer Security) and need no setup: each uses the rustls crypto provider your application installed, or else its own. The exception is Redis over rediss://, where Swiftide installs aws-lc-rs as the process-wide provider before connecting if none is installed, so install yours before the first Redis call to use another.

The fastembed model download goes through native TLS, which means OpenSSL on Linux.

Matrix columns

Every flag, type and example in the matrix matches Swiftide 0.34.

Integration names the provider or backend, with a short note.
Feature flag is the flag to pass to cargo add.
Provides says where the integration plugs in:
- LLM: a large language model (LLM) client for prompts, chat completions and agents (SimplePrompt, ChatCompletion).
- Embeddings and Sparse embeddings: an embedder for dense or sparse vectors (EmbeddingModel, SparseEmbeddingModel).
- Structured output: typed responses through StructuredPrompt.
- Storage: a backend that the indexing pipeline stores nodes in (Persist).
- Retrieval: a retriever for the query pipeline (Retrieve). The storage guide for each backend lists the search strategies it supports.
- Node cache: a node cache that skips nodes an indexing pipeline has already processed (NodeCache).
- Loader: a loader that produces nodes (Loader).
- Transformers: transformers and chunkers for the indexing pipeline.
- Reranking: a response transformer that reorders retrieved documents (TransformResponse).
- Agent tooling: tools for agents, or token estimation.
- Observability: traces or metrics.
Main types are the types you build. Each links to docs.rs for the pinned release.
Examples link to example files in the Swiftide repository at the pinned commit.
Guide is the page on this site that shows the integration in use.

Integration	Feature flag	Provides	Main types	Examples	Guide
OpenAI: Chat Completions and the Responses API; Azure OpenAI through `GenericOpenAI` with `AzureConfig`.	`openai`	LLM, Embeddings, Structured output	`OpenAI`, `GenericOpenAI`	`responses_api.rs`, `responses_api_reasoning.rs`, `structured_prompt.rs`, `describe_image.rs`	integrations/openai
Anthropic	`anthropic`	LLM	`Anthropic`	`streaming_agents.rs`	integrations/anthropic
AWS Bedrock: Uses the Bedrock Converse API.	`aws-bedrock`	LLM, Structured output	`AwsBedrock`	`aws_bedrock.rs`, `aws_bedrock_agent.rs`	integrations/aws-bedrock
Groq: OpenAI-compatible client preconfigured for Groq.	`groq`	LLM, Structured output	`Groq`	`index_groq.rs`	integrations/openai-compatible
Google Gemini: OpenAI-compatible client preconfigured for the Gemini API.	`gemini`	LLM, Embeddings, Structured output	`Gemini`	`hello_agents.rs`	integrations/openai-compatible
Ollama: OpenAI-compatible client preconfigured for a local Ollama server.	`ollama`	LLM, Embeddings, Structured output	`Ollama`	`index_ollama.rs`, `index_md_into_pgvector.rs`	integrations/openai-compatible
OpenRouter: OpenAI-compatible client preconfigured for OpenRouter.	`open-router`	LLM, Structured output	`OpenRouter`	-	integrations/openai-compatible
Dashscope: OpenAI-compatible client preconfigured for Alibaba Dashscope.	`dashscope`	LLM, Embeddings, Structured output	`Dashscope`	`dashscope.rs`	integrations/openai-compatible
FastEmbed: Runs dense, sparse and reranking models locally with ONNX Runtime.	`fastembed`	Embeddings, Sparse embeddings, Reranking	`FastEmbed`, `Rerank`	`fastembed.rs`, `hybrid_search.rs`, `reranking.rs`	integrations/fastembed
Qdrant: Similarity and hybrid (dense + sparse) search, named vectors, filters.	`qdrant`	Storage, Retrieval	`Qdrant`	`index_codebase.rs`, `hybrid_search.rs`, `store_multiple_vectors.rs`	integrations/qdrant
PgVector	`pgvector`	Storage, Retrieval	`PgVector`	`index_md_into_pgvector.rs`	integrations/pgvector
LanceDB: Embedded, no server required; also supports custom queries.	`lancedb`	Storage, Retrieval	`LanceDB`	`lancedb.rs`, `dashscope.rs`	integrations/lancedb
DuckDB: Embedded; similarity and hybrid search.	`duckdb`	Storage, Retrieval, Node cache	`Duckdb`	-	indexing/storage
Redis: Also stores agent message history.	`redis`	Storage, Node cache	`Redis`	`index_into_redis.rs`, `index_codebase.rs`	indexing/caching
Redb: Embedded node cache, no server required.	`redb`	Node cache	`Redb`	-	indexing/caching
Kafka	`kafka`	Loader, Storage	`Kafka`	`kafka.rs`	indexing/loading
Fluvio	`fluvio`	Loader	`Fluvio`	`fluvio.rs`	indexing/loading
Parquet	`parquet`	Loader	`Parquet`	-	indexing/loading
Scraping (spider)	`scraping`	Loader, Transformers	`ScrapingLoader`, `HtmlToMarkdownTransformer`	`scraping_index_to_markdown.rs`	indexing/loading
Tree-sitter: Code-aware chunking, outlines and metadata; Perl behind `tree-sitter-perl`.	`tree-sitter`	Transformers	`ChunkCode`, `MetadataQACode`, `OutlineCodeTreeSitter`, `MetadataRefsDefsCode`	`index_codebase.rs`, `index_codebase_reduced_context.rs`	integrations/tree-sitter
MCP: Exposes the tools of any MCP server (via rmcp) to an agent.	`mcp`	Agent tooling	`McpToolbox`	`agents_mcp_tools.rs`	agents/mcp
tiktoken: Token estimation with OpenAI tokenizers.	`tiktoken`	Agent tooling	`TikToken`	-	models/errors-backoff-and-usage
Langfuse: A tracing layer that sends agent and pipeline spans to Langfuse.	`langfuse`	Observability	`LangfuseLayer`	`langfuse.rs`	observability/langfuse
Metrics: Emits usage and pipeline metrics through the `metrics` crate facade.	`metrics`	Observability	-	`usage_metrics.rs`	observability/metrics-and-statistics

Guides

This section has a page for each of these integrations:

OpenAI and Azure: Chat Completions, the Responses API (application programming interface), and Azure OpenAI.
OpenAI-compatible providers: Groq, Gemini, Ollama, OpenRouter, Dashscope and any OpenAI-compatible gateway.
Anthropic: prompts, chat completions, streaming and agents with Claude.
AWS Bedrock: Bedrock models through the Converse API.
FastEmbed: dense and sparse embeddings and reranking on your CPU (central processing unit).
Qdrant: storage with similarity and hybrid search.
PgVector: storage in Postgres with the pgvector extension.
LanceDB: an embedded vector store in a local directory.
Tree-sitter: chunking, outlines and metadata for source code.

The other integrations are covered on the page for the feature they serve. The Guide column in the matrix links to each one: DuckDB, Redis and Redb with storage and caching, Kafka, Fluvio, Parquet and scraping with loading, MCP with agents, tiktoken with model usage, and Langfuse and metrics with observability.

Reference

OpenAI and Azure