Platform For AI:Workflow node reference

Start

The Start Node establishes the entry point of an Application Flow and specifies its input parameter configuration.

• For conversational Application Flows, there are two default fields: Conversation History and User Input. You can add custom variables as needed. The node supports File type input variables for user-uploaded files. For more information, see File type input/output.

  

• When you run the Application Flow, configure the input parameters for the current session in the conversation panel.

  

Conditional Branch

This node implements IF/ELSE logical operations for flow control. When specified conditions are satisfied, only the corresponding branch executes. If no conditions are met, the else branch activates. This node requires integration with the Variable Aggregate node.

• Configuration interface

  

• Input

  When configuring branch conditions, keep the following in mind:

  • Each branch represents an execution path. The last branch is the else branch, which runs if no other conditions are met and cannot be edited.

  • Each branch can have multiple conditions that support and/or logic.

  • To ensure your conditions are accurate and valid, carefully check the outputs of upstream nodes, matching operators (such as =, ≠, is empty, does not include), and matching values.

• Output

  This node has no output.

• Usage example

  When connecting a Conditional Branch node to downstream components, each branch features a corresponding port on the node. When a branch condition triggers, the downstream nodes connected to that branch execute, while nodes in alternative branches are bypassed. Subsequently, utilize a Variable Aggregate node to consolidate outputs from all conditional branches.

  

Variable Aggregate

This node consolidates outputs from multiple branches into a unified variable structure. In multi-branch scenarios, this functionality enables mapping variables with identical purposes from various branches to a single output variable, eliminating redundant definitions in downstream components.

• Configuration interface

  

• Input

  When you configure variable groups, keep the following in mind:

  • The upstream nodes are typically multiple execution branches from a Conditional Branch or Intent Recognition nodes.

  • Variables within the same group must be of the same type. The first non-empty output value becomes the output for that group.

  • Since a Conditional Branch or Intent Recognition node triggers only one branch, each group will have only one non-empty value. The Variable aggregate node extracts this value for use by downstream nodes.

  • If each branch has multiple required outputs, you can add multiple groups to extract each corresponding output value.

• Output

  The output variables dynamically adjust to the groups you add. If there are multiple groups, the node outputs multiple key-value pairs. The key is the group name, and the value is the first non-empty variable value within that group.

• Usage example

  For a usage example, see the Conditional Branch component.

Loop

The Loop node repeatedly executes a sub-flow for tasks where each iteration depends on the result of the previous one. The loop terminates when an exit condition is met or the maximum loop count is reached.

• Configuration interface

  

• Input

  • Loop variables: These variables pass data between loop iterations and remain available to downstream nodes after the loop finishes. You can configure multiple loop variables and set their values manually or from the outputs of upstream nodes.

  • Loop exit condition: Configure this based on the loop variables. The loop terminates when a specified loop variable meets the condition.

  • Maximum loop count: This limits the maximum number of loop executions to prevent infinite loops.

• Output

  The node's output is the value of the loop variables after the current loop execution. Loop variables can only be updated by a Variable Assigner node. Without this node, the Loop node's output will always be the same as its initial input, regardless of the number of iterations.

• Related nodes

  Loop-related nodes can only be used inside a loop. Add the following related nodes by clicking the "+" icon to the right of a node within the loop:

  • Break Loop

    Exits the loop. This node is typically preceded by a Conditional Branch node.

  • Variable Assigner

    Assigns the outputs of sub-nodes within the loop to the loop variables.

  

Direct Output

The Direct Output node sends a direct reply based on an output template. You can reference the outputs of upstream nodes using the {{node.variable}} syntax. The node also supports streaming output.

Example: Add a Direct Output node before an LLM node to first send a message to the user.

Batch Processing

The Batch Processing node processes list data in parallel. It runs each list element through the same sub-flow, and parallel execution significantly improves processing efficiency.

