Flowise (End of Life)

Flowise ended active development on July 29, 2026, archived its repositories on August 13, 2026, and ends official support on August 31, 2026. This guide is retained for existing self-hosted deployments. Do not start new production projects with Flowise. See the official Flowise announcement.

Flowise was an open-source low-code tool for building customized LLM orchestration flows and AI agents. Its source remains available under the Apache 2.0 license, but the upstream repository is read-only and no longer accepts fixes. By integrating Cerebras with Flowise, you can leverage the world’s fastest AI inference to power your Flowise applications with ultra-low latency and high throughput.

This legacy guide covers the ChatCerebras v3.0 node from the final Flowise releases, including its model dropdown selector and automatic integration tracking.

Prerequisites

Before you begin, ensure you have:

Cerebras API Key - Get a free API key here.
Existing self-hosted Flowise installation - Use this guide only to maintain an existing deployment.
Node.js 24 - Required by the final Flowise 3.1.x package.

Install Flowise

Install Flowise via NPM

The easiest way to get started with Flowise is to install it globally using NPM:

npm install -g flowise

Alternatively, you can use Docker:

docker run -d -p 3000:3000 flowiseai/flowise

Start Flowise

Once installed, start Flowise with:

flowise start

This will launch Flowise on http://localhost:3000. Open this URL in your browser to access the Flowise interface.

Configure Cerebras in Flowise

Create a new Chatflow

In the Flowise UI, create a new chatflow to house your Cerebras-powered application:

Click on “Chatflows” in the left sidebar
Click the “+Add New” button
Give your chatflow a descriptive name like “Cerebras Chat Assistant”

Add the ChatCerebras node

Flowise has a dedicated ChatCerebras node for seamless integration:

In the canvas, click the ”+” button or drag from the left panel
Search for “ChatCerebras” in the Chat Models category
Drag the ChatCerebras node onto the canvas

Configure the ChatCerebras node

Click on the ChatCerebras node to open its configuration panel and configure the following settings:Required Settings:

Connect Credential: Click to add your Cerebras API Key
- If this is your first time, click “Create New”
- Enter your API key from cloud.cerebras.ai (starts with csk-)
- Give it a name like “Cerebras API”
- Click “Add”
Model Name: Select from the dropdown:
- gpt-oss-120b - General text, coding, and tool use

The final Flowise 3.1.x releases may preselect the retired llama3.1-8b model. Explicitly select gpt-oss-120b before saving the node.

Optional Settings (under Additional Parameters):

Temperature: Control randomness (0.0 to 1.0, default 0.9)
Max Tokens: Maximum response length
Top P: Nucleus sampling parameter
Streaming: Enable for real-time token generation (default: true)

The ChatCerebras node automatically:

Configures the correct API endpoint (https://api.cerebras.ai/v1)
Adds the integration tracking header for better support
No manual configuration needed!

Connect additional nodes

Build out your chatflow by adding other nodes to create a complete application:

Add a Prompt Template - Click ”+” and search for “Prompt Template” to customize your system prompts
Add Memory (optional) - Search for “Buffer Memory” or “Conversation Buffer Memory” to maintain conversation context
Connect the nodes - Draw connections between nodes by clicking and dragging from output ports to input ports

A basic flow might look like:

Prompt Template → ChatCerebras → Output

Or with memory:

Prompt Template → Buffer Memory → ChatCerebras → Output

Test your chatflow

Once your nodes are connected, test your Cerebras-powered chatflow:

Click the “Save” button in the top right
Click the “Chat” icon to open the test interface
Send a test message like “Hello! What can you help me with?”
You should receive a response from your Cerebras-powered chatflow

If you encounter any errors, check that your API key is correct and the Base URL is set to https://api.cerebras.ai/v1.

Using Cerebras with Flowise API

Flowise automatically generates REST APIs for your chatflows, allowing you to integrate Cerebras-powered AI into any application.

Get your Chatflow API endpoint

In the Flowise UI:

Open your chatflow
Click the “API” button in the top right
Copy the API endpoint URL (e.g., http://localhost:3000/api/v1/prediction/your-chatflow-id)

Make API requests to your chatflow

You can now call your Cerebras-powered chatflow from any application:

import requests
import json

url = "http://localhost:3000/api/v1/prediction/your-chatflow-id"

payload = {
    "question": "What is the capital of France?",
    "overrideConfig": {
        "temperature": 0.7
    }
}

headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)
result = response.json()

print(result["text"])

const response = await fetch(
  'http://localhost:3000/api/v1/prediction/your-chatflow-id',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      question: 'What is the capital of France?',
      overrideConfig: {
        temperature: 0.7,
      },
    }),
  }
);

const result = await response.json();
console.log(result.text);

curl -X POST http://localhost:3000/api/v1/prediction/your-chatflow-id \
  -H "Content-Type: application/json" \
  -d '{
    "question": "What is the capital of France?",
    "overrideConfig": {
      "temperature": 0.7
    }
  }'

The chatflow will use Cerebras Inference to generate responses, giving you the speed and performance of Cerebras through Flowise’s convenient API.

Direct Integration with OpenAI SDK

