The Groq MCP for low-latency inference inside your automations
Connect one Groq API key and chat completions, the Responses API, Whisper transcription, and batch jobs become steps on a visual canvas that AI agents can drive. 18 typed nodes over Groq's OpenAI-compatible API.
What the Groq MCP connector does
The Groq connector for Mattering Automations covers Groq's documented REST surface as 18 typed nodes: chat completions and the Responses API running on Groq's LPU inference, Whisper transcription and translation from an audio URL, asynchronous batch jobs, file listing, metadata, content download and delete, and LoRA fine-tune registration. Nine are read-only queries and nine are actions.
Every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and any MCP-capable assistant can call them, and so can Matter, the assistant built into the platform. The shape that pays off here is an assistant planning a workflow and handing the high-volume generation to Groq, with both sitting on one canvas you can see and edit.
Groq's API is deliberately OpenAI-compatible, which is why the node list reads like a subset of OpenAI's. Two details are worth knowing. Groq serves two path prefixes, /openai/v1 for the compatible surface and /v1/fine_tunings for its own LoRA registration, and each node carries the right one so a call never lands on the wrong prefix. And every model field is free text with a documented default rather than a fixed list, because Groq adds and retires models on a rolling basis. Run Groq: List Models to see exactly what your key can call.
One connection, three surfaces
- Visual automations. Drag Groq nodes onto the canvas and wire them to triggers, conditions, and other apps.
- AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
- The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.
Every Groq node, ready to drop on the canvas
18 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 9
Groq: Download File Content
Download a file's contents as text. Batch output and error files are JSONL, so the node also returns each line parsed into a `lines` array you can loop over.
Groq: Get Batch
Get one batch job: status, request counts, and the output / error file IDs to download once it completes.
Groq: Get File
Get one file's metadata: size in bytes, filename, purpose, and creation time.
Groq: Get Fine-Tuning
Get one registered fine-tune, including the fine_tuned_model ID you pass as `model` on a chat completion. Enterprise tier only.
Groq: Get Model
Get one model's details: owner, whether it is active, its context window, and its max completion tokens.
Groq: List Batches
List the batch jobs on the account with their current status and request counts.
Groq: List Files
List the files uploaded to the account, with size, filename, and purpose.
Groq: List Fine-Tunings
List the LoRA fine-tunes registered on the account. Enterprise tier only: other accounts get an authorization error.
Groq: List Models
List every model the API key can call, with each model's context window and owner. Takes no parameters, so it doubles as the credential health check.
Action nodes 9
Groq: Cancel Batch
Cancel a batch job that is still validating or in progress. Already-completed requests keep their results.
Groq: Create Batch
Kick off an asynchronous batch job over a previously uploaded JSONL file. Batch runs are discounted and return results as an output file once the window closes.
Groq: Create Chat Completion
Run a chat completion on Groq's LPU inference. Send a messages array, get the assistant reply back at choices[0].message.content plus token usage. Supports tool calling, JSON-mode / structured output, and reasoning models. Non-streaming.
Groq: Create Response
Run a prompt through Groq's Responses API and read the reply straight off output_text. Simpler than chat completions for single-shot generation, and it is the surface that supports built-in tools (code interpreter, browser search, remote MCP). Non-streaming.
Groq: Delete File
Permanently delete an uploaded file from the Groq account.
Groq: Delete Fine-Tuning
Delete a registered LoRA fine-tune. The adapter stops being callable as a model. Enterprise tier only.
Groq: Register Fine-Tuning (LoRA)
Register an already-uploaded LoRA adapter archive as a callable fine-tuned model. Groq does not train adapters; you build them elsewhere and upload the .zip with purpose 'fine_tuning' first. Enterprise tier only.
Groq: Transcribe Audio (URL)
Transcribe an audio file into text with Whisper on Groq. Takes a publicly reachable audio URL (Groq fetches it), this node does not upload local files. Formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, webm.
Groq: Translate Audio to English (URL)
Translate non-English audio into English text with Whisper on Groq. Takes a publicly reachable audio URL, so this node does not upload local files.
Connecting Groq takes one credential
Groq authenticates with a single API key created in the Groq console under API keys. There is no second field, no organization header, and no OAuth flow to complete. The key is shown once at creation, so copy it before you leave the page.
In the Groq console at console.groq.com/keys, create an API key and copy it.
In Mattering Automations, open Connectors, choose Groq, and create a credential holding the key.
Click Connect. All 18 Groq nodes appear in the canvas palette.
Drop Groq: List Models on a canvas and run it as a test step. It takes no parameters, costs no tokens, and returns every model your key can call, so it doubles as the credential health check.
Common uses for the Groq MCP
Generation steps that keep a workflow moving
Drafting, rewriting, summarizing, classifying, and structured extraction as one node between your data source and its destination. The chat completion node supports tool calling, JSON mode and structured output, and reasoning models.
Audio to text without a separate transcription vendor
Point the transcription node at a recording's URL and get the text back with Whisper on Groq, or use the translation node to turn non-English audio into English text in the same step.
Bulk work through batch jobs
Start a batch over a JSONL file, poll it for status, then download the output file. The download node returns the raw text plus each JSONL line already parsed into a lines array, so a For Each node can loop the results straight away.
Choosing the model per step
Mix providers inside one canvas and pick the model for each job. List Models and Get Model report a model's context window, owner, and whether it is active, so a workflow can check before it sends a long prompt.
Keeping the account's files in order
List files, read their size, filename, and purpose, download their contents, and delete the ones a finished batch left behind, so batch inputs and outputs do not pile up unattended.
Callable fine-tunes on enterprise accounts
Register a LoRA adapter you built elsewhere as a callable model, then pass the returned fine_tuned_model id as the model on a chat completion. These four nodes need an enterprise-tier Groq account.
Example: A recording becomes a summary and assigned work
Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.
Trigger: a scheduled run picks up a new recording whose audio sits at a publicly reachable URL.
Groq: Transcribe Audio (URL) runs Whisper over the recording and returns the transcript.
Groq: Create Chat Completion turns that transcript into a summary and a list of action items, with the transcript dropped straight into one entry of the messages array as a template reference.
Mattering Productivity: a task is created for each action item, with the summary on the card, so the meeting ends with tracked work instead of a text file.
Groq MCP questions, answered
Can an AI agent run Groq inference through this MCP?
Yes. Matter and any MCP-connected assistant, including Claude and ChatGPT, can call the chat completion and Responses nodes, transcribe or translate audio, submit and poll batch jobs, and read or delete files on the account. They use the same 18 nodes the automation canvas uses.
Does this work with Claude, ChatGPT, or other AI assistants?
Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant can connect to your workspace and reach Groq through them. Matter, the assistant built into the platform, uses the same nodes natively. Nothing here is tied to one assistant: the point of the connector is to give whichever assistant you already work with access to Groq inference.
Which models can these nodes call?
Whatever your Groq API key has access to. The model field on every node is free text with a documented default rather than a fixed dropdown, because Groq's line-up changes on a rolling basis and a hardcoded list would go stale. Run Groq: List Models for the current set your key can call, with each model's context window and owner, or Groq: Get Model for one model's details.
Can the audio nodes transcribe a file from my computer?
No. Transcribe Audio (URL) and Translate Audio to English (URL) take a publicly reachable audio URL that Groq fetches itself, which is why the node labels say URL. There is no local file upload in the config panel. Host the audio somewhere Groq can reach, such as a signed URL from your own storage, and pass that. Accepted formats are flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, and webm.
Does Groq have an embeddings endpoint?
No. Groq's API reference does not document an embeddings endpoint, so there is no embeddings node here and one could not be made to work. If a workflow needs vectors, get them from a provider that offers embeddings and keep Groq for generation and audio. This is one of the places where Groq's OpenAI compatibility stops short of full parity.
What is not covered by the 18 nodes?
Two Groq endpoints are deliberately left out. File upload needs a real binary multipart payload and the canvas config panel has no file input, so uploads happen out of band; the read, download, and delete half of the files API is shipped, which means a batch workflow still runs end to end from a file id onward. Text to speech returns a raw audio stream rather than JSON, and this connector has nowhere to put those bytes yet. Streaming is also out of scope: nodes return one complete response, and the connector strips stream from outbound bodies so a payload pasted over from OpenAI cannot silently break a node.
Can I use the fine-tuning nodes?
Only on an enterprise-tier Groq account. The four LoRA nodes are shipped and are plain JSON calls, but Groq restricts its fine-tunings surface to enterprise customers by request, so any other key gets an authorization error. Worth knowing: Groq does not train adapters. You build the LoRA elsewhere and upload the archive, then register it with Groq: Register Fine-Tuning (LoRA) to get a fine_tuned_model id you can pass as the model on a chat completion.
What credential does the connector use, and who bills the usage?
One Groq API key, sent as a bearer token and stored encrypted in Google Secret Manager. Groq bills the tokens, audio, and batch jobs to that key on your own Groq account, under the plan and rate limits you hold there. That is separate from Mattering credits, which are pooled at the organization level and cover running the automation itself.
Put Groq to work inside your workspace
Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.
All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Groq is a product of its respective owner; Mattering is an independent platform.