{
  "result": [
    "This document is the XX product user manual, covering product features and installation steps...",
    "This contract is for software service procurement with a 12-month term...",
    null,
    "Standard VAT invoice, issued on January 15, 2026..."
  ]
}

End

The End node marks the completion of an Application Flow and defines its output parameters. An Application Flow can only have one End node.

• Output parameter configuration

  The Application Flow's output can reference the outputs from any upstream node. For example, in the following illustration, the answer output of the Application Flow uses the output from the LLM node, while search_results uses the output from a search node.

  

  Note

  • Conversational Application Flows have a default Chat output field, which serves as the conversational output of the flow.

  • An Application Flow must include a Start node and an End node. Only nodes connected between these two nodes are executed. Standalone nodes are not executed.

LLM

The LLM node is the core component for calling a LLM to perform natural language tasks, such as answering questions or processing complex inputs. You can configure model parameters, manage multi-turn conversation history, and customize prompts to optimize the model's response quality and accuracy.

• Use cases

  • Text generation: Generate text content based on a topic or keywords.

  • Classification: Automatically classify email types (e.g., inquiry, complaint, spam).

  • Text translation: Translate text into a specified language.

  • Retrieval-Augmented Generation (RAG): Answer user questions by combining retrieved knowledge.

• Configuration interface

  

• Input

  • Model settings: Supports model services deployed from ModelGallery or other custom deployments, and models from providers like Dashscope and DeepSeek. For better performance, we recommend choosing a more powerful model. You can configure the following model parameters:

    • Temperature: A value between 0 and 1 that controls the randomness of the model's output. A value closer to 0 produces more deterministic and consistent results, while a value closer to 1 yields more random and diverse outcomes.

    • Top P: Controls the diversity of the results. The model samples from the smallest possible set of tokens whose cumulative probability exceeds the threshold P.

    • Top K: Controls the model's output by limiting the number of candidate tokens it can choose from when generating a result. The model will only select from the top K most probable tokens. This method reduces randomness and focuses the output on more likely words. Compared to Top P, Top K more directly limits the number of candidate tokens rather than relying on cumulative probability.

    • Presence penalty: Reduces the model's tendency to repeat the same entities or information. By penalizing content that has already been generated, the model is encouraged to produce new or different information. Higher values apply a greater penalty, reducing the likelihood of repetition.

    • Frequency penalty: Reduces the generation probability of overly frequent words or phrases. As the parameter value increases, a greater penalty is applied to common terms, reducing their frequency and helping to increase lexical diversity.

    • Max tokens: Sets the maximum length of the output that the model can generate in a single call. A lower value may result in shorter or truncated text, while a higher value allows for longer outputs. This helps control the scale and complexity of the generated content.

    • Seed: When a seed value is specified, the model attempts to perform deterministic sampling. Repeated requests with the same seed and parameters should return the same result. However, complete determinism is not guaranteed. Refer to the system_fingerprint response parameter to monitor for potential changes. You may need a proxy to access system_fingerprint.

    • Stop sequences: A list of up to four sequences. When the model encounters one of these sequences, it stops generating tokens. The output does not include the stop sequence.

  • Conversation history: When enabled, the chat history of the Application Flow is automatically inserted into the prompt.

  • Input variables: Variables can reference the outputs of all preceding nodes.

  • Prompt: Customize the content of the SYSTEM, USER, or ASSISTANT prompts. The prompt is a Jinja2 template, and you can reference input variables within the template using double curly braces {{ }}.

• Output

  The node defaults to outputting String data but can be configured to output in JSON format. The JSON type supports adding custom output variables, and the LLM will generate output based on the meaning of the variable names. Future versions plan to add a description field for each variable, allowing the LLM to generate output based on the description's meaning.

• Use cases

  • Build a Q&A Application Flow for finance and healthcare with DeepSeek+RAG based on LangStudio

  • LangStudio & DeepSeek: RAG and web search chatbot solution

Intent recognition

This node is primarily used for flow control. It uses an LLM to recognize the user's intent from their input, then executes the corresponding branch. It supports multi-intent configuration and conversation history.

