How to Add Persistent Storage to Flowise AI Agents

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, Fastio Collaboration, and Fastio AI.

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.

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.

Give Your AI Agents Persistent Storage

Persistent workspace storage for Flowise agents. Built-in RAG via Ripley, REST under /current/, and an MCP server so you are not managing buckets.

Explore Agent Storage

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/.

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:

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}:

{"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).

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.