Menu

Mattering Automations Fireworks AI integration

Connect Fireworks AI to Mattering Automations: chat and text completions on open-weight models, an Anthropic-format Messages endpoint, embeddings, document reranking, and dataset and fine-tuning management as workflow steps, authenticated with one Fireworks API key.

The Mattering Automations Fireworks AI integration puts Fireworks serverless inference on your automation canvas: run chat and text completions on open-weight models such as Kimi, Qwen, Llama, and DeepSeek inside a workflow step, call the Anthropic-format Messages endpoint, create embeddings, rerank documents by relevance, and read and manage the datasets and supervised fine-tuning jobs on your Fireworks account.

Setup is one API key from the Fireworks dashboard; the same key covers both Fireworks surfaces the connector uses, serverless inference and the account control plane. This guide covers creating the key, connecting it, a read-only verify path that also hands you the account ID the control-plane nodes need, and the full node reference, and it ends with the failure modes worth recognizing on sight.

Before you start

  • A Fireworks AI account at app.fireworks.ai with permission to create an API key.
  • A Mattering workspace with access to the Automations app.
  • For the fine-tuning nodes, a training dataset already uploaded to Fireworks out of band, with firectl or the Fireworks SDK. The canvas has no file upload, so the integration picks the lifecycle up from an uploaded dataset onward.
  • A budget awareness point: inference is billed per token and fine-tuning is billed by tokens processed, all on your Fireworks account. Starting a fine-tuning job from a workflow spends real money.

Create a Fireworks API key

Mattering authenticates to Fireworks with an API key sent as an Authorization bearer header. It is a single field: no organization id, no version header, no OAuth flow to complete.

Sign in at app.fireworks.ai and open API Keys.
Create a key and name it after where it will be used, such as Mattering Automations.
Copy the key and keep it somewhere safe until you have pasted it into Mattering. Treat it like a password: it can run billable inference and start billable training on your account.
One key is all you need. Fireworks uses the same bearer key for its inference API and its account control plane, so a single credential covers all 16 nodes.

Connect Fireworks AI to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Fireworks AI from the list.
Click Create new credential, paste the API key, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Connect. All 16 Fireworks nodes appear in your canvas palette.
The Fireworks AI connector does not ship a built-in auth test, so Test Connection has nothing to call for this one. Verify with the read-only nodes in the next section instead.

Verify it works

Open any automation canvas and check the palette: a Fireworks AI section should list eight query nodes and eight action nodes. Drop Fireworks: List Accounts onto the canvas and run a test step. It takes no parameters and is read-only, so a successful response proves the key works and returns each account's ID, type, and state. Write down the account ID: the other control-plane nodes for models, datasets, and fine-tuning jobs take it as account_id.

Then run Fireworks: List Models. Its account_id defaults to fireworks, the shared public library, so it works with no configuration and returns the serverless catalog, with model IDs in the form accounts/fireworks/models/kimi-k2-instruct-0905. Set account_id to your own account ID instead to list the models you have uploaded or fine-tuned. This is the model discovery path: Fireworks has no models listing on its inference API, so the control plane is where the catalog lives.

To confirm inference itself, add Fireworks: Create Chat Completion, keep the default model, put one short message in the messages array, and set max_tokens low. A successful run returns the reply at choices[0].message.content along with token usage.

Node reference

16 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 8

Fireworks: Get Account

fireworks_get_account

Get one Fireworks account: display name, account type, state, and spend-notification settings.

Fireworks: Get Dataset

fireworks_get_dataset

Get one dataset: state, format, example count, and token estimate. Poll this after an out-of-band upload to wait for state READY before starting a fine-tuning job.

Fireworks: Get Fine-Tuning Job

fireworks_get_sft_job

Get one fine-tuning job: state, progress percent, estimated cost, and the outputModel to call once it reaches JOB_STATE_COMPLETED.

Fireworks: Get Model

fireworks_get_model