• Configuration interface

  

• Input

  • User input: Select the user input for intent recognition.

  • Multi-intent configuration: Set up intents as needed. Ensure each intent description is clear and distinct from others. The last intent defaults to "Other," representing cases where no other intent is matched, and cannot be edited.

  • Model settings: Configure the LLM for intent recognition. For better performance, select a powerful model such as qwen-max.

  • Conversation history: When enabled, the model automatically includes the Application Flow's chat history in the prompt during inference.

  • Additional prompt: The content entered here is appended to the system prompt to help the model better perform intent recognition.

• Output

  This node has no output.

• Use case

  When connecting the Intent Recognition node to downstream nodes, each intent branch has a corresponding port on the node. When an intent is recognized, the downstream nodes connected to that branch are executed, while other branch nodes are skipped. You can then use a variable aggregate node to collect the outputs from all branches.

  

Agent

The Agent node is an autonomous agent component developed within the LangStudio Application Flow. This node supports capabilities such as reasoning strategies and tool use. By integrating reasoning strategies (currently supporting FunctionCalling and ReAct), it enables the autonomous calling of Model Context Protocol (MCP) tools. This enables the LLM to dynamically select and execute tools at runtime to perform autonomous, multi-step reasoning.

Document parsing

This node supports using the system's built-in intelligent document parsing tool and the document parsing service from the AI Search Open Platform.

• • Built-in parser: Extracts structured content and metadata from documents. It supports various mainstream document formats, including PDF, DOCX, PPTX, TXT, HTML, CSV, XLSX, XLS, JSONL, and MD.

  • AI Search Open Platform: Provides high-precision structured document parsing, supporting the extraction of logical-level information such as titles and paragraphs, and content like text, tables, and images. This improves the effectiveness and accuracy of document extraction. You must first configure an AI Search Open Platform model service connection. Supported file formats include PDF, DOCX, PPTX, TXT, and HTML.

  The parsed content can be used in downstream nodes for RAG, summarization, and question answering. The configuration interface is as follows:

  

• Document file: Input a single document file for intelligent parsing and extraction of structured content. Select a file-type field from an upstream node.

• Model settings: (Optional) Select an AI Search Open Platform model service connection that has been created in LangStudio. If not configured, the system uses the built-in basic parsing method to process the uploaded file.

• Output results:

  • file_id: The unique identifier of the input file.

  • content: The parsed structured text content, including hierarchical information like titles and paragraphs.

  • status: The parsing status, which can be SUCCESS or FAIL.

  • metadata: The document's metadata and parsing details.

    • file_name: The name of the file.

    • file_type: The type of the file.

    • source_uri: The original URI of the file.

    • download_url: The downloadable URL of the file.

    • analysis_method: The parsing method used. opensearch indicates structured parsing by the AI Search Open Platform, while builtin indicates the use of the built-in basic parsing method.

Downstream usage example: Reference the result fields of the Document parsing node in downstream nodes as needed. To use the document parsing result in an LLM node, you can introduce the parsed content in the user prompt as follows:

Speech recognition

Use the Speech Recognition tool to convert audio or video files into text. It supports multiple audio formats and language recognition.

Knowledge base retrieval

Retrieves relevant text content from a Knowledge Base to be used as context for a downstream LLM node.

• Configuration interface

  

• Input

  • Knowledge base index name: Select a knowledge base that is registered and available in LangStudio. For more details, see Manage knowledge bases.

  • Search keywords: Select the key information you want to retrieve from the knowledge base. This must reference an output parameter from an upstream node in String format.

  • Top K: When the knowledge base index is retrieved, the system returns the top K results that are most relevant to the search keywords.

