NVIDIA Nemotron 3.5 Super VL is an open multimodal model for agents that see, reason, and act. Its 120B-parameter Mixture-of-Experts design (12B active) understands text, images, documents, GUIs, and video, and adds reasoning and tool use on top.

NVIDIA-Nemotron-3.5-Super-VL

Step 5 Preview is StepFun's flagship model for agentic work. It is a sparse Mixture-of-Experts model with 600B total parameters and 27B active per token, a 1M-token context window, and text and image input. It delivers frontier-level performance in software engineering, long-horizon agentic execution with repeated tool calls, and professional knowledge work, with particular strength in finance.

Step-5-Preview

Hy4 preview is a 770B-parameter Mixture-of-Experts flagship model from the Tencent Hy Team, with 49B parameters activated per token and a 1M-token context window. It uses Gated DeepSeek Sparse Attention with IndexCache, and is post-trained for software engineering, office and data analysis, game development, and scientific research.

Hy4-preview

MiMo-V2.6-Flash is the efficiency-balanced model in Xiaomi's MiMo-V2.6 series: a sparse Mixture-of-Experts model with 309B total and 15B activated parameters, natively omnimodal across text, image, video and audio, with a 1M-token context window. Trained with large-scale mixed reinforcement learning across coding, general agents, visual and cybersecurity tasks, it is built for agentic workloads such as long-horizon coding, tool use and computer use.

MiMo-V2.6-Flash

MiMo-V2.6-Pro is the flagship of Xiaomi's MiMo-V2.6 series: a sparse Mixture-of-Experts model with 1.02T total and 42B activated parameters, natively omnimodal across text, image, video and audio, with a 1M-token context window. Trained with large-scale mixed reinforcement learning and groupwise agentic grading, it is built for demanding agentic work including long-horizon coding, multi-tool agents and cybersecurity tasks.

MiMo-V2.6-Pro

Introduce DeepSeek-V4.1-Flash, a multimodal Mixture-of-Experts (MoE) model with 552B backbone parameters and support for contexts of up to one million tokens.

DeepSeek-V4.1-Flash

GLM-5.3 is a large-scale reasoning model from Z.ai, built for complex software engineering and long-horizon agent tasks. It supports text input and output with a 1M-token context window, and improves on GLM-5.2 in coding and in the balance between performance and token efficiency.

GLM-5.3

GLM-5.3-Flash is a native multimodal model from Z.ai. It is suited for efficient coding and long-horizon agent tasks. Its hybrid sparse and linear attention architecture maintains accurate long-context behavior while reducing compute overhead.

GLM-5.3-Flash

Kimi K3 is Moonshot AI's 2.8T-parameter open-weight multimodal reasoning model. Built for complex coding, knowledge work, and long-horizon agentic workflows, it excels at navigating large repositories, calling tools, debugging, and iterating on images, logs, tests, and runtime feedback. Its architecture relies on KDA and Attention Residuals for computational efficiency.

Kimi-K3

DeepSeek-V4-Pro-0813 is the official release of DeepSeek-V4-Pro, superseding the preview version, with greatly enhanced agentic capabilities and performance improvements that are especially pronounced in production environments. It is built on the DeepSeek-V4-Pro (Preview) model structure, with a DSpark speculative decoding module attached.

DeepSeek-V4-Pro-0813

DeepSeek-V4-Flash-0731 is the official release of DeepSeek-V4-Flash, superseding the preview version, with substantially enhanced agentic capabilities. DeepSeek-V4-Flash-0731 outperforms DeepSeek-V4-Pro (Preview) on benchmarks listed below despite its far smaller activated parameter count, and is broadly competitive with the strongest proprietary models available.

DeepSeek-V4-Flash-0731

GLM-5.2 is Z-AI's latest flagship model for long-horizon tasks. It marks a substantial leap in long-horizon task capability over its predecessor GLM-5.1 and, for the first time, delivers that capability on a **solid 1M-token context**.

GLM-5.2

Nemotron 3 Ultra is built for, frontier reasoning, orchestration, coding agents, deep research, and complex enterprise workflows. It delivers up to 5x faster inference and up to 30% lower cost for agentic workloads while supporting up to 1M token context.

NVIDIA-Nemotron-3-Ultra-550B-A55B

DeepSeek V4 Flash is an efficiency-focused MoE model with 284B total parameters (13B active) and a 1M-token context window. It's tuned for fast inference and high-throughput use cases while still holding up on reasoning and coding tasks.

DeepSeek-V4-Flash

DeepSeek V4 Pro is an MoE model with 1.6T total parameters (49B active) and a 1M-token context window. It's built for advanced reasoning, coding, and long-running agent tasks, and performs well on knowledge, math, and software engineering benchmarks.

DeepSeek-V4-Pro

