# How to Add Persistent Storage to Flowise AI Agents

Flowise AI agents often lose files, especially in containerized deployments where local storage is temporary. This guide explains how to add cloud storage to your Flowise workflows, so agents can save, retrieve, and share files permanently without managing S3 buckets.

Source: https://fast.io/resources/flowise-ai-agent-storage/
Last reviewed: 2026-02-10

## Why Flowise Agents Lose Their Files

If you run Flowise in a Docker container or on a cloud platform like Render or Railway, you might hit the "missing file" problem. By default, Flowise saves uploaded files and agent outputs to a local directory (defined by `BLOB_STORAGE_PATH`). When your container restarts or redeploys, that local directory is deleted. Your agent's memory of those files disappears, which breaks agents that need to reference previous work or maintain a long-term project history. While Flowise supports S3 and Google Cloud Storage via environment variables, these solutions are built for *infrastructure* storage (where the app keeps its data), not for *agent* storage (where the agent manages and shares files for humans). Setting up an S3 bucket with correct IAM policies just to let a chatbot save a PDF is often too much work for developers who just want to build logic.

Helpful references: [Fastio Workspaces](/product/workspaces/), [Fastio Collaboration](/product/collaboration/), and [Fastio AI](/product/ai/).

## What to check before scaling flowise ai agent storage

Flowise is great for logic and orchestration, but it needs storage to handle file-heavy workflows. Effective agent storage needs:

*   **Persistence:** Files survive restarts and redeployments.
*   **Accessibility:** Files are accessible via URL, not just hidden in a bucket.
*   **Intelligence:** The storage layer should auto-index content for RAG.
*   **Collaboration:** Humans should be able to see what the agent created. Fastio fixes this with a cloud storage file system made for AI agents. Unlike raw object storage (S3), Fastio provides a file system API, built-in RAG through Ripley, and a visual interface for humans. Cloud storage architecture matters more than most people realize. Sync-based platforms require local copies of every file, consuming disk space and creating version conflicts. Cloud-native platforms stream files on demand, so your team accesses what they need without downloading entire folder trees.

## 3 Ways to Store Files in Flowise

Depending on your technical requirements, you have three main options for handling files in Flowise.

### 1. Local Filesystem (Ephemeral)
*   **Best for:** Local testing, temporary files.
*   **Setup:** Default behavior.
*   **Risk:** Data loss on container restart.
*   **Pros:** Zero configuration.

### 2. S3 / MinIO (Infrastructure)
*   **Best for:** Enterprise deployments, long-term archival.
*   **Setup:** Requires configuring `STORAGE_TYPE=s3` and AWS credentials.
*   **Risk:** Complexity. Debugging IAM permission errors can be time-consuming.
*   **Pros:** Industry standard, infinite scale.

### 3. Fastio (Agent-Focused)
*   **Best for:** Active workflows, human review, RAG.
*   **Setup:** An HTTP Request node against `/current/` REST routes, a Custom Tool, or the Fastio MCP server when Flowise can attach it.
*   **Pros:** Built-in RAG (Ripley), shareable Send/Receive/Exchange links, a visual workspace for humans. Consider how this fits into your broader workflow and what matters most for your team. The right choice depends on your specific requirements: file types, team size, security needs, and how you collaborate with external partners. Start with one workspace and a single HTTP Request node so you can see if the flow fits your chatflow.

## Tutorial: Connecting Flowise to Fastio via HTTP Request

Flowise supports HTTP requests, so you can call Fastio's REST API directly from the canvas with no extra dependency. (For scripted work outside Flowise there is also a CLI, `@vividengine/fastio-cli`.) This is the right mechanism when you want an explicit, visible node on the canvas. Official guidance is that agent-facing integrations should use the Fastio MCP server when the runtime can connect to it: Streamable HTTP at `https://mcp.fast.io/mcp`, or `https://mcp.fast.io/mcp/key` with a Bearer header. Use MCP for search, RAG questions, and multi-step uploads. Use the HTTP Request node for a single, well-defined REST call.

