How to Build AI Agents Without Code Using AnythingLLM's Agent-Flow Builder

AnythingLLM's no-code Agent-Flow Builder lets you assemble AI agents from reusable building blocks via a drag-and-drop interface, storing workflows as JSON files executed by the FlowExecutor class.

The Mintplex-Labs/anything-llm repository includes a powerful visual tool that allows you to build AI agents without code. This no-code Agent-Flow Builder abstracts complex agent logic into modular steps, enabling non-developers to create sophisticated automation workflows through an intuitive web interface.

Understanding the No-Code Agent Architecture

JSON-Based Workflow Storage

Every agent flow you create is persisted as a JSON file in storage/plugins/agent-flows/, with the path configurable via process.env.STORAGE_DIR. The AgentFlows class in server/utils/agentFlows/index.js handles all CRUD operations, validating the JSON schema before saving to disk.

The FlowExecutor Engine

When you run an agent, the FlowExecutor class defined in server/utils/agentFlows/executor.js loads the JSON workflow and orchestrates execution. It iterates through the steps array, instantiating the appropriate executor for each step type—such as api-call, llm-instruction, or web-scraping—and passes outputs from one step as inputs to the next.

How to Build AI Agents Without Code in AnythingLLM

Step 1: Access the Agent-Flow Builder

Navigate to the Community Hub section in the AnythingLLM web interface. The visual builder loads the drag-and-drop canvas where you can compose your agent workflow without writing any code.

Step 2: Compose Steps Using Building Blocks

Drag step types from the sidebar onto the canvas. Each block represents a reusable component—such as an LLM prompt, API call, or web scraper—defined in server/utils/agentFlows/flowTypes.js. Connect blocks to define the data flow between steps.

Step 3: Configure Step Parameters

Click each block to open its configuration panel. Set parameters such as the prompt template for llm-instruction steps or the endpoint URL for api-call steps. Use the {{variable}} syntax to reference outputs from previous steps, creating dynamic data pipelines.

Step 4: Save and Execute Your Agent

Click the save button to serialize your canvas into the JSON workflow format. The front-end SDK in frontend/src/models/agentFlows.js POSTs the configuration to POST /agent-flows/save, handled by server/endpoints/agentFlows.js. To run your agent, trigger the execution endpoint, which invokes FlowExecutor to process your workflow.

Programmatic Flow Management (Optional)

While the primary interface is visual, you can also manage flows programmatically using the REST API or front-end SDK.

Creating a Flow via Node.js

Use the same endpoint the UI calls to create flows programmatically:

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

async function createSummarizerFlow() {
  const flow = {
    name: 'Web Page Summarizer',
    description: 'Scrape a URL and summarize it with the LLM.',
    steps: [
      {
        type: 'web-scraping',
        config: { url: '{{inputUrl}}' }
      },
      {
        type: 'llm-instruction',
        config: {
          prompt: 'Summarize this content:\n{{webScrapeResult}}',
          model: 'gpt-4'
        }
      }
    ]
  };

  const res = await fetch('https://your-instance/api/agent-flows/save', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ name: flow.name, config: flow })
  });

  const { success, flow: saved } = await res.json();
  console.log('Flow saved with UUID:', saved?.uuid);
}

createSummarizerFlow();

Running Flows from the Front-End SDK

Trigger execution using the JavaScript model:

import AgentFlows from '@/models/agentFlows';

const uuid = 'c1b2d3e4-5678-90ab-cdef-1234567890ab';
const variables = { inputUrl: 'https://news.ycombinator.com/' };

AgentFlows.run(uuid, variables)
  .then(result => console.log('Agent result →', result))
  .catch(err => console.error('Run failed:', err));

Publishing to the Community Hub

Share your flows via the Community Hub using the same JSON format:

import CommunityHub from '@/models/communityHub';
import AgentFlows from '@/models/agentFlows';

async function publish(flowUuid) {
  const flow = await AgentFlows.get(flowUuid);
  const payload = {
    name: flow.name,
    description: flow.config.description,
    steps: flow.config.steps,
    tags: ['summarizer', 'web'],
    visibility: 'public'
  };
  const { success, error } = await CommunityHub.createAgentFlow(payload);
  console.log(success ? 'Published!' : `Error: ${error}`);
}

Key Implementation Files

Understanding the source structure helps when debugging or extending the no-code builder:

• server/utils/agentFlows/index.js – Core manager class handling CRUD operations, file persistence to storage/plugins/agent-flows/, and JSON schema validation.
• server/utils/agentFlows/executor.js – FlowExecutor class that orchestrates step execution and manages data flow between steps.
• server/utils/agentFlows/flowTypes.js – Defines supported step types (llm-instruction, api-call, web-scraping) available in the builder.
• server/endpoints/agentFlows.js – Express routes exposing REST endpoints for saving, loading, listing, and running flows.
• frontend/src/models/agentFlows.js – Front-end SDK providing JavaScript methods to interact with the REST API.
• frontend/src/models/communityHub.js – Handles publishing and importing flows to/from the Community Hub marketplace.
• frontend/src/pages/GeneralSettings/CommunityHub/utils.js – UI utilities for the Community Hub integration.
• frontend/src/pages/GeneralSettings/CommunityHub/ImportItem/Steps/PullAndReview/HubItem/AgentFlow.js – React component for previewing flows during import.

Summary

• AnythingLLM's no-code Agent-Flow Builder stores workflows as JSON files in storage/plugins/agent-flows/, managed by the AgentFlows class.
• The FlowExecutor in server/utils/agentFlows/executor.js runs workflows by chaining step executors (llm-instruction, api-call, web-scraping) and passing outputs between steps.
• You can build AI agents without code using the drag-and-drop canvas, configure step parameters with the {{variable}} syntax, and execute flows via REST endpoints or the front-end SDK.
• The Community Hub integration allows sharing portable JSON workflows across different AnythingLLM installations using frontend/src/models/communityHub.js.

Frequently Asked Questions

What file format does AnythingLLM use to save agent flows?

AnythingLLM persists agent flows as JSON files in the storage/plugins/agent-flows/ directory (configurable via STORAGE_DIR). Each file contains the flow name, description, and a steps array defining the workflow logic, as handled by the AgentFlows class in server/utils/agentFlows/index.js.

Can I run agent flows programmatically without using the web interface?

Yes. You can trigger flow execution programmatically using the REST API endpoint POST /agent-flows/:uuid/run or the front-end SDK method AgentFlows.run(uuid, variables) defined in frontend/src/models/agentFlows.js. The server invokes the FlowExecutor class to process the workflow and return results.

What types of steps can I include in a no-code agent flow?

The supported step types are defined in server/utils/agentFlows/flowTypes.js and include llm-instruction for LLM prompts, api-call for HTTP requests, and web-scraping for extracting web content. Each step type has a corresponding executor in the FlowExecutor that handles its specific logic.

How do I share my agent flows with other AnythingLLM users?

You can publish flows to the Community Hub using the CommunityHub.createAgentFlow() method in frontend/src/models/communityHub.js. This uploads your flow's JSON configuration to the marketplace, making it available for other users to import via the Community Hub interface in frontend/src/pages/GeneralSettings/CommunityHub/ImportItem/Steps/PullAndReview/HubItem/AgentFlow.js.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}