Kimi K2.6 is an open-source, native multimodal agentic model that advances practical capabilities in long-horizon coding, coding-driven design, proactive autonomous execution, and swarm-based task orchestration.

Kimi-K2.6

Qwen3.6-35B-A3B is Alibaba's latest flagship Mixture-of-Experts model, with 35B total parameters and only 3B activated per token (256 experts, 8 routed + 1 shared). Built on direct feedback from the community, Qwen3.6 prioritizes stability and real-world utility, offering developers a more intuitive, responsive, and genuinely productive coding experience.

Qwen3.6-35B-A3B

Qwen3.5-397B-A17B is Alibaba's most capable Qwen3.5 model, a Mixture-of-Experts architecture with 397B total parameters and 17B activated per token. It features a 262K token context window (extensible to 1M with YaRN), thinking/reasoning mode, tool calling with MCP integration, and support for 201 languages. Sets state-of-the-art results on reasoning, coding, math, and multimodal benchmarks.

Qwen3.5-397B-A17B

Efficient, MoE variant of Gemma 4. Gemma is a family of open models built by Google DeepMind. Gemma 4 models are multimodal, handling text and image input and generating text output.

gemma-4-26B-A4B-it

Gemma is a family of open models built by Google DeepMind. Gemma 4 models are multimodal, handling text and image input and generating text output.

gemma-4-31B-it

NVIDIA Nemotron 3 Super is a hybrid Mixture-of-Experts (MoE) model engineered for highest compute efficiency and accuracy in multi-agent applications and specialized agentic systems. It is optimized to run many collaborating agents per application on a single GPU, delivering high accuracy for reasoning, tool use, and instruction following.

NVIDIA-Nemotron-3-Super-120B-A12B

  Qwen3-TTS is an advanced text-to-speech model by Alibaba's Qwen team, delivering stable, expressive, and low-latency speech generation across 10 languages.                                                                                                                                                                                                                                                                                                                                           Key capabilities:                                                                                                                                                                                                                                  - 9 preset voices — Vivian, Serena, Uncle_Fu, Dylan, Eric, Ryan, Aiden, Ono_Anna, Sohee — covering diverse genders, ages, and accents                                                                                                              - Voice cloning — clone any voice from a short (~3s) audio sample via the voice_id parameter   - Instruction control — adjust tone, emotion, and speaking style with natural language (e.g. "speak slowly and calmly", "excited tone")   - 10 languages — English, Chinese, Japanese, Korean, German, French, Russian, Spanish, Italian, Portuguese   - Streaming support — real-time PCM streaming with ~97ms first-byte latency   - Multiple output formats — WAV, MP3, FLAC, PCM    Built on a 1.7B parameter architecture using discrete multi-codebook language modeling for end-to-end speech synthesis without cascading errors. Uses a custom 12Hz acoustic tokenizer that preserves paralinguistic information and   environmental audio details.

Qwen3-TTS

● Qwen3-TTS-VoiceDesign is a voice design variant of Qwen3-TTS by Alibaba's Qwen team. Instead of selecting from preset voices, you describe the voice you want in natural language — and the model generates speech in that voice.                                                                                                                                                                                                                                                                     Key capabilities:                                                                                                                                                                                                                                  - Natural language voice control — describe any voice with free text (e.g. "a deep male voice with a calm, authoritative presence", "a young cheerful female with a warm and friendly tone")   - 10 languages — English, Chinese, Japanese, Korean, German, French, Russian, Spanish, Italian, Portuguese                                                                                                                                         - Streaming support — real-time PCM streaming   - Multiple output formats — WAV, MP3, FLAC, PCM    Built on the same 1.7B parameter architecture as Qwen3-TTS, using discrete multi-codebook language modeling and a custom 12Hz acoustic tokenizer for high-quality end-to-end speech synthesis.

Qwen3-TTS-VoiceDesign

DeepSeek-V3.2 is a large language model designed to harmonize high computational efficiency with strong reasoning and agentic tool-use performance. It introduces DeepSeek Sparse Attention (DSA), a fine-grained sparse attention mechanism that reduces training and inference cost while preserving quality in long-context scenarios. A scalable reinforcement learning post-training framework further improves reasoning, with reported performance in the GPT-5 class, and the model has demonstrated gold-medal results on the 2025 IMO and IOI. V3.2 also uses a large-scale agentic task synthesis pipeline to better integrate reasoning into tool-use settings, boosting compliance and generalization in interactive environments.

DeepSeek-V3.2

The fastest model of the Flux 2 family. Frontier visual intelligence — state-of-the-art image generation and editing from Black Forest Labs

FLUX-2-klein-4b

The best quality-to-latency ratio, production apps model of the Flux 2 family. Frontier visual intelligence — state-of-the-art image generation and editing from Black Forest Labs

FLUX-2-klein-9b

claude

Claude

deepseek

DeepSeek

flux

