Node Reference

Nodes are the basic units for orchestrating Workflows and Chatflows. On the “App Development” canvas, add nodes by clicking and connect them along your business logic to form a complete app flow. This article introduces every node LanSphere provides, grouped by function — what each node does, its key settings, and what it outputs — for quick lookup while you orchestrate.

Before reading, get familiar with two basic concepts:

• Node groups: The canvas node list is divided into six functional groups — Start, AI, Logic Control, Data Processing, External Calls, and Output. The list can be expanded/collapsed and searched by fuzzy name match to quickly find what you need.
• Variable references: An upstream node’s output variables can be referenced by downstream nodes. For example, the user’s question collected by the “Input” node can be referenced as a context variable in the “LLM” node’s prompt; chunks retrieved by the “Knowledge Base” node can be passed downstream for further processing. Before publishing, use the Variable Inspector to confirm variable definitions, type matching, and reference validity.

Start

Input

The entry node that receives user input — both conversational input and form input enter the flow here.

• Key settings: Define what input to collect from the user.
• Outputs: The user’s submitted input, available as variables for downstream nodes.
• Tips: The “Input” node is globally unique — an app can have only one; once it is on the canvas, the node list hides it automatically.

Scheduled Trigger

Automatically triggers the app on a recurring schedule — no human action needed.

• Key settings: Set the recurring schedule rule.
• Outputs: Starts one flow run on each scheduled tick.
• Tips: For recurring automation such as scheduled reports and scheduled data collection.

Webhook Callback

Generates a callback URL that external systems call to trigger the app.

• Key settings: Complete the callback configuration as prompted on the page.
• Outputs: The content the external system passes in when calling the callback URL, for downstream nodes to use.
• Tips: For scenarios driven by business-system events — e.g., an external system produces new data and triggers the processing flow automatically.

AI

LLM

Calls an LLM to generate text — the core node for smart Q&A, content generation, summarization, and more.

• Key settings: Choose the model; write a prompt that governs the model’s responses; reference upstream context variables in the prompt.
• Outputs: The text generated by the model.
• Tips: Prompt quality directly determines output quality — state the task goal, output format, and constraints clearly. Available models depend on what is connected in “System Settings → Models.”

Knowledge Base

Retrieves content relevant to the input from associated Knowledge Bases and outputs the retrieved knowledge chunks.

• Key settings: Associate one or more Knowledge Bases; set retrieval parameters — Top K (default 3), Score threshold (off by default), and retrieval method (vector / full-text / hybrid).
• Outputs: Retrieved knowledge chunks, for downstream nodes such as “LLM” to reference.
• Tips: Usually paired with the “LLM” node to form a knowledge Q&A chain; retrieval precision can be tuned step by step via Top K, the Score threshold, and the retrieval method.

Agent

Attaches a published Agent into the flow, letting it coordinate resources autonomously to complete the task.

• Key settings: Single-select one from the published-Agent list to attach.
• Outputs: The Agent’s execution result.
• Tips: Only published Agents can be attached; published Agents can be viewed in the “Collaboration Components → Agent” tab.

Intent Recognition

Classifies user input into branches by semantics, routing the flow along different paths by intent.

• Key settings: Define each intent category and its description.
• Outputs: The recognized intent category, driving the subsequent branch.
• Tips: A typical case is a customer-service app — first classify the user’s question into intents like “inquiry,” “complaint,” or “after-sales,” then route each into its own handling flow so every kind of question gets a targeted response.

Parameter Extraction

Extracts structured parameters from natural language, turning colloquial user expressions into fields the flow can use directly.

• Key settings: Define the parameters to extract from the input.
• Outputs: The extracted structured parameters, for downstream nodes to reference.
• Tips: For scenarios like form filling and query-condition parsing — e.g., extracting the time range from “check next week’s department meeting schedule for me.”

Logic Control

Conditional Branch

Splits the flow into multiple branches by conditions — the equivalent of an if / elif / else structure.

• Key settings: Configure the condition for each branch.
• Outputs: The flow continues into the branch whose condition holds.
• Tips: When organizing branches as if / elif / else, mind the order of conditions so every case has a clear destination.

Loop

Repeats a stretch of the flow until a set condition no longer holds.

• Key settings: Configure the loop’s execution logic and termination condition.
• Outputs: The final result produced by the loop.
• Tips: Make sure a terminating condition is set to avoid an infinite loop.

