Skip to main content
Pre-release

This release is a pre-release and may not be stable for production use.

fastretrieval

Fast multi-model retrieval runtime: ONNX and GGUF embeddings, reranking, and a declarative model contract

CI codecov PyPI License: Apache-2.0

Python ONNX Runtime Hugging Face semantic-release Renovate

Sister projects from n24q02m (click to expand)
Project Tagline Tag
better-semantic-release Drop-in python-semantic-release fork with built-in release-safety guards (orp... Tooling
claude-plugins Claude Code plugin marketplace for the n24q02m MCP servers -- install web sea... Marketplace
crg Knowledge graph for token-efficient code reviews -- semantic search and call-... MCP
email IMAP/SMTP email for AI agents -- read, send, organize folders, and manage att... MCP
fastretrieval Fast multi-model retrieval runtime: ONNX and GGUF embeddings, reranking, and ... Tooling
hull hull is the shared monorepo core for the wet, crg and mnemo self-hosted stack MCP
jules-task-archiver Chrome Extension for bulk operations on Jules tasks via batchexecute API -- a... Tooling
mnemo Persistent AI memory with hybrid search. Open, free, unlimited. MCP
notion Markdown-first Notion for AI agents -- pages, databases, blocks, and comments... MCP
sillstone Pure-Rust multimedia, hashing, and array suite Tooling
skret Secrets without the server. CLI
tacet A self-distilling neuro-symbolic cascade that amortises LLM cost across knowl... Tooling
telegram Telegram for AI agents -- messages, chats, media, and contacts across both bo... MCP
tools-docs Docs portal for the n24q02m open-source tool stack (skret, MCP plugins, hull,... Tooling
wet Open-source MCP server for AI agents: web search, content extraction, and lib... MCP
workspace Google Workspace MCP server (Docs/Drive/Calendar/Gmail/Sheets/Slides/Tasks/Ch... MCP

What it is

fastretrieval is a Python runtime for multi-model retrieval with text embeddings and reranking on ONNX Runtime or GGUF (llama-cpp-python) with no PyTorch dependency. It uses a declarative model contract so built-in Qwen3 reference models and custom models can share the same runtime, and supports Matryoshka (MRL) truncation, instruction-aware queries, and optional GPU acceleration. It is derived from fastembed and keeps Qwen3 model names as model identifiers rather than as the package boundary. Supported runtimes are CPython 3.11, 3.12, 3.13, 3.14, and 3.15. onnxruntime does not publish a Python 3.15 wheel yet, so on 3.15 it is not installed: the package imports, and loading an ONNX model raises an ImportError that says so.

What it does

Task Class Extra needed
Dense text embedding TextEmbedding none
Sparse embedding (SPLADE) SparseTextEmbedding none
Late interaction (ColBERT) LateInteractionTextEmbedding none
Image embedding ImageEmbedding image
Late interaction multimodal (ColPali) LateInteractionMultimodalEmbedding image
Cross-encoder rerank TextCrossEncoder none
Generative rerank (yes/no logit) TextCrossEncoder with a YesNo model none
Shared /embed + /rerank HTTP server fastretrieval.server server

Table of contents

Features

  • Model-specific pooling: Built-in Qwen3 text models use last-token pooling; other models use their declared preprocessing and pooling contract.
  • MRL support: Qwen3 reference embeddings support truncation from 32 to 1024 dimensions before L2 normalization.
  • Instruction-aware: Query embedding supports task instructions for better retrieval performance.
  • Causal LM reranking: Qwen3 rerankers use yes/no logit scoring, producing [0, 1] scores.
  • Multiple backends: ONNX Runtime and optional GGUF via llama-cpp-python; available formats depend on the selected model.
  • GPU optional, no PyTorch: Runs on ONNX Runtime or llama-cpp-python -- no heavy ML framework required. Auto-detects GPU (CUDA, DirectML) when available.
  • Multilingual: Built-in Qwen3 reference models support multi-language inputs.

Supported Models

The public facades have independent registries. TextEmbedding() selects n24q02m/Qwen3-Embedding-0.6B-ONNX (INT8, 1024 dimensions); every other facade requires an explicit model_name. A registry's first entry is not an implicit default. Qwen3 models are reference models, not a restriction on supported model families.

Facade Default selection Built-in capability
TextEmbedding Qwen3-Embedding-0.6B-ONNX Dense text, ONNX or GGUF
TextCrossEncoder None; explicit model required Qwen3 reranking, ONNX or GGUF
SparseTextEmbedding None; explicit model required SPLADE sparse text
LateInteractionTextEmbedding None; explicit model required ColBERT token vectors
ImageEmbedding None; explicit model required Image vectors (image extra)
LateInteractionMultimodalEmbedding None; explicit model required ColPali text/image token vectors (image extra)

Qwen3 ONNX reference models

Model Type Dims Max Tokens Size
n24q02m/Qwen3-Embedding-0.6B-ONNX Embedding 32-1024 (MRL) 32768 573 MB
n24q02m/Qwen3-Embedding-0.6B-ONNX-Q4F16 Embedding 32-1024 (MRL) 32768 517 MB
n24q02m/Qwen3-Reranker-0.6B-ONNX Reranker - 40960 573 MB
n24q02m/Qwen3-Reranker-0.6B-ONNX-Q4F16 Reranker - 40960 518 MB
n24q02m/Qwen3-Reranker-0.6B-ONNX-YesNo Reranker - 40960 598 MB

Qwen3 GGUF reference models (requires the gguf extra)

Model Type Dims Max Tokens Size
n24q02m/Qwen3-Embedding-0.6B-GGUF Embedding 32-1024 (MRL) 32768 378 MB
n24q02m/Qwen3-Reranker-0.6B-GGUF Reranker - 40960 378 MB

Other built-in ONNX models

Facade Model Output size
SparseTextEmbedding prithivida/Splade_PP_en_v1 Sparse vocabulary: 30522
LateInteractionTextEmbedding colbert-ir/colbertv2.0 128 per token
LateInteractionTextEmbedding answerdotai/answerai-colbert-small-v1 96 per token
ImageEmbedding Qdrant/clip-ViT-B-32-vision 512
ImageEmbedding Qdrant/resnet50-onnx 2048
ImageEmbedding Qdrant/Unicom-ViT-B-16 768
ImageEmbedding Qdrant/Unicom-ViT-B-32 512
ImageEmbedding jinaai/jina-clip-v1 768
LateInteractionMultimodalEmbedding Qdrant/colpali-v1.3-fp16 128 per token

The sparse registry also reports the deprecated misspelling prithvida/Splade_PP_en_v1; use the canonical prithivida spelling above. Call each facade's list_supported_models() for its installed registry metadata without loading model weights. Register additional dense and reranker models with CustomModelSpec / CustomRerankerSpec and the declarative fastretrieval.contract API; custom registration does not change the facade defaults.

HuggingFace Repos

Format Embedding Reranker
ONNX n24q02m/Qwen3-Embedding-0.6B-ONNX n24q02m/Qwen3-Reranker-0.6B-ONNX
GGUF n24q02m/Qwen3-Embedding-0.6B-GGUF n24q02m/Qwen3-Reranker-0.6B-GGUF

The five sentence-transformers builds from fastretrieval.convert are hosted as n24q02m/fr-* (384 dims, mean pooling, L2 normalized, INT8 + Q4F16) and resolve through short server aliases:

Alias HuggingFace repo
minilm-l6-v2 n24q02m/fr-all-MiniLM-L6-v2
minilm-l12-v2 n24q02m/fr-all-MiniLM-L12-v2
multi-qa-minilm-l6-cos-v1 n24q02m/fr-multi-qa-MiniLM-L6-cos-v1
paraphrase-minilm-l3-v2 n24q02m/fr-paraphrase-MiniLM-L3-v2
paraphrase-multilingual-minilm-l12-v2 n24q02m/fr-paraphrase-multilingual-MiniLM-L12-v2

Installation

pip install fastretrieval            # text only
pip install "fastretrieval[image]"   # adds image and ColPali
pip install "fastretrieval[all]"     # adds GGUF backend too
pip install "fastretrieval[server]"  # adds the /embed + /rerank HTTP server

# For GGUF support
pip install fastretrieval[gguf]

Usage

Text Embedding

from fastretrieval import TextEmbedding

# INT8 (default)
model = TextEmbedding(model_name="n24q02m/Qwen3-Embedding-0.6B-ONNX")

# Q4F16 (smaller, slightly less accurate)
model = TextEmbedding(model_name="n24q02m/Qwen3-Embedding-0.6B-ONNX-Q4F16")

# GGUF (requires: pip install fastretrieval[gguf])
model = TextEmbedding(model_name="n24q02m/Qwen3-Embedding-0.6B-GGUF")

documents = [
    "Qwen3 is a multilingual embedding model.",
    "ONNX Runtime enables fast CPU inference.",
]

embeddings = list(model.embed(documents))
# Each embedding: numpy array of shape (1024,), L2-normalized

# Matryoshka Representation Learning (MRL) -- truncate to smaller dims
embeddings_256 = list(model.embed(documents, dim=256))
# Each embedding: numpy array of shape (256,), L2-normalized

# Query with instruction (for retrieval tasks)
queries = list(
    model.query_embed(
        ["What is Qwen3?"],
        task="Given a question, retrieve relevant passages",
    )
)

Reranking

from fastretrieval import TextCrossEncoder

reranker = TextCrossEncoder(model_name="n24q02m/Qwen3-Reranker-0.6B-ONNX")

# YesNo variant: ~10x less RAM (~598MB vs ~12GB at inference)
# reranker = TextCrossEncoder(model_name="n24q02m/Qwen3-Reranker-0.6B-ONNX-YesNo")

query = "What is Qwen3?"
documents = [
    "Qwen3 is a series of large language models by Alibaba.",
    "The weather today is sunny.",
    "Qwen3-Embedding supports multilingual text embedding.",
]

scores = list(reranker.rerank(query, documents))
# scores: list of float in [0, 1], higher = more relevant

# Or rerank pairs directly
pairs = [
    ("What is AI?", "Artificial intelligence is a branch of computer science."),
    ("What is ML?", "Machine learning is a subset of AI."),
]
pair_scores = list(reranker.rerank_pairs(pairs))

Reranker determinism

Reranker scores are batch-invariant: the score of a (query, document) pair does not depend on batch size or the other documents scored in the same call. ONNX reranker variants are scored one sequence at a time (no padding), which keeps RoPE positions correct regardless of batch composition.

Custom models (bring your own)

Qwen3 models are built-in reference models, but any ONNX-able embedding model can be registered and then loaded by id. Use CustomModelSpec with one of the four output shapes: CLS/MEAN (bert-bi), LAST_TOKEN (causal), or DISABLED (raw).

from fastretrieval import CustomModelSpec, TextEmbedding

# Multilingual (incl. Vietnamese) + code, CLS-pooled, 768-dim
CustomModelSpec(
    model_id="onnx-community/gte-multilingual-base",
    hf="onnx-community/gte-multilingual-base",
    model_file="onnx/model_quantized.onnx",
    dim=768,
    pooling="CLS",
    normalization=True,
).register()

model = TextEmbedding("onnx-community/gte-multilingual-base")
embeddings = list(model.embed(["xin chào", "def add(a, b): return a + b"]))

Other verified examples: bge-m3 (pooling="CLS", dim=1024), EmbeddingGemma-300m (pooling="MEAN", dim=768). MRL truncation (embed(..., dim=256)) works for custom models whose vectors are Matryoshka-trained. Custom models are scored per-row, so — like the built-in INT8 reranker — their scores are batch-invariant by construction.

A BYO reranker registers the same way with CustomRerankerSpec. Any standard ONNX cross-encoder (a single relevance logit per pair — bge-reranker, gte-reranker, ms-marco, jina-reranker) works; there is no dim/pooling to set:

from fastretrieval import CustomRerankerSpec, TextCrossEncoder

CustomRerankerSpec(
    model_id="onnx-community/gte-multilingual-reranker-base",
    hf="onnx-community/gte-multilingual-reranker-base",
    model_file="onnx/model_quantized.onnx",
).register()

encoder = TextCrossEncoder("onnx-community/gte-multilingual-reranker-base")
scores = list(encoder.rerank("xin chào", ["tài liệu A", "tài liệu B"]))

PyTorch-only models can be converted first (in a throwaway env, since the export deps don't co-resolve with the lean runtime pins):

# pip install "optimum-onnx[onnxruntime]" torch transformers onnx
from fastretrieval.export import export_to_onnx

export_to_onnx("intfloat/multilingual-e5-base", "./e5-onnx")

HTTP server

fastretrieval[server] ships a small ASGI service so several processes share one model instance instead of each loading its own ONNX/GGUF session.

pip install "fastretrieval[server]"
fastretrieval-server --host 127.0.0.1 --port 9800
# or: python -m fastretrieval.server --port 9800
Route Request Response
GET /health -- {status, version}
GET /models -- {embed: {alias: model}, rerank: {alias: model}}
POST /embed {input: [str], model?, dims?} {data: [[float]], model, dims}
POST /rerank {query, documents: [str], model?, top_n?} {results: [{index, relevance_score}], model}
  • dims accepts 32..1024 (default 1024): Qwen3 reference embeddings are MRL-truncated before L2 normalization.
  • model takes an alias (qwen3-0.6b, qwen3-0.6b-q4f16, qwen3-0.6b-gguf, qwen3-rerank-0.6b, qwen3-rerank-0.6b-q4f16, qwen3-rerank-0.6b-yesno, qwen3-rerank-0.6b-gguf) or any registered model name, which passes through unchanged.
  • A GGUF alias without fastretrieval[gguf] returns 503 with the install hint; an unregistered model or out-of-range dims returns 400.
  • Artifacts download from Hugging Face into the cache on first use: FASTRETRIEVAL_CACHE_PATH, or --cache-dir. Inference threads: FASTRETRIEVAL_THREADS, or --threads.

The container image runs this server on 0.0.0.0:9800, with the model cache on a /data volume and a HEALTHCHECK on /health:

docker build -t fastretrieval .
docker run --rm -p 9800:9800 -v fastretrieval-models:/data fastretrieval

Converting your own model

fastretrieval does not ship a closed model zoo. Point the converter at a model family in the support matrix and it produces an artifact with a declarative contract manifest. Unsupported architectures fail closed instead of producing a misleading artifact.

The conversion dependencies (torch, transformers, optimum-onnx, and the ONNX Runtime quantizer stack including onnx-ir) are deliberately not runtime dependencies. Run conversion in a throwaway environment:

uv run --with-requirements fastretrieval/convert/requirements.txt \
  python -m fastretrieval.convert onnx intfloat/multilingual-e5-base \
  --out ./e5 --pooling mean --normalize

uv run --with-requirements fastretrieval/convert/requirements.txt \
  python -m fastretrieval.convert verify ./e5 \
  --source intfloat/multilingual-e5-base

verify validates the manifest, loads every ONNX variant through ONNX Runtime, and compares the converted outputs with the original model on the same probes. An explicit --atol always wins; otherwise the tolerance default follows the manifest task: embedding (dense) outputs use the per-variant defaults below, while cross_encoder outputs are raw logits compared against a single logit-scale default.

Task Default tolerance
dense (full precision) 1e-2
dense (int8 / q4f16) 0.1 / 0.15
cross_encoder (all variants) 2.0

The card command writes a model card only after the manifest and artifact formats pass validation. GGUF conversion additionally requires a built llama.cpp checkout and --llama-cpp (or LLAMA_CPP_HOME).

Large models can run in the optional Modal backend. It mounts local sources and downloads the completed artifact back to the requested output directory; it does not publish to a model hub:

uv run --with-requirements fastretrieval/convert/requirements.txt \
  python -m fastretrieval.convert onnx Qwen/Qwen3-Embedding-0.6B \
  --out ./qwen3 --pooling last_token --normalize --backend modal

The first acceptance profiles are Qwen3 and BERT-family text models. Adding a model family requires its architecture, task, modality, pooling, normalization, and output-shape profile plus parity tests; the model name alone is never enough.

Configuration

Environment variables

Variable Purpose
FASTRETRIEVAL_CACHE_PATH Override the model cache directory.
FASTRETRIEVAL_MAX_INPUT_LENGTH Override the maximum accepted input length.
QWEN3_EMBED_CACHE_PATH Deprecated compatibility alias for FASTRETRIEVAL_CACHE_PATH.
QWEN3_EMBED_MAX_INPUT_LENGTH Deprecated compatibility alias for FASTRETRIEVAL_MAX_INPUT_LENGTH.

The FASTRETRIEVAL_* names take precedence when both names are set. The deprecated QWEN3_EMBED_* names remain readable and emit a DeprecationWarning so existing configurations do not silently stop working.

Programmatic cache location

Consumers that need to inspect or clear the model cache should use the public helper instead of importing an internal module:

from fastretrieval import define_cache_dir

cache_dir = define_cache_dir()

define_cache_dir() honors FASTRETRIEVAL_CACHE_PATH first and the deprecated QWEN3_EMBED_CACHE_PATH alias second. An explicit path argument overrides both.

GPU Acceleration

Both ONNX and GGUF backends auto-detect GPU when available (Device.AUTO is the default).

ONNX

Requires onnxruntime-gpu (CUDA) or onnxruntime-directml (Windows) instead of onnxruntime:

pip install onnxruntime-gpu  # NVIDIA CUDA
# or
pip install onnxruntime-directml  # Windows AMD/Intel/NVIDIA
from fastretrieval import TextEmbedding, Device

# Auto-detect GPU (default)
model = TextEmbedding(model_name="n24q02m/Qwen3-Embedding-0.6B-ONNX")

# Force CPU
model = TextEmbedding(model_name="n24q02m/Qwen3-Embedding-0.6B-ONNX", cuda=Device.CPU)

# Force CUDA
model = TextEmbedding(model_name="n24q02m/Qwen3-Embedding-0.6B-ONNX", cuda=Device.CUDA)

GGUF

GPU is handled by llama-cpp-python. The default pip install fastretrieval[gguf] is CPU-only. For CUDA GPU support, build with:

CMAKE_ARGS="-DGGML_CUDA=on" pip install fastretrieval[gguf]
from fastretrieval import TextEmbedding, Device

# Auto-detect GPU (default, offloads all layers)
model = TextEmbedding(model_name="n24q02m/Qwen3-Embedding-0.6B-GGUF")

# Force CPU only
model = TextEmbedding(model_name="n24q02m/Qwen3-Embedding-0.6B-GGUF", cuda=Device.CPU)

Development

uv sync --group dev                              # Install dev dependencies
uv run ruff check .                              # Lint
uv run ruff format --check .                     # Format check
uv run ty check                                  # Type check
uv run pytest                                    # All tests (integration tests download ~1.2 GB)
uv run pytest -m "not integration" --tb=short    # Unit tests only (CI default)

# Shortcuts (optional, via mise): mise run setup / lint / test / fix

Migrating from qwen3-embed

The library was previously published as qwen3-embed. New releases use the fastretrieval distribution and import package; Qwen3 model identifiers remain unchanged.

Package and import names

# Before
pip install qwen3-embed[gguf]

# After
pip install fastretrieval[gguf]
# Before
from qwen3_embed import TextEmbedding, TextCrossEncoder

# After
from fastretrieval import TextEmbedding, TextCrossEncoder

The public API is unchanged. The old environment variable names remain supported as deprecated compatibility aliases:

Old variable New variable
QWEN3_EMBED_CACHE_PATH FASTRETRIEVAL_CACHE_PATH
QWEN3_EMBED_MAX_INPUT_LENGTH FASTRETRIEVAL_MAX_INPUT_LENGTH

The old names still work and emit a DeprecationWarning; when both names are set, the FASTRETRIEVAL_* value wins.

qwen3-embed 1.14.1 is the final release under the old name and receives no further releases. It is a stub built from legacy/qwen3-embed: installing it installs fastretrieval, and qwen3_embed re-exports the 1.14.0 public API (TextEmbedding, TextCrossEncoder, CustomModelSpec, CustomRerankerSpec, Device) from fastretrieval with a DeprecationWarning. Imports of qwen3_embed submodules are not forwarded.

Releases and Deployment

Releases are cut only by a manual workflow_dispatch of .github/workflows/cd.yml with release_type=beta or release_type=stable; merging to main never releases. The workflow runs python-semantic-release (v10) and publishes the version to PyPI via Trusted Publishing (PUBLISH_PYPI=true). Before any release, the readme-sync job verifies that pyproject.toml points at the README shipped to the registry, so README edits pass through the same gate. The Docker, MCP-registry, and downstream-notify jobs in the CD template are gated off for this repo (PUBLISH_DOCKER, PUBLISH_MCP_REGISTRY, and NOTIFY_DOWNSTREAM are unset).

The public reference page is mcp.n24q02m.com/reference/fastretrieval/. fastretrieval is a library: it ships no MCP endpoint and has no hosted deployment.

  • wet-mcp -- MCP web search server with vector-based docs search, uses fastretrieval for local embedding
  • mnemo-mcp -- MCP memory server with semantic search powered by fastretrieval
  • better-code-review-graph -- Knowledge graph for code reviews, uses fastretrieval for local ONNX embedding
  • modalcom-ai-workers -- GPU-serverless workers that convert Qwen3 models to ONNX/GGUF format

Contributing

See CONTRIBUTING.md.

License

Apache-2.0 -- See LICENSE. Original fastembed by Qdrant.

Metadata

Release files for fastretrieval 1.14.0b3

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for fastretrieval 1.14.0b3
File Size Uploaded Provenance Actions
fastretrieval-1.14.0b3.tar.gz 391.7 kB With provenance Details for fastretrieval-1.14.0b3.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for fastretrieval 1.14.0b3
File Interpreter ABI Platform Actions
fastretrieval-1.14.0b3-py3-none-any.whl Python 3 none any Details for fastretrieval-1.14.0b3-py3-none-any.whl

Total release size: 551.2 kB

Release files / fastretrieval-1.14.0b3.tar.gz

Download URL fastretrieval-1.14.0b3.tar.gz
Size 391.7 kB
Tags Source
SHA-256 checksum
How to use checksums
a83e6b46f17f47e00ef57aac5e32e8768f7cc8853b43fd0ec11af6c07e3687bb
BLAKE2b-256 checksum
How to use checksums
44977176270482696f3e170dc2aec4fb555145e43bb9cf885627171b6dc871f6
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.

Transparency log

Release files / fastretrieval-1.14.0b3-py3-none-any.whl

Download URL fastretrieval-1.14.0b3-py3-none-any.whl
Size 159.5 kB
Tags Python 3
SHA-256 checksum
How to use checksums
59f2919e426d7f8b747ae987a1508eae7a0f2a9174a8027ecca64ec1a52e9d94
BLAKE2b-256 checksum
How to use checksums
d27dbee7e8c8cfb0989e80116e33700daf549f6fcbd8d4cf2fa22f1b5fd7e657
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.

Transparency log

Security for fastretrieval 1.14.0b3

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

Both files in this release have been uploaded with provenance metadata.

Select from 2 files

Attestation for fastretrieval-1.14.0b3.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release
Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page