# DeepSeek-Reasonix Pre-trained Models: Available Identifiers and Configuration Guide

> Explore DeepSeek-Reasonix pre-trained models like deepseek-v4-flash and deepseek-v4-pro. Easily configure and switch between models using TOML, CLI, or API for optimized inference and advanced reasoning.

- Repository: [YHH/DeepSeek-Reasonix](https://github.com/esengine/DeepSeek-Reasonix)
- Tags: api-reference
- Published: 2026-06-26

---

**DeepSeek-Reasonix ships with built-in support for two primary pre-trained model identifiers—`deepseek-v4-flash` for speed-optimized inference and `deepseek-v4-pro` for advanced reasoning—allowing users to configure and switch between these public DeepSeek models via TOML settings, CLI flags, or runtime API calls.**

DeepSeek-Reasonix is an open-source inference framework that integrates with the DeepSeek API to leverage their pre-trained models. While the repository does not host model weights directly, it provides standardized identifiers and configuration infrastructure for the publicly available DeepSeek model family, enabling seamless switching between specialized variants without modifying core provider code.

## Available Pre-trained Model Identifiers

The framework recognizes four distinct ways to reference DeepSeek's pre-trained models:

- **`deepseek-v4-flash`** – The default speed-optimized model entry (provider key `deepseek-flash`), configured for lower latency and cost efficiency.

- **`deepseek-v4-pro`** – The higher-capacity reasoning model (provider key `deepseek-pro`), offering enhanced depth for complex tasks.

- **`deepseek`** – A provider alias that defaults to `deepseek-v4-flash` when no specific variant is specified.

- **Model arrays** – Configuration lists such as `["deepseek-v4-flash", "deepseek-v4-pro"]` that enable runtime switching without recreating connections.

These identifiers are hardcoded in the provider implementation at [`internal/provider/openai/openai.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/provider/openai/openai.go) (lines 71–76), where the OpenAI-compatible client detects DeepSeek-flavored model strings and applies the appropriate request protocol.

## Configuring Pre-trained Models

### TOML Configuration

The primary configuration method uses the [`reasonix.example.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.example.toml) file located in the repository root. This file declares the available models and establishes defaults:

```toml

# reasonix.example.toml (lines 56-57)

default_model = "deepseek"          # Provider alias mapping to deepseek-v4-flash

models      = ["deepseek-v4-flash", "deepseek-v4-pro"]
default     = "deepseek-v4-flash"   # Optional; falls back to first array entry

```

The `default_model` entry points to the provider name, while the `models` array explicitly lists the pre-trained DeepSeek variants that Reasonix can toggle between during execution.

### Environment Setup

Users must supply their own DeepSeek API credentials via environment variables or `.env` files, as the framework requires external API access to utilize these pre-trained models. The repository includes an `.env.example` file demonstrating the required authentication format.

## Runtime Model Selection

### CLI Overrides

Bypass TOML defaults by specifying the model directly via command-line flags:

```bash

# Execute with the pro variant for enhanced reasoning

reasonix run --model deepseek-v4-pro --input "Explain quantum entanglement."

```

The `--model` flag instructs the client to route requests to the `deepseek-v4-pro` endpoint regardless of the configuration file's default setting.

### Web UI and API Switching

The documentation site renders model selection controls in the UI. According to `site/src/pages/docs.astro` (lines 231–245), the interface exposes the active model name and provides mechanisms to switch contexts:

```javascript
// Runtime model switching via Reasonix API
await fetch('/api/set-model', {
  method: 'POST',
  body: JSON.stringify({ model: 'deepseek-v4-pro' })
});

```

This client-side request forwards to the controller, which updates the active model for subsequent inference calls without requiring application restarts.

## Implementation Details

### Provider Detection

In [`internal/provider/openai/openai.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/provider/openai/openai.go), the framework inspects model strings to determine routing logic. The implementation specifically checks for DeepSeek identifiers to adjust API request formatting, ensuring compatibility with DeepSeek's OpenAI-compatible endpoints while maintaining distinct handling for official OpenAI models.

### Skill-Level Model Resolution

Individual skills can query the resolved profile to determine which pre-trained model executes their logic. In [`internal/skill/tools.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/skill/tools.go), skills access the configuration through:

```go
// Retrieve active model for sub-agent execution
profile := skill.ProfileResolver(ctx, sk)
// profile.Model contains "deepseek-v4-flash" or "deepseek-v4-pro"

```

This allows multi-agent systems to adapt their behavior based on the computational characteristics of the active pre-trained model—whether optimizing for speed with the flash variant or leveraging the pro model's extended context window.

## Summary

- **DeepSeek-Reasonix provides pre-configured identifiers** for `deepseek-v4-flash` and `deepseek-v4-pro`, not hosted weights.
- **Configuration occurs in [`reasonix.example.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.example.toml)** via the `models` array and `default_model` provider mapping.
- **Runtime flexibility** allows model switching through CLI flags (`--model`), REST API calls (`/api/set-model`), or UI controls documented in `site/src/pages/docs.astro`.
- **Provider logic** in [`internal/provider/openai/openai.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/provider/openai/openai.go) automatically detects DeepSeek model strings and applies appropriate request protocols.
- **API key requirement**: Users must provide their own DeepSeek API credentials to access these pre-trained models.

## Frequently Asked Questions

### Does DeepSeek-Reasonix download model weights locally?

No. DeepSeek-Reasonix does not distribute or download pre-trained model weights. The repository contains only integration code and configuration identifiers that route requests to DeepSeek's official API endpoints. Users must possess valid DeepSeek API credentials to access the models.

### How do I switch between flash and pro models without restarting the application?

Send a POST request to the `/api/set-model` endpoint with the desired model identifier in the JSON body, or use the model selector in the web interface documented in `site/src/pages/docs.astro`. The framework updates the active provider context immediately without requiring process restarts.

### What is the difference between the `deepseek` alias and explicit model names?

The `deepseek` provider alias defaults to `deepseek-v4-flash` as implemented in the configuration resolution logic. Explicitly specifying `deepseek-v4-flash` or `deepseek-v4-pro` ensures predictable routing regardless of future changes to the default alias mapping.

### Can I use both pre-trained models in the same project?

Yes. Define both models in the `models` array within [`reasonix.example.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.example.toml), then select the appropriate variant per-task using the `--model` CLI flag or runtime API calls. Skills can also introspect the active model via `ProfileResolver` in [`internal/skill/tools.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/skill/tools.go) to adjust prompting strategies based on the selected variant's capabilities.