**Step 1: Get Your API Key**
1. Create a Fastio account and open a workspace. Workspace IDs are 19-digit numeric strings. 2. Go to Settings > Devices & Agents > API Keys and generate a key. You can also create a key with `POST /current/user/auth/key/`. Every authenticated call uses `Authorization: Bearer {api_key}`.

**Step 2: Add the HTTP Request Node**
In your Flowise canvas, add the **HTTP Request** tool. Configure it to upload a small file in one request (Fastio auto-adds it to storage):

*   **Method:** `POST`
*   **URL:** `https://api.fast.io/current/upload/`
*   **Headers:**
    *   `Authorization`: `Bearer {api_key}`
*   **Body:** `multipart/form-data` with these fields:
    *   `name`: the filename
    *   `size`: the file size in bytes
    *   `chunk`: the file bytes
    *   `action`: `create`
    *   `instance_id`: the workspace ID
    *   `folder_id`: `root` (or an existing folder node ID)

Keep the trailing slash. Most Fastio POST bodies are `application/x-www-form-urlencoded`. Uploads are the exception: they use `multipart/form-data`. If Flowise already has a public URL for the file (instead of raw bytes), prefer `POST https://api.fast.io/current/web_upload/` with form fields `source_url`, `file_name`, `profile_id`, `profile_type` (`workspace` or `share`), and `folder_id`.

**Step 3: Handle the Response**
A successful small upload returns HTTP 201:

```
{"result":true,"id":"<upload_id>","new_file_id":"<node_id>"}
```

There is no download URL in that payload. Pass `new_file_id` back to the LLM, or follow up with `GET /current/workspace/{workspace_id}/storage/{node_id}/details/` or `GET /current/workspace/{workspace_id}/storage/{node_id}/read/`. Same-name upload into the same folder overwrites in place and keeps the old content as a recoverable version. The `node_id` stays stable. Do not delete-then-re-upload.

