AI

One AI node, two BYOK providers. Pick a credential from either provider, choose a model, and reference the result downstream as {aiResponse.data}. The node, configuration UI, and output shape are identical across providers; only the credential and the model catalog change.

Providers

Pick whichever fits your workflow. You can add credentials for both and switch per-node.

Quick start

1. Add an OpenRouter or Venice AI key under Credentials.
2. Drop an AI node onto the canvas. In the config dialog, pick your credential.
3. Choose a model from the live dropdown (or type any model ID).
4. Write a prompt, e.g. Summarize this token: {json birdeyeResponse.data}.
5. Wire the next node to read {aiResponse.data}.

That's the whole loop. Everything below is detail for when you need it.

Prerequisites

• An API key from either provider:
  • OpenRouter: openrouter.ai/keys
  • Venice AI: venice.ai/settings/api. Add any USD balance to your Venice account first; Venice keys stay inactive on a $0 balance and will fail at runtime. See the Venice AI setup walkthrough for the exact steps.
• Add it as a credential in Credentials.

Operations

Input modes

Configuration

Select a credential first to load the live model list. The list is fetched directly from the active provider, so it always reflects what your key can use.

Switching credentials across providers clears the saved model. OpenRouter IDs (e.g. openai/gpt-5-mini) and Venice IDs (e.g. llama-3.2-3b) aren't interchangeable, so the node prompts you to pick again rather than ship a mismatched pair to the wire.

The user prompt is hard-capped at 200,000 characters. Anything longer is truncated with a marker ([Prompt truncated by Solaris to stay within model context limits]) before the call goes out.

Model IDs by provider

You can type a custom ID in either case. The runtime forwards it unchanged to the active provider, so typos fail at the wire with the provider's own error message (e.g. "model not found").

Advanced parameters

These are OpenAI-compatible parameters; both providers accept them.

Reasoning

Some models support extended reasoning. When enabled, the model may return additional reasoning metadata alongside the reply.

Reasoning is model-dependent on both providers. Claude 4.6 (via OpenRouter) uses adaptive thinking automatically (the effort setting is ignored). Models that don't support reasoning will reject the call. Venice's reasoning-capable models surface their thinking as reasoning_content and are normalized into the same reasoning output field as OpenRouter.

JSON Request mode

When inputMode is json, the body must be an object with an OpenAI-compatible messages[] array. This is the only shape the runtime forwards to either provider.

Static JSON is checked in the editor before the workflow runs. If the JSON contains template expressions, the final shape is checked after those templates render at runtime. Legacy provider formats such as Gemini contents[] or Anthropic top-level system are rejected when the rendered request is parsed.

{
  "messages": [
    { "role": "system", "content": "You are a concise assistant." },
    { "role": "user", "content": "Summarize: {json birdeyeResponse.data}" }
  ]
}

role must be one of system, user, assistant, developer. content is a non-empty string, or an OpenAI-format content-parts array ([{ "type": "text", "text": "..." }, { "type": "image_url", "image_url": { "url": "..." } }]) for multimodal models.

The body may also set:

All other fields in the body are ignored. Advanced parameters (topP, frequencyPenalty, etc.) and responseFormat come from node settings, not the JSON body. Set them in the editor's Advanced parameters panel or Response format toggle.

Template expressions inside requestJson are resolved before the body is parsed as JSON, so a path like {json codeResponse.data} interpolates a JSON value at that position. Undefined paths fail loudly with AI JSON input uses undefined variables: <path> instead of producing invalid JSON or empty substitutions.

Response format

The responseFormat setting controls how the model's reply lands in the output envelope. It must agree with what your prompt asks for. Instructing the model to respond in JSON without flipping this toggle leaves .data as a string that downstream nodes can't traverse with field paths.

Some models don't support structured outputs and will fail when json_object is set. Pick a model that does, or fall back to text and parse downstream.

Output

In text mode (default):

{
  "success": true,
  "data": "The current price of SOL is approximately $150.",
  "model": "openai/gpt-5-mini",
  "usage": { "promptTokens": 42, "completionTokens": 18 }
}

In json_object mode:

{
  "success": true,
  "data": { "price": 150, "asset": "SOL", "confidence": "high" },
  "model": "llama-3.3-70b",
  "usage": { "prompt_tokens": 42, "completion_tokens": 18 }
}

The model field reflects the provider's canonical ID (slashed for OpenRouter, bare for Venice). The usage shape mirrors whatever the provider returns; OpenRouter uses camelCase via its SDK, Venice uses snake_case directly. Both expose token counts you can read with {aiResponse.usage.prompt_tokens} or {aiResponse.usage.promptTokens} as appropriate.

Reasoning models may add a reasoning field when reasoning is enabled.

Reference patterns:

• {aiResponse.data} is the model's reply as a string. In text mode this is the raw model output. In json_object mode .data is an object, so without the json prefix the template substitutes [object Object] (string coercion). Use {json aiResponse.data} instead when .data is an object.
• {aiResponse.data.field} is a scalar field (string / number / boolean) from a json_object reply, dropped in unquoted. The right shape for prompts and most string fields in HTTP query strings.
• {json aiResponse.data.field} is the same field JSON-encoded (strings get quotes, objects/arrays get JSON syntax). Use this when interpolating into JSON HTTP bodies, or when the field itself is an object or array.
• {json aiResponse} is the full response envelope, useful for HTTP bodies or debugging.

Template variables

The system prompt, prompt, and JSON-input fields all support template expressions like {json codeResponse.data.field}. Two things to know:

• Use the variable picker (the { } button next to any text field). It walks upstream nodes and suggests valid paths, including nested field paths once the workflow has run once. Before the first run, it falls back to a static schema for known node types so you still get useful suggestions.
• Undefined paths fail loudly. If a path doesn't resolve (typo, wrong nesting, upstream node didn't emit that field), the node fails before calling the model. Checked across all three template fields (systemPrompt, prompt, requestJson) so a single failure surfaces every offending path at once. The error message mentions the offending path: Prompt template uses undefined variables: <path> in prompt mode (covers system prompt + prompt), AI JSON input uses undefined variables: <path> in JSON Request mode (covers system prompt + JSON body). This is the most common cause of "I don't see any data" replies; fix the path instead of debugging the model. A path that resolves to null (e.g. balanceResponse.mint on a SOL balance) is treated as a present value, not a missing one.

When to pick which provider

• Default to OpenRouter if you need access to a specific commercial model (GPT, Claude, Gemini) or want the broadest catalog.
• Pick Venice when you need private inference, want to run uncensored or open-source models, or already use Venice for the rest of your stack.

You can use both in the same workflow. Each AI node carries its own credential, so one node can call GPT-5 while the next routes to Llama through Venice.

Common use cases

• Analyze on-chain data and generate trading signals
• Summarize token metrics into human-readable alerts
• Parse unstructured data into structured JSON with json_object response format
• Use reasoning models for complex multi-step analysis
• Route sensitive prompts through Venice for private inference, public prompts through OpenRouter for breadth

Next steps

• Jupiter connects AI to on-chain swaps
• Configuring Nodes explains template expressions for dynamic prompts