Get one model's details: state, kind, context length, and capability flags such as tool support, LoRA support, and serverless availability.

Fireworks: List Accounts

fireworks_list_accounts

List the Fireworks accounts the API key can access, with each account's ID, type, and state. Works with no parameters, so it doubles as the credential health check.

Fireworks: List Datasets

fireworks_list_datasets

List the datasets under a Fireworks account, with each dataset's state, format, and example count. Datasets are the training inputs for fine-tuning jobs.

Fireworks: List Fine-Tuning Jobs

fireworks_list_sft_jobs

List the supervised fine-tuning jobs on the account with their state, base model, output model, and estimated cost.

Fireworks: List Models

fireworks_list_models

List models under a Fireworks account. Use account ID 'fireworks' to browse the shared public model library, or your own account ID to list your uploaded and fine-tuned models.

Action nodes 8

Fireworks: Create Chat Completion

fireworks_create_chat_completion

Run a chat completion on Fireworks serverless inference. Send a messages array, get the assistant reply back at choices[0].message.content plus token usage. Supports tool calling, JSON-mode and JSON-schema structured output, vision models via image_url content parts, and reasoning models. Non-streaming.

Fireworks: Create Completion

fireworks_create_completion

Run a raw text completion: prompt in, continuation out at choices[0].text. Use this for base models or when you control the full prompt format yourself; use Create Chat Completion for instruct models. Non-streaming.

Fireworks: Create Embeddings

fireworks_create_embeddings

Turn text into embedding vectors for search, clustering, or similarity. Accepts a single string or a JSON array of up to 2048 strings; vectors come back at data[].embedding in input order.

Fireworks: Create Fine-Tuning Job

fireworks_create_sft_job

Start a supervised fine-tuning (LoRA) job over an uploaded dataset. Training is billed by tokens processed, so this spends real money. The job runs asynchronously: poll Get Fine-Tuning Job for state and the resulting outputModel.

Fireworks: Create Message (Anthropic Format)

fireworks_create_message

Run a Fireworks model through the Anthropic-compatible Messages endpoint: Messages-format request in, content blocks out at content[0].text. Useful when a flow or prompt library is already built around the Messages shape. Auth stays the Fireworks Bearer key. Non-streaming.

Fireworks: Delete Dataset

fireworks_delete_dataset

Permanently delete a dataset from the Fireworks account. This cannot be undone.

Fireworks: Delete Fine-Tuning Job

fireworks_delete_sft_job

Permanently delete a supervised fine-tuning job record. This cannot be undone.

Fireworks: Rerank Documents

fireworks_rerank_documents

Rerank a list of documents by relevance to a query using a Fireworks reranker model. Returns each document's index and relevance_score sorted best-first: the standard second stage after a keyword or vector search.

Using the integration

On the automation canvas

Fireworks nodes chain with everything else: pull a record, generate or classify with Fireworks: Create Chat Completion, then write the result into a task, a message, or a Database row. Template references resolve inside nested JSON, so an upstream node's output can drop straight into one entry of the messages array, a rerank documents list, or a tool definition, rather than templating the whole array as a single blob.

Three ways to run a model

Fireworks: Create Chat Completion is the standard messages in, choices out shape, with tool calling, JSON mode and JSON-schema structured output, vision input via image_url content parts, and reasoning models. Fireworks: Create Completion is prompt in, continuation out, for base models or when you control the full prompt format yourself. Fireworks: Create Message (Anthropic Format) runs Fireworks models through a Messages-compatible endpoint for prompts already built around that shape; auth stays the Fireworks key and the model field takes a Fireworks model ID. All three are non-streaming, so each node returns one complete response.

Embeddings and reranking

Fireworks: Create Embeddings accepts a single string or a JSON array of up to 2048 strings and returns vectors in input order at data[].embedding. Fireworks: Rerank Documents is the second stage: give it a query and a list of candidate documents and it returns each document's index and relevance_score sorted best-first, which is the standard follow-up to a keyword or vector search before handing results to a generation step.