For advanced users who want to use Cerebras directly in custom Flowise nodes or external applications, you can use the OpenAI SDK with Cerebras configuration:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("CEREBRAS_API_KEY"),
    base_url="https://api.cerebras.ai/v1",
    default_headers={
        "X-Cerebras-3rd-Party-Integration": "flowise"
    }
)

response = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ],
    max_tokens=500,
    temperature=0.7
)

print(response.choices[0].message.content)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.CEREBRAS_API_KEY,
  baseURL: 'https://api.cerebras.ai/v1',
  defaultHeaders: {
    'X-Cerebras-3rd-Party-Integration': 'flowise'
  }
});

const response = await client.chat.completions.create({
  model: 'gpt-oss-120b',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'What is the capital of France?' }
  ],
  max_tokens: 500,
  temperature: 0.7
});

console.log(response.choices[0].message.content);

curl https://api.cerebras.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CEREBRAS_API_KEY" \
  -H "X-Cerebras-3rd-Party-Integration: flowise" \
  -d '{
    "model": "gpt-oss-120b",
    "messages": [
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "What is the capital of France?"
      }
    ],
    "max_tokens": 500,
    "temperature": 0.7
  }'

Advanced Configuration

Using Environment Variables

For production deployments, store your Cerebras API key as an environment variable:

export CEREBRAS_API_KEY=your-api-key-here

Then in Flowise, reference it in the ChatCerebras credential configuration using ${CEREBRAS_API_KEY}.

Streaming Responses

To enable streaming responses for real-time output:

In the ChatCerebras node, enable “Streaming”
Your API responses will now stream tokens as they’re generated
This is particularly useful for long-form content generation and provides a better user experience

Using Multiple Cerebras Models

You can create different chatflows for different use cases:

Text and coding: Use gpt-oss-120b
Multimodal applications through a custom node: Use the gemma-4-31b model
Reasoning applications: Review the model catalog before choosing a model

Next Steps

Review the archived Flowise source and end-of-life announcement
Try different Cerebras models to find the best fit for your use case
For new projects, choose an actively maintained option from the integrations directory

FAQ

Error: 'Invalid API key' or 401 Unauthorized

This usually means your Cerebras API key is incorrect or not properly configured:

Verify your API key at cloud.cerebras.ai
Make sure there are no extra spaces or characters in the API key field
If using environment variables, ensure they’re properly loaded
Try regenerating your API key if the issue persists

Error: 'Model not found' or invalid model name

Ensure you’re using the correct model name format:

Use gpt-oss-120b as the default model
Do not leave the node on its retired llama3.1-8b default
Check the model catalog before selecting a different model

Refer to the Cerebras models documentation for the complete list of available models.

Responses are slow or timing out

If you’re experiencing slow responses:

Check your internet connection
Verify the Base URL is set to https://api.cerebras.ai/v1 (not http://)
Try reducing the max_tokens parameter
Reduce unnecessary prompt and output tokens
Check Cerebras status page for any service issues

Does the integration tracking header get added automatically?

Yes! As of ChatCerebras v3.0, the X-Cerebras-3rd-Party-Integration: flowise header is automatically included in all requests. You don’t need to manually configure anything.This header helps Cerebras:

Track integration usage and performance
Provide better support for Flowise users
Identify and resolve integration-specific issues faster

How do I switch between different Cerebras models?

Switching models is easy with the dropdown selector:

Click on the ChatCerebras node in your chatflow
Click the “Model Name” dropdown
Select your desired model from the list (each has a description to help you choose)
Save the chatflow
Test with the new model

You can also create multiple chatflows with different models for different use cases. The dropdown makes it easy to see all available options at a glance.

What additional latency can I expect when using Cerebras through Flowise?

Flowise adds minimal overhead since it primarily orchestrates the workflow. The actual inference is performed directly by Cerebras, so you’ll experience the same ultra-low latency that Cerebras is known for. Any additional latency is typically negligible (< 50ms) and comes from Flowise’s workflow orchestration.

Integrations

Agentic Frameworks

AI Development Kits

Coding Tools

Containerization

Observability & Evaluation

LLM Integration Tools

LLM Application Frameworks

Document Processing

Real-Time Audio

Multi-LLM Management

No-Code/Low-Code Platforms

Prerequisites

Install Flowise

Configure Cerebras in Flowise

Using Cerebras with Flowise API

Direct Integration with OpenAI SDK

Advanced Configuration

Using Environment Variables

Streaming Responses

Using Multiple Cerebras Models

Next Steps

FAQ

​Prerequisites

​Install Flowise

​Configure Cerebras in Flowise

​Using Cerebras with Flowise API

​Direct Integration with OpenAI SDK

​Advanced Configuration

​Using Environment Variables

​Streaming Responses

​Using Multiple Cerebras Models

​Next Steps

​FAQ

Prerequisites

Install Flowise

Configure Cerebras in Flowise

Using Cerebras with Flowise API

Direct Integration with OpenAI SDK

Advanced Configuration

Using Environment Variables

Streaming Responses

Using Multiple Cerebras Models

Next Steps

FAQ