Iteration

Runs the same processing on every item of an array in parallel, completing batch tasks in one go.

• Key settings: Specify the array to process and the per-item processing logic.
• Outputs: A collection of per-item results.
• Tips: For batch-processing similar data — e.g., generating a summary for each document in a batch.

Data Processing

Code Execution

Write custom processing logic in Python or JavaScript for data work that built-in nodes cannot do directly.

• Key settings: Choose the script language and write the script, configured as prompted on the page.
• Outputs: The script’s execution result.
• Tips: For individualized processing like format conversion and data computation.

Variable Assignment

Writes or updates a variable’s value — keeping intermediate state or constructing new variables in the flow.

• Key settings: Choose the target variable and set the value to write.
• Outputs: The updated variable value.
• Tips: Commonly used to initialize variables or update them at stages within a flow.

Variable Aggregator

Aggregates the outputs of multiple branches into one variable for later nodes to reference uniformly.

• Key settings: Choose the output variables of the branches to aggregate.
• Outputs: A single aggregated variable.
• Tips: Where multiple branches converge, Variable Aggregator spares downstream nodes from referencing each branch’s output separately, keeping the flow structure cleaner.

Variable Formatter

Concatenates multiple variables into a piece of text by template.

• Key settings: Write the text template and reference the variables to concatenate in it.
• Outputs: The concatenated text.
• Tips: Good for fixed-structure content such as notification copy and report paragraphs.

Document Parser

Extracts text from uploaded document files for downstream nodes to process.

• Key settings: Specify the document file source to parse.
• Outputs: The text extracted from the document.
• Tips: Often the preprocessing step of document apps — parse the document first, then hand it to the LLM for analysis or summarization.

Array Operations

Performs filter, sort, and pick operations on arrays.

• Key settings: Specify the target array and the operation.
• Outputs: The processed array or the picked element.
• Tips: For secondary processing of list-type results from upstream — e.g., filter out qualifying entries before handling them one by one.

External Calls

External-call nodes bring tool capabilities from inside and outside the platform into the flow. When adding any of the four — System Plugins, Workflow, MCP, Custom Tools — clicking opens the corresponding tool list for you to choose from.

HTTP Request

Calls an external REST API to integrate with external systems that expose open APIs.

• Key settings: Configure the request URL, method, headers, body, and authentication, and complete parameter mapping.
• Outputs: The response returned by the API.
• Tips: Manage parameters like service addresses and secrets through Environment Variables to avoid exposing them in plain text in flow configurations; mark one as a secret variable and its value is masked with asterisks.

System Plugins

Calls the platform’s built-in plugin capabilities.

• Key settings: Choose the plugin to call from the System Plugins list.
• Outputs: The plugin’s execution result.
• Tips: Available plugins depend on what is installed and enabled in “Plugin Management.”

Workflow

Calls Workflow components published in “Collaboration Components” to reuse flows.

• Key settings: Choose the component to call from the Workflow component list.
• Outputs: The called Workflow’s output.
• Tips: Once a Workflow app is consolidated as a component via “Publish as Component,” it can be called by any app on the platform — see “Collaboration Components.”

MCP

Calls tools provided by MCP Services.

• Key settings: Choose the tool to call from the MCP Services list.
• Outputs: The MCP tool’s execution result.
• Tips: The platform comes with the Lansenger MCP toolset covering messaging, groups, contacts, calendar, video meetings, and media files; more MCP Services can be added under the “MCP Services” menu.

Custom Tools

Calls tools built by your team.

• Key settings: Choose the tool to call from the Custom Tools list.
• Outputs: The custom tool’s execution result.
• Tips: Custom Tools are created in “Plugin Management” and can only be called after passing the test and being saved.

Output

Reply

Outputs a message to the user in a Chatflow — can output multiple times mid-flow.

• Key settings: Write the message to send the user; upstream variables can be referenced.
• Outputs: The message shown to the user.
• Tips: Chatflow only. With multiple outputs, you can report stage progress to the user in time during longer flows.

Output

Returns the final result when a Workflow ends.

• Key settings: Define the result content to return.
• Outputs: The Workflow’s final result.
• Tips: For Workflows. A Workflow takes input straight to output with no interaction; the final result is delivered through this node.

Node Quick-Reference Table