• Output

  The retrieval output is a variable result of type List[Dict]. The keys in the dictionary include the following fields:

  Key	Description
  content	The content of the retrieved document chunk. This is a text fragment extracted from the knowledge base, typically related to the input query.
  score	The similarity score between the document chunk and the input query. A higher score means stronger relevance.

  The following is an example output, which shows the top K records with the highest scores:

  [
    {
      "score": 0.8057173490524292,
      "content": "Due to pandemic-related uncertainties, XX Bank proactively\nincreased provisions for loan losses and non-credit asset impairments\nbased on economic trends and conditions in the Chinese mainland,\naccelerated disposal of non-performing assets, and enhanced provisioning coverage.\nIn 2020, it achieved a net profit of CNY 28.928 billion, up 2.6% year-on-year,\nwith gradually improving profitability.\n(CNY million) 2020 2019 Change (%)\nOperating Results and Profitability\nOperating Revenue 153,542 137,958 11.3\nPre-Impairment Operating Profit 107,327 95,816 12.0\nNet Profit 28,928 28,195 2.6\nCost-to-Income Ratio(1)(%) 29.11 29.61 Down 0.50\npercentage points\nAverage Total Assets Return (%) 0.69 0.77 Down 0.08\npercentage points\nWeighted Average ROE (%) 9.58 11.30 Down 1.72\npercentage points\nNet Interest Margin(2)(%) 2.53 2.62 Down 0.09\npercentage points\nNote: (1) Cost-to-Income Ratio = Operating and Administrative Expenses / Operating Revenue.",
      "id": "49f04c4cb1d48cbad130647bd0d75f***1cf07c4aeb7a5d9a1f3bda950a6b86e",
      "metadata": {
        "page_label": "40",
        "file_name": "2021-02-04_China XX Insurance Group Co., Ltd._XX_China XX_2020_Annual Report.pdf",
        "file_path": "oss://my-bucket-name/datasets/chatglm-fintech/2021-02-04__China_XX_Insurance_Group_Co.__Ltd.__601318__China_XX__2020__Annual_Report.pdf",
        "file_type": "application/pdf",
        "file_size": 7982999,
        "creation_date": "2024-10-10",
        "last_modified_date": "2024-10-10"
      }
    },
    {
      "score": 0.7708036303520203,
      "content": "7.2 billion, up 5.2% year-on-year.\n2020\n(CNY million) Life &\nHealth Insurance Property\nInsurance Banking Trust Securities Other Asset\nManagement Technology Other\nBusinesses & Consolidation Eliminations Group Total\nNet Profit Attributable to Shareholders 95,018 16,083 16,766 2,476 2,959 5,737 7,936 (3,876) 143,099\nMinority Interest 1,054 76 12,162 3 143 974 1,567 281 16,260\nNet Profit (A) 96,072 16,159 28,928 2,479 3,102 6,711 9,503 (3,595) 159,359\nAdjustments:\n Short-term Investment Fluctuations(1)(B) 10,308 – – – – – – – 10,308\n Discount Rate Impact (C) (7,902) – – – – – – – (7,902)\n One-time Items Excluded by Management\n from Core Operations (D) – – – – – – 1,282 – 1,282\nCore Profit (E=A-B-C-D) 93,666 16,159 28,928 2,479 3,102 6,711 8,221 (3,595) 155,670\nCore Profit Attributable to Shareholders 92,672 16,",
      "id": "8066c16048bd722d030a85ee8b1***36d5f31624b28f1c0c15943855c5ae5c9f",
      "metadata": {
        "page_label": "19",
        "file_name": "2021-02-04_China XX Insurance Group Co., Ltd._XXX_China XX_2020_Annual Report.pdf",
        "file_path": "oss://my-bucket-name/datasets/chatglm-fintech/2021-02-04__China_XX_Insurance_Group_Co.__Ltd.__601318__China_XX__2020__Annual_Report.pdf",
        "file_type": "application/pdf",
        "file_size": 7982999,
        "creation_date": "2024-10-10",
        "last_modified_date": "2024-10-10"
      }
    }
  ]

• Use case

  • Build a DeepSeek+RAG Q&A application flow for finance and healthcare using LangStudio

  • LangStudio and DeepSeek: RAG and web search chatbot solution

