LLM Configuration

Reflexio uses LiteLLM for multi-provider LLM support. You must configure an API key for at least one provider.

Current OpenAI and Anthropic models

Reflexio requires LiteLLM >=1.103.1,<2. The following model IDs are qualified with deterministic provider-adapter tests for structured extraction and tool loops (September 30, 2026):

Bare IDs and direct provider prefixes such as openai/gpt-6.1-sol and anthropic/claude-sonnet-5-5 are supported. Select them through the existing LLMConfig model overrides; this compatibility update does not change the provider defaults or any saved organization model selection.

from reflexio.models.config_schema import LLMConfig

config = client.get_config()
if config.llm_config is None:
    config.llm_config = LLMConfig()
config.llm_config.generation_model_name = "openai/gpt-6.1-sol"
client.set_config(config)

For these GPT-6 and new Claude models, Reflexio omits temperature, top_p, and top_k rather than forwarding unsupported sampling settings. GPT-6 Luna retains temperature and top_p when reasoning_effort="none" is explicitly requested. Existing Haiku sampling behavior is preserved. LiteLLM routes reasoning OpenAI function tool requests through the Responses API; Luna with reasoning explicitly disabled can use Chat Completions. Custom OpenAI-compatible endpoints keep LiteLLM's existing endpoint routing.

The new Claude models require automatic or disabled tool selection (auto or none); explicitly forcing a tool produces a clear error. Reflexio preserves signed thinking blocks and encrypted reasoning items between tool turns, including when completions run in isolated subprocesses.

Reflexio supplies missing capability metadata for the listed GPT-6 and new Claude IDs when LiteLLM's bundled catalog is older than the model. It preserves existing catalog entries and does not invent prices for missing entries. Tests use local HTTP fixtures and do not establish live account access or provider availability. See the OpenAI model catalog and Claude model catalog for provider availability and migration requirements.

Current MiniMax and GLM models

The following additional direct-provider IDs are qualified with local HTTP fixtures and actual subprocess tool exchanges (October 1, 2026):

Existing MiniMax M3 and GLM 5.2 defaults remain unchanged. These new models require thinking to stay enabled. MiniMax Preview accepts reasoning effort low, medium, high, xhigh, or max; GLM 5.3 variants accept low, high, or max. Reflexio forwards explicitly requested effort through LiteLLM and rejects disabled thinking or invalid effort before sending a request. MiniMax Preview also requires reasoning_split=True when that option is supplied. Sampling settings keep their existing behavior.

Structured extraction uses Reflexio's existing prompt-schema and JSON parsing strategy for these providers. Tool exchanges preserve reasoning_content and accompanying assistant text. Missing catalog entries receive capability metadata without fabricated pricing or a claim of native strict JSON schemas.

Reflexio routes GLM 5.3 and Flash through the coding-plan endpoint by default. GLM FlashX uses https://api.z.ai/api/paas/v4 because it is not available on that plan; supply a general API key when selecting FlashX. Explicit per-call api_base overrides remain available. MiniMax Preview requires access through M Plan or MiniMax Code. A model being supported by Reflexio does not grant account access. See the MiniMax API documentation, GLM 5.3 guide, and GLM Flash/FlashX guide.

API Keys

Method 1: Environment Variables (Recommended)

Set provider-specific environment variables in your .env file. LiteLLM picks them up automatically.

# .env — set one or more provider keys
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GEMINI_API_KEY=...
DEEPSEEK_API_KEY=...

OpenAI is a common starting point for text generation. Embeddings default to Reflexio's local model unless you override embedding_model_name.

Method 2: Programmatic Configuration

Set API keys via the Config object. Programmatic keys take precedence over environment variables.

from reflexio.models.config_schema import APIKeyConfig, OpenAIConfig

config = client.get_config()
config.api_key_config = APIKeyConfig(
    openai=OpenAIConfig(api_key="sk-your-key-here")
)
client.set_config(config)

curl -X GET "${REFLEXIO_URL:-https://www.reflexio.ai}/api/get_config" \
  -H "User-Agent: my-agent-reflexio" \
  -H "Authorization: Bearer $REFLEXIO_API_KEY"

curl -X POST "${REFLEXIO_URL:-https://www.reflexio.ai}/api/set_config" \
  -H "User-Agent: my-agent-reflexio" \
  -H "Authorization: Bearer $REFLEXIO_API_KEY" \
  -H "Content-Type: application/json" \
  --data @- <<'JSON'
{
  "...": "updated full config object"
}
JSON

Supported Providers:

For Z.ai models such as zai/glm-5.2, Reflexio uses https://api.z.ai/api/coding/paas/v4 as the built-in API base. Configure only the ZAI_API_KEY; the coding endpoint is a runtime default, not a setting. An explicit per-call API base or a configured custom endpoint still takes precedence.

Custom OpenAI-Compatible Endpoints

Use CustomEndpointConfig to connect to any OpenAI-compatible API. Custom endpoints take priority over other providers for text generation (but not embeddings).

from reflexio.models.config_schema import APIKeyConfig, CustomEndpointConfig

config.api_key_config = APIKeyConfig(
    custom_endpoint=CustomEndpointConfig(
        model="my-model",
        api_key="your-key",
        api_base="http://localhost:8000/v1"
    )
)
client.set_config(config)

curl -X POST "${REFLEXIO_URL:-https://www.reflexio.ai}/api/set_config" \
  -H "User-Agent: my-agent-reflexio" \
  -H "Authorization: Bearer $REFLEXIO_API_KEY" \
  -H "Content-Type: application/json" \
  --data @- <<'JSON'
{
  "...": "updated full config object"
}
JSON

Azure OpenAI

Use AzureOpenAIConfig nested inside OpenAIConfig to connect to Azure OpenAI:

from reflexio.models.config_schema import (
    APIKeyConfig, OpenAIConfig, AzureOpenAIConfig
)

config.api_key_config = APIKeyConfig(
    openai=OpenAIConfig(
        azure_config=AzureOpenAIConfig(
            api_key="your-azure-key",
            endpoint="https://your-resource.openai.azure.com/",
            api_version="2024-02-15-preview",
            deployment_name="gpt-4o"
        )
    )
)
client.set_config(config)

curl -X POST "${REFLEXIO_URL:-https://www.reflexio.ai}/api/set_config" \
  -H "User-Agent: my-agent-reflexio" \
  -H "Authorization: Bearer $REFLEXIO_API_KEY" \
  -H "Content-Type: application/json" \
  --data @- <<'JSON'
{
  "...": "updated full config object"
}
JSON

Model Selection

Reflexio uses different models for different tasks. Sensible defaults are provided, but you can override them via LLMConfig. Only set fields you want to override — None fields keep the defaults.

Embedding input formatting plus the default retrieval and playbook-clustering thresholds are selected by the exact embedding model:

An explicit request threshold always wins, including 0.0. In hybrid search, the threshold filters only the vector arm; full-text matches remain eligible. An explicit playbook clustering_similarity also wins. Playbook embeddings use only their normalized trigger; they do not fall back to playbook content. This normalization applies when an embedding is computed and does not automatically backfill existing playbook vectors.

from reflexio.models.config_schema import LLMConfig

config = client.get_config()
config.llm_config = LLMConfig(
    generation_model_name="openai/gpt-4o",
    embedding_model_name="text-embedding-3-small",
)
client.set_config(config)

curl -X GET "${REFLEXIO_URL:-https://www.reflexio.ai}/api/get_config" \
  -H "User-Agent: my-agent-reflexio" \
  -H "Authorization: Bearer $REFLEXIO_API_KEY"

curl -X POST "${REFLEXIO_URL:-https://www.reflexio.ai}/api/set_config" \
  -H "User-Agent: my-agent-reflexio" \
  -H "Authorization: Bearer $REFLEXIO_API_KEY" \
  -H "Content-Type: application/json" \
  --data @- <<'JSON'
{
  "...": "updated full config object"
}
JSON

Model names use LiteLLM's "provider/model-name" format (e.g., "openai/gpt-4o", "anthropic/claude-3-5-sonnet", "deepseek/deepseek-chat").

Z.ai models use Reflexio's prompt-backed structured-output path, and the live-verified zai/glm-5.2 model supports extraction-agent tool loops. Fallback lists may freely mix providers and structured-output strategies — Reflexio walks the primary and fallback models itself, one at a time, and rebuilds the request (structured-output strategy, api_base, per-model timeout) for each one. That means a primary using native JSON Schema can fall back to a prompt-backed provider like Z.ai, and vice versa; no transport compatibility restriction applies to structured-output or text fallback lists.

Changing embedding models puts new query vectors and existing stored vectors in different vector spaces until regeneration finishes, so semantic search quality may be temporarily degraded during the job.

The input-formatting policy is also part of the embedding space. If an existing non-Nomic database was populated by a Reflexio version that added Nomic-style prefixes to every model, rebuild the local SQLite database or run enterprise embedding regeneration after upgrading.