How to Set Up File Storage in Flowise

Flowise is an open-source tool with over 35,000 GitHub stars that lets you build LLM applications by dragging and connecting nodes. It supports custom tool nodes for external service integration, which is how we'll add file storage. By default, Flowise handles two types of data: chat memory (conversation history) and vector stores (document embeddings for retrieval). Neither of these works as general-purpose file storage. If your agent generates a PDF report, builds a CSV export, or creates an image, there's nowhere to put it. Setting up file storage gives your Flowise agents the ability to:

• Save generated files (reports, exports, code) to a permanent location
• Create branded Send, Receive, or Exchange shares, or a durable fileshare, for anything they create
• Read files uploaded by users or other agents
• Organize outputs into folders for different projects

Without this, your agent's file outputs disappear when the chat session ends.

Before starting, make sure you have these ready:

Flowise instance: Running locally (npx flowise start), in Docker, or on a cloud host like Railway or Render. Any version from 1.4+ works. Version 2.0+ is needed if you want MCP support later.

Fastio workspace: Sign up at fast.io/storage-for-agents and open a workspace. Workspace IDs are 19-digit numeric strings.

API key: Go to Settings > Devices & Agents > API Keys and generate a key, or create one with POST /current/user/auth/key/. Authenticated calls use Authorization: Bearer {api_key} against https://api.fast.io/current/. You'll paste this into your Flowise custom tool configuration.

Basic JavaScript knowledge: The custom tool uses a short JavaScript function. You don't need to be an expert, but you should be comfortable reading 20 lines of code.

Flowise lets you extend agents through Custom Tools. We'll create one that uploads a small text file to Fastio and returns the new file ID. The same call works on Flowise's HTTP Request node if you prefer a visible node on the canvas. In your Flowise dashboard:

1. Go to Tools in the left sidebar
2. Click "Add New" to create a custom tool
3. Name it SaveFile (or whatever makes sense for your workflow)
4. Set the description to "Saves a file to cloud storage and returns the new file ID"

Add these input variables in the tool schema:

• fileName (string, required): The name for the saved file, like report.md
• content (string, required): The text content to save
• apiKey (string, required): Your Fastio API key
• workspaceId (string, required): Your Fastio workspace ID

Then paste this JavaScript function. It posts a small file in one request to https://api.fast.io/current/upload/. Uploads are multipart/form-data. Keep the trailing slash.

const fetch = require('node-fetch');

const uploadFile = async (fileName, content, apiKey, workspaceId) => {
  const bytes = Buffer.from(content, 'utf8');
  const form = new FormData();
  form.append('name', fileName);
  form.append('size', String(bytes.length));
  form.append('chunk', new Blob([bytes]), fileName);
  form.append('action', 'create');
  form.append('instance_id', workspaceId);
  form.append('folder_id', 'root');

const response = await fetch('https://api.fast.io/current/upload/', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${apiKey}`
    },
    body: form
  });

if (!response.ok) {
    const err = await response.text();
    return `Upload failed (${response.status}): ${err}`;
  }

const data = await response.json();
  return `File saved as ${fileName}. File ID: ${data.new_file_id}`;
};

return uploadFile($fileName, $content, $apiKey, $workspaceId);

A successful small upload returns HTTP 201: {"result":true,"id":"<upload_id>","new_file_id":"<node_id>"}. Same-name upload into the same folder overwrites in place and keeps the old content as a recoverable version. The node_id stays stable.

On an HTTP Request node, use the same contract: Method POST, URL https://api.fast.io/current/upload/, header Authorization: Bearer {api_key}, body multipart/form-data with name, size, chunk (the bytes), action=create, instance_id (the workspace ID), and folder_id=root.

For a markdown note instead of a file, POST https://api.fast.io/current/workspace/{workspace_id}/storage/{parent_id}/createnote/. Use root or an existing folder node ID as {parent_id}.

Click Save. Your tool is now available to use in any chatflow.

Now wire the custom tool into a chatflow so your agent can use it. 1. Open your chatflow (or create a new one) 2. Add an Agent node (like OpenAI Function Agent or Tool Agent) 3. Add a Custom Tool node and select SaveFile from the dropdown 4. Connect the tool to the agent's "tools" input 5.

Set the static variables: Paste your API key and workspace ID into the tool's configuration fields. These stay constant across conversations. The agent will decide when to call SaveFile based on the conversation. If a user says "save this as a report," the agent recognizes the intent and calls the tool with the right filename and content.

Pro tip: Set the apiKey and workspaceId as Flowise environment variables instead of hardcoding them. Use $vars.FASTIO_API_KEY in your tool to keep credentials out of the tool definition.

Give Your AI Agents Persistent Storage

Fastio gives teams shared workspaces, MCP tools, and searchable file context to run flowise file storage setup workflows with reliable agent and human handoffs.

Explore Agent Storage

Open the chat window for your chatflow and try these prompts:

• "Write a short summary of today's meeting and save it as meeting-notes.md"
• "Create a Python script that calculates compound interest and save it as calculator.py"
• "Generate a list of 10 blog post ideas and save them as content-ideas.txt"

The agent should respond with a confirmation that includes the file's new_file_id. You can verify the file exists by checking your Fastio workspace dashboard. To hand someone a durable single-file link, follow the upload with POST /current/workspace/{workspace_id}/create/fileshare/. For a branded folder they can browse, create a Send, Receive, or Exchange share with POST /current/workspace/{workspace_id}/create/share/.

Troubleshooting Common Issues

401 Unauthorized: Your API key is wrong or expired. Double-check the key in Settings > Devices & Agents > API Keys.

404 Not Found: The workspace ID doesn't match. Copy the 19-digit ID directly from your Fastio dashboard URL.

Empty file content: The agent sometimes calls the save tool before finishing its output. Add an instruction in your system prompt: "Always finish generating the full content before calling SaveFile."

Network errors in Docker: Make sure your Flowise container can reach external URLs. Check your Docker network configuration and DNS settings.

The custom tool approach works for basic file saves. But if your agents need to read files, search across documents, manage folders, or handle permissions, the Fastio MCP server gives you access to 19 consolidated tools through a single connection. Flowise 2.0+ has native MCP support through its "MCP Tool" node. To connect:

1. Add an MCP Tool node to your chatflow
2. Set the server URL to https://mcp.fast.io/mcp/key (Streamable HTTP is https://mcp.fast.io/mcp; legacy SSE is https://mcp.fast.io/sse)
3. Configure authentication with your Fastio API key as a Bearer header
4. Select the tools you want to expose to your agent

Named mode tools include upload, storage, find, ai, share, fileshare, download, and event. With MCP, your agent can do things the custom tool can't:

• Read uploaded files: Let users drop a PDF into a shared folder and have the agent read it with storage (details) or download
• Search by meaning: Find files with find, or ask Ripley (the built-in RAG agent) with ai (ask)
• Create branded shares: Build Send, Receive, or Exchange portals for client deliverables
• Set up receive folders: Create a Receive share where clients can send files to your agent

A tools/call looks like this:

{"jsonrpc":"2.0","id":1,"method":"tools/call",
 "params":{"name":"upload","arguments":{"action":"web-import","url":"https://example.com/report.pdf",
 "profile_type":"workspace","profile_id":"1234567890123456789"}}}

The MCP server works with any LLM backend that Flowise supports, including OpenAI, Anthropic Claude, Google Gemini, and local models through Ollama. For the full list of available tools and their parameters, check the MCP documentation.