Alibaba Cloud IQS - Web Search (IQS-GenericSearch)

Performs a standard search using the Alibaba Cloud Information Query Service (IQS), with support for time range filtering.

• Configuration interface

  

• Input

  • Search keywords: The key information you want to search online. The length must be between 2 and 100 characters. If it exceeds 100 characters, it is truncated. If it is less than 2 characters, an error occurs.

  • Time range: The time range for the search data. Options include NoLimit, OneDay, OneWeek, OneMonth, and OneYear.

  • IQS connection: If a role with the required permissions was not configured at startup, you can select a pre-configured IQS connection. To learn how to configure an IQS connection, see Service connection configuration - Custom connection. Set the key to api_key and its value, which can be found in the Information Query Service - Credential Management. For more details on using an IQS connection, see Build a DeepSeek web search application flow using LangStudio & Alibaba Cloud Information Query Service.

• Output

  • output: The web search output variable, of type List[Dict]. The keys in the dictionary include the following fields:

    Key	Description
    title	The title of the search result, which briefly summarizes the content's topic.
    link	The URL of the search result.
    summary	A summary of the search result, helping users quickly grasp the core information.
    content	The full content of the search result.
    markdown_text	The search content in Markdown format, which may be empty.
    score	A numerical score indicating the relevance or quality of the result.
    publish_time	The publication time of the content.
    host_logo	The logo or icon of the content's source website (image URL).
    hostname	The hostname or domain name of the content's source website.
    site_label	A label or category for the content's source website.

  • scene_items: Supplementary information to enhance search results. In most general searches, scene_items is usually empty. However, in specific scenarios (such as time, weather, or calendar queries), the system may return scene_items to provide more precise and useful information.

• Use case

  Build a DeepSeek web search application flow using LangStudio and Alibaba Cloud Information Query Service

SerpAPI - generic search

Performs a web search using SerpApi. It supports multiple search engines (such as Bing, Google, Baidu, and Yahoo, and custom engines) and allows you to configure the search location and number of results.

• Configuration interface

  

• Input

  • SerpApi connection: Select a SerpApi connection that has been created in LangStudio. For details, see Create SerpApi connection.

  • Search keywords: The key information for the web search. This must reference an output parameter from an upstream node in String format.

  • Search engine: Supports Bing, Google, Baidu, and Yahoo search engines, and custom inputs.

  • Location: The location for the search. If used, it is recommended to be specific (e.g., Shanghai, China).

  • Result count: The number of query results to return.

• Output

  The web search output variable output, of type List[Dict]. The keys in the dictionary include the following fields:

  Key	Description
  title	The title of the search result, which briefly summarizes the content's topic.
  link	The URL of the search result.
  summary	A summary of the search result, helping users quickly grasp the core information.

• Use case

  LangStudio & DeepSeek chatbot solution with RAG and web search

HTTP Request

The HTTP Request node calls external APIs. It supports various HTTP methods, authentication types, and request body formats.

Python development

Application Flows support nodes with custom Python code, enabling complex data processing logic with support for streaming input and output. The configuration interface is as follows:

Simply enter your Python code, and the system automatically parses the inputs and outputs. Note the following:

• The entry point function must be decorated with @tool to be loaded as a node.

• Note

  When a Python node needs to support input streams, it must be configured with @tool(properties={"streaming_pass_through": True}). Otherwise, all inputs to the Python node, such as from an LLM, will be complete text outputs rather than streams.

• Supported input/output types for the function: int, float, bool, str, dict, TypedDict, dataclass (output only), list, and File.

• The system dynamically parses the entry function's input parameters to create the node's inputs. It places the function's return values into an output dictionary, which can be referenced by other nodes.

• Important

  The automatic parsing of a Python node's input and output parameters depends on the runtime. You cannot configure the node's input/output information without a running runtime.