Flux

gemini

Gemini

kimi

Kimi

llama

Llama

mistral

Mistral

nemotron

Nemotron

qwen

Qwen

Nemotron-3.5-Embed-1B-BF16 is a compact multimodal embedding model from NVIDIA that maps text, images, and page screenshots into a shared 2048-dimensional vector space for visual document retrieval and semantic search. It pairs the Nemotron-3-Embed-1B text encoder with a vision encoder, supports up to 32k tokens and Matryoshka dimensions, and suits multilingual RAG over PDFs, slides, and scanned documents.

DeepInfra supports the OpenAI embeddings API. This model embeds text, images, audio and video into one vector space: each item of `input` is a string, or a list of content parts that are embedded together in order.

```bash
curl "https://api.deepinfra.com/v1/openai/embeddings" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPINFRA_API_KEY" \
  -d '{
    "model": "nvidia/Nemotron-3.5-Embed-1B-BF16",
    "input": [
      "Waterproof trail running shoes",
      [
        {"type": "text", "text": "Product photo:"},
        {"type": "image_url", "image_url": {"url": "https://example.com/shoe.jpg"}}
      ],
      [
        {"type": "audio_url", "audio_url": {"url": "https://example.com/clip.mp3"}}
      ]
    ],
    "task": "document",
    "dimensions": 768,
    "encoding_format": "float"
  }'
```

Content parts: `text`, `image_url`, `input_audio` (`{"data": "<base64>", "format": "wav"}`), `audio_url` and `video_url`. URLs can be `https://` or `data:<mime>;base64,...`.

`task` selects the model's instruction for items that contain text: `search_query`, `document`, `question_answering`, `fact_checking`, `code_retrieval`, `classification`, `clustering` or `sentence_similarity`. Embed queries with `search_query` and the corpus with `document`. `dimensions` can be 768, 512, 256 or 128; vectors are always L2-normalized.

which will return one embedding per input item

```json
{
  "object": "list",
  "data": [
    {"object": "embedding", "index": 0, "embedding": [-0.0105, -0.0026, ..., 0.0202]},
    {"object": "embedding", "index": 1, "embedding": [0.0123, -0.0311, ..., -0.0087]},
    {"object": "embedding", "index": 2, "embedding": [-0.0402, 0.0071, ..., 0.0158]}
  ],
  "model": "nvidia/Nemotron-3.5-Embed-1B-BF16",
  "usage": {"prompt_tokens": 362, "total_tokens": 362}
}
```

Each image costs about 270 tokens, audio 25 tokens per second (clips up to 30 s), and video about 140 tokens per frame sampled at 1 frame per second (up to 32 frames). An item can hold up to 8,192 tokens.


You can use the official OpenAI python client. Pass content parts to embed images, audio and video, and `task` through `extra_body`.

```python
import base64
import os

from openai import OpenAI

openai = OpenAI(
    api_key=os.environ["DEEPINFRA_API_KEY"],
    base_url="https://api.deepinfra.com/v1/openai",
)

query = openai.embeddings.create(
    model="nvidia/Nemotron-3.5-Embed-1B-BF16",
    input=["waterproof shoes for trail running"],
    dimensions=256,
    extra_body={"task": "search_query"},
)

with open("clip.wav", "rb") as f:
    clip = base64.b64encode(f.read()).decode()

documents = openai.embeddings.create(
    model="nvidia/Nemotron-3.5-Embed-1B-BF16",
    input=[
        [
            {"type": "text", "text": "Product photo:"},
            {"type": "image_url", "image_url": {"url": "https://example.com/shoe.jpg"}},
        ],
        [{"type": "input_audio", "input_audio": {"data": clip, "format": "wav"}}],
    ],
    dimensions=256,
    extra_body={"task": "document"},
)

# Vectors are L2-normalized, so the dot product is the cosine similarity.
q = query.data[0].embedding
for doc in documents.data:
    print(doc.index, sum(a * b for a, b in zip(q, doc.embedding)))
print(documents.usage.prompt_tokens)
```

Compare vectors of the same dimension: embed queries with the same `dimensions` as the documents.


You can use the official OpenAI Node.js client. Pass content parts to embed images, audio and video; `task` and `dimensions` go in the request body.

```javascript
import OpenAI from "openai";

const openai = new OpenAI({
  baseURL: "https://api.deepinfra.com/v1/openai",
  apiKey: process.env.DEEPINFRA_API_KEY,
});

async function main() {
  const embeddings = await openai.embeddings.create({
    model: "nvidia/Nemotron-3.5-Embed-1B-BF16",
    input: [
      "Waterproof trail running shoes",
      [
        { type: "text", text: "Product photo:" },
        { type: "image_url", image_url: { url: "https://example.com/shoe.jpg" } },
      ],
      [{ type: "video_url", video_url: { url: "https://example.com/demo.mp4" } }],
    ],
    task: "document",
    dimensions: 512,
    encoding_format: "float",
  });

  for (const item of embeddings.data) {
    console.log(item.index, item.embedding.length);
  }
  console.log(embeddings.usage.prompt_tokens);
}

main();
```