The fine-tuning lifecycle

Upload the training dataset out of band, then poll Fireworks: Get Dataset until its state is READY. Fireworks: Create Fine-Tuning Job starts a supervised LoRA run over it, billed by tokens processed, and returns a job to poll with Fireworks: Get Fine-Tuning Job for state, progress, and estimated cost. When the job completes, pass its outputModel as the model on a chat completion. Fireworks: Delete Dataset and Fireworks: Delete Fine-Tuning Job are permanent, so point them only at resources you are done with.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and Matter can drive them, so an assistant can look up what a key can call, run inference, and check on a training job through the same 16 nodes the canvas uses.

Troubleshooting

Every node returns a 401
The key is wrong, revoked, or truncated on paste. Fireworks uses the same bearer key for inference and the control plane, so one bad key fails all 16 nodes at once, which is itself the diagnostic: if everything is failing the same way, it is the credential, not a node. Create a fresh key at app.fireworks.ai, update the credential on the connector, and run Fireworks: List Accounts to confirm the fix.
A control-plane node fails on account_id
The models, datasets, and fine-tuning nodes address resources under an account, and the account_id has to be the exact ID Fireworks knows, not an email address or a display name. Run Fireworks: List Accounts and copy the ID it returns. Note the asymmetry that hides this: the two model nodes default their account_id to fireworks, the public library, so they can succeed while a dataset or job node with a guessed account_id fails.
A model id returns a not found or unavailable error
The model is not available serverless, has been retired, or the id is in the wrong form. Serverless model IDs look like accounts/fireworks/models/kimi-k2-instruct-0905, so an id copied from another provider or an old workflow can stop resolving. Run Fireworks: List Models for what your key can call right now, and check Fireworks: Get Model for the model's state and its serverless availability flag before pointing a workflow at it. The model fields are free text on purpose, so they do not rot the way a fixed dropdown would.
Replies come back shorter than max_tokens
Fireworks silently lowers max_tokens to fit the model's context window instead of erroring the way OpenAI does, so a long prompt quietly shrinks the room left for the reply. Shorten the prompt, pick a model with a longer context length (which Fireworks: Get Model reports), or set context_length_exceeded_behavior on the chat node to control whether an oversized prompt truncates or errors.
Create Fine-Tuning Job is rejected
The usual cause is the dataset: the job references an existing dataset by resource name, and that dataset must be uploaded and in the READY state. Poll Fireworks: Get Dataset and wait for READY before creating the job; a dataset that is still validating cannot back a training run. Fireworks accounts also carry quotas on fine-tuning, so a job can be rejected for quota reasons even with a READY dataset; check your limits in the Fireworks dashboard. Once a job is accepted it spends real money, so poll Fireworks: Get Fine-Tuning Job rather than resubmitting on a slow run.
The Anthropic-format node errors on the model or max_tokens
Fireworks: Create Message (Anthropic Format) speaks the Messages request shape but it is still Fireworks underneath: the model field takes a Fireworks model ID such as accounts/fireworks/models/kimi-k2-instruct-0905, not an Anthropic model name, and auth stays the Fireworks bearer key. Set max_tokens explicitly as well; the Messages format conventionally expects it, and the reply comes back as content blocks with the text at content[0].text rather than the choices array.
There is no node for the endpoint you need
Some gaps are deliberate and some are Fireworks. Audio transcription and image generation have no nodes because Fireworks deprecated its audio API in June 2026 and no longer documents image generation, so those nodes would call endpoints that no longer answer. Dataset create and upload need a real JSONL file upload the canvas config panel cannot produce, so upload out of band and use the list, get, and delete nodes for the rest of the lifecycle. Dedicated deployments provision billable GPU capacity and are left to the Fireworks dashboard, DPO and reinforcement fine-tuning and batch inference are not in this first version, and streaming is not exposed: the connector strips stream from outbound bodies so a payload pasted from an OpenAI integration cannot silently break a node.

Fireworks AI is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products