Large files use a session on the same `/current/upload/` route, then `POST /current/upload/{id}/chunk/?order=N&size=N`, `POST /current/upload/{id}/complete/`, and `GET /current/upload/{id}/details/?wait=60` (response includes `session.status` and `session.new_file_id`). A single Flowise HTTP Request node is a poor fit for that sequence. Prefer the MCP `upload` tool (`create-session`, `chunk`, `finalize`) or, for a URL, MCP `upload` with action `web-import`. > **Pro Tip:** After files are in the workspace, Ripley (Fastio's built-in agent) can answer questions about them. From Flowise, the better path is the MCP `ai` tool with action `ask` (read-only RAG, requires `profile_type`). Over REST you can start a Ripley chat with `POST /current/workspace/{workspace_id}/ai/agent/`.

## Advanced: Using Custom Tools for File Management

For listing files, moving folders, or reading bytes, you can create a **Custom Tool** in Flowise that calls Fastio's `/current/` storage routes. This lets your agent manage files the way a human would, beyond a one-shot upload. For natural-language find-and-summarize jobs, prefer MCP. The MCP `find` tool searches a workspace or share. The MCP `ai` tool with action `ask` returns a cited answer. The MCP `storage` tool (`list`, `search`, `move`, `copy`, `delete`, `details`, `version-list`, `version-restore`) requires `profile_type` set to `workspace` or `share`. Streamable HTTP is `https://mcp.fast.io/mcp` (or `https://mcp.fast.io/mcp/key` with a Bearer header).

REST routes you can wire to an HTTP Request node or Custom Tool (all under `https://api.fast.io/current/`, all with `Authorization: Bearer {api_key}`):

*   List a folder: `GET /current/workspace/{workspace_id}/storage/{parent_id}/list/`
*   File details: `GET /current/workspace/{workspace_id}/storage/{node_id}/details/`
*   Download bytes: `GET /current/workspace/{workspace_id}/storage/{node_id}/read/`
*   Move: `POST /current/workspace/{workspace_id}/storage/{node_id}/move/`
*   Copy: `POST /current/workspace/{workspace_id}/storage/{node_id}/copy/`

**Example Custom Tool Definition (JavaScript)** that lists a folder:

```javascript
const fetch = require('node-fetch');
const workspaceId = $env.FASTIO_WORKSPACE_ID;
const parentId = $env.FASTIO_FOLDER_ID;
const url = 'https://api.fast.io/current/workspace/' + workspaceId + '/storage/' + parentId + '/list/';
const options = {
  method: 'GET',
  headers: {
    Authorization: 'Bearer ' + $env.FASTIO_API_KEY
  }
};
try {
  const response = await fetch(url, options);
  const text = await response.text();
  return text;
} catch (error) {
  console.error(error);
  return '';
}
```

If you cannot attach MCP natively, an HTTP Request node can POST this JSON-RPC body to `https://mcp.fast.io/mcp/key` with `Authorization: Bearer {api_key}`:

```json
{"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"}}}
```

Ask the chatflow to list a known folder, or to import a report URL into the workspace. For "find the Q3 marketing report and summarize it," use MCP `find` or MCP `ai` (`ask`).

## Real-World Use Case: Automated Client Reporting

Consider an agency automation workflow. Generating and delivering a client report usually involves multiple manual steps. With Flowise and Fastio, this becomes fully autonomous:

1. **Generation:** A Flowise chain gathers data from Google Analytics and writes a PDF report.
2. **Storage:** The chain uploads the PDF with `POST /current/upload/`, setting `instance_id` to the client workspace ID and `folder_id` to that Reports folder's node ID.
3. **Delivery:** Create a Send, Receive, or Exchange share with `POST /current/workspace/{workspace_id}/create/share/`, or a durable single-file link with `POST /current/workspace/{workspace_id}/create/fileshare/`. The client opens that share to see the new file.
4. **Confirmation:** Confirm the file landed by long-polling `GET /current/activity/poll/{entityId}?wait=95&lastactivity={timestamp}`, or by querying the activity log with `GET /current/events/search/`. Either one lets the account manager's tooling react to the delivery without a human checking the folder. This workflow separates the *logic* (Flowise) from the *state* (Fastio), creating a reliable system that doesn't depend on the memory of a single container.

## Frequently asked questions

### Does Flowise support local file storage?

Yes, Flowise supports local file storage by default using the `BLOB_STORAGE_PATH` variable. However, this storage is often ephemeral in containerized environments (Docker, Render, etc.), meaning files are lost if the service restarts.

### How do I save Flowise agent outputs permanently?

Connect Flowise to external storage. You can configure S3 or Google Cloud Storage for infrastructure-level storage, or call Fastio from an HTTP Request node (small files via POST https://api.fast.io/current/upload/, URL imports via POST https://api.fast.io/current/web_upload/). When Flowise can attach an MCP server, use https://mcp.fast.io/mcp instead.

### Can Flowise agents read files from Fastio?

Yes. Use a Custom Tool or HTTP Request node against GET /current/workspace/{workspace_id}/storage/{node_id}/read/ for bytes, or GET /current/workspace/{workspace_id}/storage/{node_id}/details/ for metadata. For questions about file contents, prefer the MCP ai tool with action ask.

### Is Fastio free for AI agents?

Fastio is a paid product, so there is no permanent free agent tier. To get started, create an account, open a workspace, and generate an API key from Settings > Devices & Agents > API Keys, or with POST /current/user/auth/key/. For agent-facing search, RAG, and multi-step uploads, prefer the MCP server at https://mcp.fast.io/mcp (or https://mcp.fast.io/mcp/key with a Bearer header). Use an HTTP Request node for a single documented /current/ REST call.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.