• If your Python code requires dependencies, click Install Dependencies in the upper-right corner of the canvas and enter the package names. The requirements.txt file is saved with the Application Flow, and the system installs the dependencies into the environment when you start the runtime or deploy the service.

  

  

Use case 1: Enter the following code in the code area. The code is mapped to the node's inputs and outputs:

from langstudio.core import tool
from dataclasses import dataclass

@dataclass
class Result:
    output1: str
    output2: int

@tool
def invoke(foo: str, bar: int) -> Result:    
    return Result(
        output1="hello" + foo,
        output2=bar + 10
    )

Use case 2: Streaming input and output. Use a Python node to process the text stream output from an LLM or Agent node, which may contain thought processes. By trimming the <think>\n\n</think> part, you can obtain a clean text output stream of the final result. Example code is as follows:

import re
from typing import Iterator
from langstudio.core import tool

@tool(properties={"streaming_pass_through": True})
def strip_think(
    stream: Iterator[str],
) -> Iterator[str]:  # Input: streaming string iterator; Output: filtered streaming string iterator
    # Match <think>\n...\n</think> structure and capture text after closing tag
    pattern = re.compile(r"<think>\n[\s\S]*\n</think>(.*)")
    in_thinking = True  # Flag indicating if currently inside <think> block
    think_buf = ""      # Buffer for storing unprocessed content

    for chunk in stream:
        if in_thinking:
            think_buf += chunk
            m = pattern.search(think_buf)  # Check if buffer contains complete thinking block
            if m:
                in_thinking = False
                result_part = m.groups()[0]
                if result_part:
                    yield result_part  # Immediately output result text if exists
        else:
            yield chunk  # Directly output all subsequent chunks after exiting thinking block

Template transformation

The Template Transformer tool enables flexible text formatting and data transformation using Jinja2 template syntax.

Dear {{ customer_name }}:

Your order {{ order_id }} has been confirmed. Details:

{% for product in products %}
- {{ product.name }}: ¥{{ product.price }}
{% endfor %}

Total: ¥{{ total }}

Thank you for your purchase!

Dear Zhang San:

Your order ORD-2025-001 has been confirmed. Details:

- Laptop: ¥8999
- Wireless Mouse: ¥199

Total: ¥9198

Thank you for your purchase!

{% for chunk in chunks %}
### Relevance: {{ "%.2f" % chunk.score }}
#### {{ chunk.title }}
{{ chunk.content }}
---
{% endfor %}

### Relevance: 0.95
#### Product Introduction
This is a detailed product description...
---

List Operations

The List Operations tool performs flexible filtering and sorting on list data for fine-grained processing and selection.

Operation 1 - Filter (by file category):
  Filter key: item.category
  Filter operator: equals
  Filter value: image

Operation 2 - Sort (by filename length):
  Sort key: item.file_name
  Sort direction: asc

Operation 3 - Filter (keep top 3):
  Filter key: index
  Filter operator: less than
  Filter value: 3

[
  {"name": "Zhang San", "score": 95, "department": "Technology"},
  {"name": "Li Si", "score": 72, "department": "Marketing"},
  {"name": "Wang Wu", "score": 88, "department": "Technology"},
  {"name": "Zhao Liu", "score": 91, "department": "Product"},
  {"name": "Qian Qi", "score": 65, "department": "Marketing"},
  {"name": "Sun Ba", "score": 98, "department": "Technology"}
]

Operation 1 - Filter (high-scoring users):
  Filter key: item.score
  Filter operator: greater than or equal
  Filter value: 80

Operation 2 - Sort (by score descending):
  Sort key: item.score
  Sort direction: desc

Operation 3 - Filter (top 5):
  Filter key: index
  Filter operator: less than
  Filter value: 5

[
  {"name": "Sun Ba", "score": 98, "department": "Technology"},
  {"name": "Zhang San", "score": 95, "department": "Technology"},
  {"name": "Zhao Liu", "score": 91, "department": "Product"},
  {"name": "Wang Wu", "score": 88, "department": "Technology"}
]