You can use cURL or any other http client to run inferences:

```bash
curl -X POST \
    -d '{"inputs": ["I like chocolate"]}'  \
    -H "Authorization: bearer $DEEPINFRA_API_KEY"  \
    -H 'Content-Type: application/json'  \
    'https://api.deepinfra.com/v1/inference/nvidia/Nemotron-3.5-Embed-1B-BF16'
```

which will give you back something similar to:

```json
{
  "embeddings": [
    [
      0.0,
      0.5,
      1.0
    ],
    [
      1.0,
      0.5,
      0.0
    ]
  ],
  "input_tokens": 42,
  "embedding_jsons": [
    "[0.0, 0.5, 1.0]",
    "[1.0, 0.5, 0.0]"
  ],
  "request_id": null,
  "inference_status": {
    "status": "unknown",
    "runtime_ms": 0,
    "cost": 0.0,
    "tokens_generated": 0,
    "tokens_input": 0,
    "output_length": 0
  }
}

```


You can use our command-line tool [deepctl](/docs/advanced/deepctl) to run
inferences:

```bash
deepctl infer \
    -m 'nvidia/Nemotron-3.5-Embed-1B-BF16'  \
    -i 'inputs=["I like chocolate"]'
```

which will give you back something similar to:

```json
{
  "embeddings": [
    [
      0.0,
      0.5,
      1.0
    ],
    [
      1.0,
      0.5,
      0.0
    ]
  ],
  "input_tokens": 42,
  "embedding_jsons": [
    "[0.0, 0.5, 1.0]",
    "[1.0, 0.5, 0.0]"
  ],
  "request_id": null,
  "inference_status": {
    "status": "unknown",
    "runtime_ms": 0,
    "cost": 0.0,
    "tokens_generated": 0,
    "tokens_input": 0,
    "output_length": 0
  }
}

```


We recommend using our NodeJS client https://github.com/deepinfra/deepinfra-node.

You can install it with

```bash
npm install deepinfra
```

and then

```javascript
import { Embeddings } from "deepinfra";

const DEEPINFRA_API_KEY = process.env.DEEPINFRA_API_KEY;
const MODEL = "nvidia/Nemotron-3.5-Embed-1B-BF16";

const main = async () => {
  const client = new Embeddings(MODEL, DEEPINFRA_API_KEY);
  const body = {
    inputs: [
      "What is the capital of France?",
      "What is the capital of Germany?",
      "What is the capital of Italy?",
    ],
  };
  const output = await client.generate(body);
  console.log(output.embeddings[0]);
};

main();
```


The service tier used for processing the request. 'priority' processes the request with higher priority (premium rate); 'flex' processes it at lower priority for a discount, served only when spare capacity exists and may be retried/timed out under load. Both apply only to models that support the respective tier. For compatibility, 'auto' is treated as 'priority' and 'standard_only' as 'default'.

service_tier

If true, the request is rejected immediately with HTTP 429 when the model has no spare capacity, instead of waiting in the queue. Opt-in; the default (false) keeps standard queueing behavior.

fail_fast

inputs

whether to normalize the computed embeddings

normalize

image

The number of dimensions in the embedding. If not provided, the model's default will be used.If provided bigger than model's default, the embedding will be padded with zeros.

dimensions

Custom instruction prepending to each input. If empty, no instruction will be used.

custom_instruction

multimodal_inputs

The webhook to call when inference is done, by default you will get the output in the response of your inference request

webhook

ServiceTier

Custom Instruction

Dimensions

Fail Fast

Image

Inputs

Multimodal Inputs

Normalize

Webhook

EmbeddingsIn

estimated cost billed for the request in USD

Cost

Output Length

Runtime Ms

Status

Tokens Generated

Tokens Input

InferenceReplyStatus

Embedding Jsons

the computed embeddings for each input sequence or a single embedding if an image was passed

Embeddings

Object containing the status of the inference request

The number of input tokens in the request

Input Tokens

Request Id

EmbeddingsOut

model

text or multimodal content to embed; one embedding per item. Each item is either a string, or a list of content parts (text / image_url / input_audio / audio_url / video_url) embedded together in part order, for multimodal embedding models such as google/embeddinggemma-2.

input

Role hint for asymmetric retrieval models: 'query' embeds a search query, 'passage'/'document' embeds a document. Controls the query:/passage: prefix on VL embedding models; ignored by symmetric models.

input_type

Task the embedding is optimized for, on models trained with task prompts (e.g. google/embeddinggemma-2). Applied to items containing text; mutually exclusive with input_type.