Skip to main content

Processing components

Langflow's processing components process and transform data within a flow. They have many uses, including:

Prompt Template

See Prompt Template.

Batch Run

The Batch Run component runs a language model over each row of one text column in a DataFrame, and then returns a new DataFrame with the original text and an LLM response.

The response contains the following columns:

  • text_input: The original text from the input DataFrame
  • model_response: The model's response for each input
  • batch_index: The 0-indexed processing order for all rows in the DataFrame
  • metadata (optional): Additional information about the processing

Use the Batch Run component in a flow

If you pass this output to a Parser component, you can use variables in the parsing template to reference these keys, such as {text_input} and {model_response}. This is demonstrated in the following example.

A batch run component connected to OpenAI and a Parser

  1. Connect a Language Model component to a Batch Run component's Language model port.

  2. Connect DataFrame output from another component to the Batch Run component's DataFrame input. For example, you could connect a File component with a CSV file.

  3. In the Batch Run component's Column Name field, enter the name of the column in the incoming DataFrame that contains the text to process. For example, if you want to extract text from a name column in a CSV file, enter name in the Column Name field.

  4. Connect the Batch Run component's Batch Results output to a Parser component's DataFrame input.

  5. Optional: In the Batch Run component's header menu, click Controls, enable the System Message parameter, click Close, and then enter an instruction for how you want the LLM to process each cell extracted from the file. For example, Create a business card for each name.

  6. In the Parser component's Template field, enter a template for processing the Batch Run component's new DataFrame columns (text_input, model_response, and batch_index):

    For example, this template uses three columns from the resulting, post-batch DataFrame:


    _10
    record_number: {batch_index}, name: {text_input}, summary: {model_response}

  7. To test the processing, click the Parser component, and then click Run component, and then click Inspect output to view the final DataFrame.

    You can also connect a Chat Output component to the Parser component if you want to see the output in the Playground.

Batch Run parameters

Some Batch Run component input parameters are hidden by default in the visual editor. You can toggle parameters through the Controls in the component's header menu.

NameTypeDescription
modelHandleInputInput parameter. Connect the 'Language Model' output from your LLM component here. Required.
system_messageMultilineInputInput parameter. A multi-line system instruction for all rows in the DataFrame.
dfDataFrameInputInput parameter. The DataFrame whose column is treated as text messages, as specified by 'column_name'. Required.
column_nameMessageTextInputInput parameter. The name of the DataFrame column to treat as text messages. If empty, all columns are formatted in TOML.
output_column_nameMessageTextInputInput parameter. Name of the column where the model's response is stored. Default=model_response.
enable_metadataBoolInputInput parameter. If True, add metadata to the output DataFrame.
batch_resultsDataFrameOutput parameter. A DataFrame with all original columns plus the model's response column.

Data Operations

The Data Operations component performs operations on Data objects, including selecting keys, evaluating literals, combining data, filtering values, appending/updating data, removing keys, and renaming keys.

  1. To use the Data Operations component in a flow, you must connect its Data input port to the output port of a component that outputs Data. All operations in the Data Operations component require at least one Data input.

    For this example, add a Webhook component to the flow, and then connect it to a Data Operations component. Assume you'll send requests to the webhook with a consistent payload that has name, username, and email keys.

  2. In the Operations field, select the operation you want to perform on the incoming Data. For this example, select the Select Keys operation to extract specific user information.

  3. Add keys for name, username, and email to select those values from the incoming request payload.

    To add additional keys, click Add more.

  4. Connect a Chat Output component.

    A flow with Webhook, Data Operations, and Chat Output components

  5. To test the flow, send the following request to your flow's webhook endpoint, and then open the Playground to see the resulting output from processing the payload.


    _26
    curl -X POST "http://$LANGFLOW_SERVER_URL/api/v1/webhook/$FLOW_ID" \
    _26
    -H "Content-Type: application/json" \
    _26
    -H "x-api-key: $LANGFLOW_API_KEY" \
    _26
    -d '{
    _26
    "id": 1,
    _26
    "name": "Leanne Graham",
    _26
    "username": "Bret",
    _26
    "email": "Sincere@april.biz",
    _26
    "address": {
    _26
    "street": "Main Street",
    _26
    "suite": "Apt. 556",
    _26
    "city": "Springfield",
    _26
    "zipcode": "92998-3874",
    _26
    "geo": {
    _26
    "lat": "-37.3159",
    _26
    "lng": "81.1496"
    _26
    }
    _26
    },
    _26
    "phone": "1-770-736-8031 x56442",
    _26
    "website": "hildegard.org",
    _26
    "company": {
    _26
    "name": "Acme-Corp",
    _26
    "catchPhrase": "Multi-layered client-server neural-net",
    _26
    "bs": "harness real-time e-markets"
    _26
    }
    _26
    }'

Data Operations parameters

Some Data Operations component input parameters are hidden by default in the visual editor. You can toggle parameters through the Controls in the component's header menu.

NameDisplay NameInfo
dataDataInput parameter. The Data object to operate on.
operationsOperationsInput parameter. The operation to perform on the data. See Data Operations operations
select_keys_inputSelect KeysInput parameter. A list of keys to select from the data.
filter_keyFilter KeyInput parameter. The key to filter by.
operatorComparison OperatorInput parameter. The operator to apply for comparing values.
filter_valuesFilter ValuesInput parameter. A list of values to filter by.
append_update_dataAppend or UpdateInput parameter. The data to append or update the existing data with.
remove_keys_inputRemove KeysInput parameter. A list of keys to remove from the data.
rename_keys_inputRename KeysInput parameter. A list of keys to rename in the data.
data_outputDataOutput parameter. The resulting Data object after the operation.

Data Operations operations

Options for the operations input parameter are as follows. All operations act on an incoming Data object.

NameRequired InputsProcess
Select Keysselect_keys_inputSelects specific keys from the data.
Literal EvalNoneEvaluates string values as Python literals.
CombineNoneCombines multiple data objects into one.
Filter Valuesfilter_key, filter_values, operatorFilters data based on key-value pair.
Append or Updateappend_update_dataAdds or updates key-value pairs.
Remove Keysremove_keys_inputRemoves specified keys from the data.
Rename Keysrename_keys_inputRenames keys in the data.

DataFrame operations

The DataFrame component performs operations on DataFrame rows and columns.

To use the DataFrame Operations component in a flow, you must connect its DataFrame input port to the output port of a component that outputs DataFrame. All operations in the DataFrame Operations component require at least one DataFrame input.

The following example fetches JSON data from an API. The Smart Filter component extracts and flattens the results into a tabular DataFrame that is then processed through the DataFrame Operations component.

A flow that ingests an API response, extracts it to a DataFrame with a Smart Filter component, and the processes it through a DataFrame Operations component

  1. The API Request component retrieves data with only source and result fields. For this example, the desired data is nested within the result field.
  2. Connect a Smart Filter to the API request component, and a Language model to the Smart Filter. This example connects a Groq model component.
  3. In the Groq model component, add your Groq API key.
  4. To filter the data, in the Smart filter component, in the Instructions field, use natural language to describe how the data should be filtered. For this example, enter:

_10
I want to explode the result column out into a Data object

tip

Avoid punctuation in the Instructions field, as it can cause errors.

  1. To run the flow, in the Smart Filter component, click Run component.
  2. To inspect the filtered data, in the Smart Filter component, click Inspect output. The result is a structured DataFrame.

_10
id | name | company | username | email | address | zip
_10
---|------------------|----------------------|-----------------|------------------------------------|-------------------|-------
_10
1 | Emily Johnson | ABC Corporation | emily_johnson | emily.johnson@abccorporation.com | 123 Main St | 12345
_10
2 | Michael Williams | XYZ Corp | michael_williams| michael.williams@xyzcorp.com | 456 Elm Ave | 67890

  1. Add the DataFrame Operations component, and a Chat Output component to the flow.
  2. In the DataFrame Operations component, in the Operation field, select Filter.
  3. To apply a filter, in the Column Name field, enter a column to filter on. This example filters by name.
  4. Click Playground, and then click Run Flow. The flow extracts the values from the name column.

_10
name
_10
Emily Johnson
_10
Michael Williams
_10
John Smith
_10
...

Operations

This component can perform the following operations on Pandas DataFrame.

OperationRequired InputsInfo
Add Columnnew_column_name, new_column_valueAdds a new column with a constant value.
Drop Columncolumn_nameRemoves a specified column.
Filtercolumn_name, filter_valueFilters rows based on column value.
Headnum_rowsReturns first n rows.
Rename Columncolumn_name, new_column_nameRenames an existing column.
Replace Valuecolumn_name, replace_value, replacement_valueReplaces values in a column.
Select Columnscolumns_to_selectSelects specific columns.
Sortcolumn_name, ascendingSorts DataFrame by column.
Tailnum_rowsReturns last n rows.
Parameters

Inputs

NameDisplay NameInfo
dfDataFrameThe input DataFrame to operate on.
operationOperationThe DataFrame operation to perform. Options include Add Column, Drop Column, Filter, Head, Rename Column, Replace Value, Select Columns, Sort, and Tail.
column_nameColumn NameThe column name to use for the operation.
filter_valueFilter ValueThe value to filter rows by.
ascendingSort AscendingWhether to sort in ascending order.
new_column_nameNew Column NameThe new column name when renaming or adding a column.
new_column_valueNew Column ValueThe value to populate the new column with.
columns_to_selectColumns to SelectA list of column names to select.
num_rowsNumber of RowsThe number of rows to return for head/tail operations. The default is 5.
replace_valueValue to ReplaceThe value to replace in the column.
replacement_valueReplacement ValueThe value to replace with.

Outputs

NameDisplay NameInfo
outputDataFrameThe resulting DataFrame after the operation.

LLM router

This component routes requests to the most appropriate LLM based on OpenRouter model specifications.

The judge LLM analyzed your input message to understand the evaluation context, and then selects the most appropriate model from your LLM pool.

The selected model processes your input and returns the response.

To use the LLM Router component in a flow, do the following:

  1. Connect multiple Language Model components to the LLM Router's Language Models input.

  2. Connect a Judge LLM component to the Judge LLM input.

  3. Connect Chat Input and Chat Output components to the LLM Router. The flow looks like this:

LLM router component

  1. In the LLM Router component, set your Optimization preference:

    • Quality: Prioritizes the highest quality response.
    • Speed: Prioritizes the fastest response time.
    • Cost: Prioritizes the most cost-effective option.
    • Balanced: Strikes a balance between quality, speed, and cost.
  2. Run the flow. Your input is the task that the LLM router evaluates the models against, such as Write a story about horses or How do I parse data objects out of JSON?.

  3. In the LLM Router component, select the Model Selection Decision output to view the router's reasoning.


    _10
    Model Selection Decision:
    _10
    - Selected Model Index: 0
    _10
    - Selected Langflow Model Name: gpt-4o-mini
    _10
    - Selected API Model ID (if resolved): openai/gpt-4o-mini
    _10
    - Optimization Preference: cost
    _10
    - Input Query Length: 27 characters (~5 tokens)
    _10
    - Number of Models Considered: 2
    _10
    - Specifications Source: OpenRouter API

Parameters

Inputs

NameDisplay NameInfo
modelsLanguage ModelsA list of LLMs to route between.
input_valueInputThe input message to be routed.
judge_llmJudge LLMThe LLM that evaluates and selects the most appropriate model.
optimizationOptimizationThe optimization preference between quality, speed, cost, or balanced.

Outputs

NameDisplay NameInfo
outputOutputThe response from the selected model.
selected_modelSelected ModelThe name of the chosen model.

Parser

This component formats DataFrame or Data objects into text using templates, with an option to convert inputs directly to strings using stringify.

To use this component, create variables for values in the template the same way you would in a Prompt component. For DataFrames, use column names, for example Name: {Name}. For Data objects, use {text}.

To use the Parser component with a Structured Output component, do the following:

  1. Connect a Structured Output component's DataFrame output to the Parser component's DataFrame input.
  2. Connect the File component to the Structured Output component's Message input.
  3. Connect the OpenAI model component's Language Model output to the Structured Output component's Language Model input.

The flow looks like this:

A parser component connected to OpenAI and structured output

  1. In the Structured Output component, click Open Table. This opens a pane for structuring your table. The table contains the rows Name, Description, Type, and Multiple.
  2. Create a table that maps to the data you're loading from the File loader. For example, to create a table for employees, you might have the rows id, name, and email, all of type string.
  3. In the Template field of the Parser component, enter a template for parsing the Structured Output component's DataFrame output into structured text. Create variables for values in the template the same way you would in a Prompt component. For example, to present a table of employees in Markdown:

_10
# Employee Profile
_10
## Personal Information
_10
- **Name:** {name}
_10
- **ID:** {id}
_10
- **Email:** {email}

  1. To run the flow, in the Parser component, click Run component.
  2. To view your parsed text, in the Parser component, click Inspect output.
  3. Optionally, connect a Chat Output component, and open the Playground to see the output.

For an additional example of using the Parser component to format a DataFrame from a Structured Output component, see the Market Research template flow.

Parameters

Inputs

NameDisplay NameInfo
modeModeThe tab selection between "Parser" and "Stringify" modes. "Stringify" converts input to a string instead of using a template.
patternTemplateThe template for formatting using variables in curly brackets. For DataFrames, use column names, such as Name: {Name}. For Data objects, use {text}.
input_dataData or DataFrameThe input to parse. Accepts either a DataFrame or Data object.
sepSeparatorThe string used to separate rows or items. The default is a newline.
clean_dataClean DataWhen stringify is enabled, this option cleans data by removing empty rows and lines.

Outputs

NameDisplay NameInfo
parsed_textParsed TextThe resulting formatted text as a Message object.

Python Interpreter

This component allows you to execute Python code with imported packages.

Use the Python Interpreter in a flow

  1. To use this component in a flow,in the Global Imports field, add the packages you want to import as a comma-separated list, such as math,pandas. At least one import is required.
  2. In the Python Code field, enter the Python code you want to execute. Use print() to see the output.
  3. Optionally, enable Tool Mode and connect the interpreter to an Agent as a tool. For example, connect a Python Interpreter and a Calculator as tools for an Agent, and test how it chooses different tools to solve math problems. The flow looks like this: Python Interpreter and calculator connected to Agent
  4. Ask the agent an easier math question. The Calculator tool can add, subtract, multiple, divide, or perform exponentiation. The agent executes the evaluate_expression tool to correctly answer the question.

Result:


_10
Executed evaluate_expression
_10
Input:
_10
{
_10
"expression": "2+5"
_10
}
_10
Output:
_10
{
_10
"result": "7"
_10
}

  1. Give the agent complete Python code. This example creates a Pandas DataFrame table with the imported pandas packages, and returns the square root of the mean squares.

_12
import pandas as pd
_12
import math
_12
_12
# Create a simple DataFrame
_12
df = pd.DataFrame({
_12
'numbers': [1, 2, 3, 4, 5],
_12
'squares': [x**2 for x in range(1, 6)]
_12
})
_12
_12
# Calculate the square root of the mean
_12
result = math.sqrt(df['squares'].mean())
_12
print(f"Square root of mean squares: {result}")

The Agent correctly chooses the run_python_repl tool to solve the problem.

Result:


_12
Executed run_python_repl
_12
_12
Input:
_12
_12
{
_12
"python_code": "import pandas as pd\nimport math\n\n# Create a simple DataFrame\ndf = pd.DataFrame({\n 'numbers': [1, 2, 3, 4, 5],\n 'squares': [x**2 for x in range(1, 6)]\n})\n\n# Calculate the square root of the mean\nresult = math.sqrt(df['squares'].mean())\nprint(f\"Square root of mean squares: {result}\")"
_12
}
_12
Output:
_12
_12
{
_12
"result": "Square root of mean squares: 3.3166247903554"
_12
}

If you don't include the package imports in the chat, the Agent can still create the table using pd.DataFrame, because the pandas package is imported globally by the Python interpreter component in the Global Imports field.

Python Interpreter parameters

NameTypeDescription
global_importsStringInput parameter. A comma-separated list of modules to import globally, such as math,pandas,numpy.
python_codeCodeInput parameter. The Python code to execute. Only modules specified in Global Imports can be used.
resultsDataOutput parameter. The output of the executed Python code, including any printed results or errors.

Save file

This component saves DataFrames, Data, or Messages to various file formats.

  1. To use this component in a flow, connect a component that outputs DataFrames, Data, or Messages to the Save to File component's input. The following example connects a Webhook component to two Save to File components to demonstrate the different outputs.

Two Save-to File components connected to a webhook

  1. In the Save to File component's Input Type field, select the expected input type. This example expects Data from the Webhook.
  2. In the File Format field, select the file type for your saved file. This example uses .md in one Save to File component, and .xlsx in another.
  3. In the File Path field, enter the path for your saved file. This example uses ./output/employees.xlsx and ./output/employees.md to save the files in a directory relative to where Langflow is running. The component accepts both relative and absolute paths, and creates any necessary directories if they don't exist.
tip

If you enter a format in the file_path that is not accepted, the component appends the proper format to the file. For example, if the selected file_format is csv, and you enter file_path as ./output/test.txt, the file is saved as ./output/test.txt.csv so the file is not corrupted.

  1. Send a POST request to the Webhook containing your JSON data. Replace YOUR_FLOW_ID with your flow ID. This example uses the default Langflow server address.

_10
curl -X POST "http://127.0.0.1:7860/api/v1/webhook/YOUR_FLOW_ID" \
_10
-H 'Content-Type: application/json' \
_10
-H 'x-api-key: LANGFLOW_API_KEY' \
_10
-d '{
_10
"Name": ["Alex Cruz", "Kalani Smith", "Noam Johnson"],
_10
"Role": ["Developer", "Designer", "Manager"],
_10
"Department": ["Engineering", "Design", "Management"]
_10
}'

  1. In your local filesystem, open the outputs directory. You should see two files created from the data you've sent: one in .xlsx for structured spreadsheets, and one in Markdown.

_10
| Name | Role | Department |
_10
|:-------------|:----------|:-------------|
_10
| Alex Cruz | Developer | Engineering |
_10
| Kalani Smith | Designer | Design |
_10
| Noam Johnson | Manager | Management |

File input format options

For DataFrame and Data inputs, the component can create:

  • csv
  • excel
  • json
  • markdown
  • pdf

For Message inputs, the component can create:

  • txt
  • json
  • markdown
  • pdf
Parameters

Inputs

NameDisplay NameInfo
input_textInput TextThe text to analyze and extract patterns from.
patternRegex PatternThe regular expression pattern to match in the text.
input_typeInput TypeThe type of input to save.
dfDataFrameThe DataFrame to save.
dataDataThe Data object to save.
messageMessageThe Message to save.
file_formatFile FormatThe file format to save the input in.
file_pathFile PathThe full file path including filename and extension.

Outputs

NameDisplay NameInfo
dataDataA list of extracted matches as Data objects.
textMessageThe extracted matches formatted as a Message object.
confirmationConfirmationThe confirmation message after saving the file.

Smart function

tip

Prior to Langflow 1.5, this component was named the Lambda filter.

This component uses an LLM to generate a function for filtering or transforming structured data.

To use the Smart function component, you must connect it to a Language Model component, which the component uses to generate a function based on the natural language instructions in the Instructions field.

This example gets JSON data from the https://jsonplaceholder.typicode.com/users API endpoint. The Instructions field in the Smart function component specifies the task extract emails. The connected LLM creates a filter based on the instructions, and successfully extracts a list of email addresses from the JSON data.

Smart function connected to an LLM

Parameters

Inputs

NameDisplay NameInfo
dataDataThe structured data to filter or transform using a Lambda function.
llmLanguage ModelThe connection port for a Model component.
filter_instructionInstructionsThe natural language instructions for how to filter or transform the data using a Lambda function, such as Filter the data to only include items where the 'status' is 'active'.
sample_sizeSample SizeFor large datasets, the number of characters to sample from the dataset head and tail.
max_sizeMax SizeThe number of characters for the data to be considered "large", which triggers sampling by the sample_size value.

Outputs

NameDisplay NameInfo
filtered_dataFiltered DataThe filtered or transformed Data object.
dataframeDataFrameThe filtered data as a DataFrame.

Split Text

This component splits text into chunks based on specified criteria. It's ideal for chunking data to be tokenized and embedded into vector databases.

The Split Text component outputs Chunks or DataFrame. The Chunks output returns a list of individual text chunks. The DataFrame output returns a structured data format, with additional text and metadata columns applied.

  1. To use this component in a flow, connect a component that outputs Data or DataFrame to the Split Text component's Data port. This example uses the URL component, which is fetching JSON placeholder data.

Split text component and chroma-db

  1. In the Split Text component, define your data splitting parameters.

This example splits incoming JSON data at the separator },, so each chunk contains one JSON object.

The order of precedence is Separator, then Chunk Size, and then Chunk Overlap. If any segment after separator splitting is longer than chunk_size, it is split again to fit within chunk_size.

After chunk_size, Chunk Overlap is applied between chunks to maintain context.

  1. Connect a Chat Output component to the Split Text component's DataFrame output to view its output.
  2. Click Playground, and then click Run Flow. The output contains a table of JSON objects split at },.

_16
{
_16
"userId": 1,
_16
"id": 1,
_16
"title": "Introduction to Artificial Intelligence",
_16
"body": "Learn the basics of Artificial Intelligence and its applications in various industries.",
_16
"link": "https://example.com/article1",
_16
"comment_count": 8
_16
},
_16
{
_16
"userId": 2,
_16
"id": 2,
_16
"title": "Web Development with React",
_16
"body": "Build modern web applications using React.js and explore its powerful features.",
_16
"link": "https://example.com/article2",
_16
"comment_count": 12
_16
},

  1. Clear the Separator field, and then run the flow again. Instead of JSON objects, the output contains 50-character lines of text with 10 characters of overlap.

_10
First chunk: "title": "Introduction to Artificial Intelligence""
_10
Second chunk: "elligence", "body": "Learn the basics of Artif"
_10
Third chunk: "s of Artificial Intelligence and its applications"

Parameters

Inputs

NameDisplay NameInfo
data_inputsInput DocumentsThe data to split. The component accepts Data or DataFrame objects.
chunk_overlapChunk OverlapThe number of characters to overlap between chunks. Default: 200.
chunk_sizeChunk SizeThe maximum number of characters in each chunk. Default: 1000.
separatorSeparatorThe character to split on. Default: newline.
text_keyText KeyThe key to use for the text column. Default: text.

Outputs

NameDisplay NameInfo
chunksChunksA list of split text chunks as Data objects.
dataframeDataFrameA list of split text chunks as DataFrame objects.

Other text splitters

Structured output

This component transforms LLM responses into structured data formats.

In this example from the Financial Support Parser template, the Structured Output component transforms unstructured financial reports into structured data.

Structured output example

The connected LLM model is prompted by the Structured Output component's Format Instructions parameter to extract structured output from the unstructured text. Format Instructions is utilized as the system prompt for the Structured Output component.

In the Structured Output component, click the Open table button to view the Output Schema table. The Output Schema parameter defines the structure and data types for the model's output using a table with the following fields:

  • Name: The name of the output field.
  • Description: The purpose of the output field.
  • Type: The data type of the output field. The available types are str, int, float, bool, list, or dict. The default is text.
  • Multiple: This feature is deprecated. Currently, it is set to True by default if you expect multiple values for a single field. For example, a list of features is set to True to contain multiple values, such as ["waterproof", "durable", "lightweight"]. Default: True.

The Parse DataFrame component parses the structured output into a template for orderly presentation in chat output. The template receives the values from the output_schema table with curly braces.

For example, the template EBITDA: {EBITDA} , Net Income: {NET_INCOME} , GROSS_PROFIT: {GROSS_PROFIT} presents the extracted values in the Playground as EBITDA: 900 million , Net Income: 500 million , GROSS_PROFIT: 1.2 billion.

Parameters

Inputs

NameTypeDescription
llmLanguageModelThe language model to use to generate the structured output.
input_valueStringThe input message to the language model.
system_promptStringThe instructions to the language model for formatting the output.
schema_nameStringThe name for the output data schema.
output_schemaTableThe structure and data types for the model's output.
multipleBoolean[Deprecated] Always set to True.

Outputs

NameTypeDescription
structured_outputDataThe structured output is a Data object based on the defined schema.

Type convert

This component converts data types between different formats. It can transform data between Data, DataFrame, and Message objects.

  • Data: A structured object that contains both text and metadata.

_10
{
_10
"text": "User Profile",
_10
"data": {
_10
"name": "John Smith",
_10
"age": 30,
_10
"email": "john@example.com"
_10
}
_10
}

  • DataFrame: A tabular data structure with rows and columns. Keys are columns, and each dictionary (a collection of key-value pairs) in the list is a row.

_12
[
_12
{
_12
"name": "John Smith",
_12
"age": 30,
_12
"email": "john@example.com"
_12
},
_12
{
_12
"name": "Jane Doe",
_12
"age": 25,
_12
"email": "jane@example.com"
_12
}
_12
]

  • Message: A string, such as"Name: John Smith, Age: 30, Email: john@example.com".

To use this component in a flow, do the following:

  1. Add the Web search component to the Basic prompting flow. In the Search Query field, enter a query, such as environmental news.
  2. Connect the Web search component's output to a component that accepts the DataFrame input. This example uses a Prompt component to give the chatbot context, so you must convert the Web search component's DataFrame output to a Message type.
  3. Connect a Type Convert component to convert the DataFrame to a Message.
  4. In the Type Convert component, in the Output Type field, select Message. Your flow looks like this:

Type convert web search output to chat

  1. In the Language Model component, in the OpenAI API Key field, add your OpenAI API key.
  2. Click Playground, and then ask about latest news.

The search results are returned to the Playground as a message.

Result:


_10
Latest news
_10
AI
_10
gpt-4o-mini
_10
Here are some of the latest news articles related to the environment:
_10
Ozone Pollution and Global Warming: A recent study highlights that ozone pollution is a significant global environmental concern, threatening human health and crop production while exacerbating global warming. Read more
_10
...

Parameters

Inputs

NameDisplay NameInfo
input_dataInput DataThe data to convert. Accepts Data, DataFrame, or Message objects.
output_typeOutput TypeThe desired output type. Options: Data, DataFrame, or Message.

Outputs

NameDisplay NameInfo
outputOutputThe converted data in the specified format.

Legacy processing components

The following processing components are legacy components. You can still use them in your flows, but they are no longer supported and can be removed in a future release.

Replace these components with suggested alternatives as soon as possible.

Alter Metadata

Replace this legacy component with the Data Operations component.

This component modifies metadata of input objects. It can add new metadata, update existing metadata, and remove specified metadata fields. The component works with both Message and Data objects, and can also create a new Data object from user-provided text.

It accepts the following parameters:

NameDisplay NameInfo
input_valueInputInput parameter. Objects to which Metadata should be added.
text_inUser TextInput parameter. Text input; the value is contained in the 'text' attribute of the Data object. Empty text entries are ignored.
metadataMetadataInput parameter. Metadata to add to each object.
remove_fieldsFields to RemoveInput parameter. Metadata fields to remove.
dataDataOutput parameter. List of Input objects, each with added metadata.
Combine Data/Merge Data

Replace this legacy component with the Data Operations component or the Loop component.

This component combines multiple data sources into a single unified Data object.

The component iterates through a list of Data objects, merging them into a single Data object (merged_data). If the input list is empty, it returns an empty data object. If there's only one input data object, it returns that object unchanged.

The merging process uses the addition operator to combine data objects.

Combine Text

Replace this legacy component with the Data Operations component.

This component concatenates two text inputs into a single text chunk using a specified delimiter, outputting a Message object with the combined text.

Create Data

Replace this legacy component with the Data Operations component.

This component dynamically creates a Data object with a specified number of fields and a text key.

It accepts the following parameters:

NameDisplay NameInfo
number_of_fieldsNumber of FieldsInput parameter. The number of fields to be added to the record.
text_keyText KeyInput parameter. Key that identifies the field to be used as the text content.
text_key_validatorText Key ValidatorInput parameter. If enabled, checks if the given Text Key is present in the given Data.
Extract Key

Replace this legacy component with the Data Operations component.

This component extracts a specific key from a Data object and returns the value associated with that key.

Data to DataFrame/Data to Message

Replace these legacy components with newer processing components, such as the Data Operations component and Type Convert component.

These components converted one or more Data objects into a DataFrame or Message object.

For the Data to DataFrame component, each Data object corresponds to one row in the resulting DataFrame. Fields from the .data attribute become columns, and the .text field (if present) is placed in a text column.

Filter Data

Replace this legacy component with the Data Operations component.

This component filters a Data object based on a list of keys (filter_criteria), returning a new Data object (filtered_data) that contains only the key-value pairs that match the filter criteria.

Filter Values

Replace this legacy component with the Data Operations component.

The Filter values component filters a list of data items based on a specified key, filter value, and comparison operator.

It accepts the following parameters:

NameDisplay NameInfo
input_dataInput dataInput parameter. The list of data items to filter.
filter_keyFilter KeyInput parameter. The key to filter on.
filter_valueFilter ValueInput parameter. The value to filter by.
operatorComparison OperatorInput parameter. The operator to apply for comparing the values.
filtered_dataFiltered dataOutput parameter. The resulting list of filtered data items.
JSON Cleaner

Replace this legacy component with the Parser component.

This component cleans JSON strings to ensure they are fully compliant with the JSON specification.

It accepts the following parameters:

NameDisplay NameInfo
json_strJSON StringInput parameter. The JSON string to be cleaned. This can be a raw, potentially malformed JSON string produced by language models or other sources that may not fully comply with JSON specifications.
remove_control_charsRemove Control CharactersInput parameter. If set to True, this option removes control characters (ASCII characters 0-31 and 127) from the JSON string. This can help eliminate invisible characters that might cause parsing issues or make the JSON invalid.
normalize_unicodeNormalize UnicodeInput parameter. When enabled, this option normalizes Unicode characters in the JSON string to their canonical composition form (NFC). This ensures consistent representation of Unicode characters across different systems and prevents potential issues with character encoding.
validate_jsonValidate JSONInput parameter. If set to True, this option attempts to parse the JSON string to ensure it is well-formed before applying the final repair operation. It raises a ValueError if the JSON is invalid, allowing for early detection of major structural issues in the JSON.
outputCleaned JSON StringOutput parameter. The resulting cleaned, repaired, and validated JSON string that fully complies with the JSON specification.
Message to Data

Replace this legacy component with the Type Convert component.

This component converts Message objects to Data objects.

Parse DataFrame

Replace this legacy component with the DataFrame Operations component or Parser component.

This component converts DataFrame objects into plain text using templates.

It accepts the following parameters:

NameDisplay NameInfo
dfDataFrameInput parameter. The DataFrame to convert to text rows.
templateTemplateInput parameter. Template for formatting (use {column_name} placeholders).
sepSeparatorInput parameter. String to join rows in output.
textTextOutput parameter. All rows combined into single text.
Parse JSON

Replace this legacy component with the Parser component.

This component converts and extracts JSON fields in Message and Data objects using JQ queries, then returns filtered_data, which is a list of Data objects.

Python REPL

Replace this legacy component with the Python Interpreter component or another processing or logic component.

This component creates a Python REPL (Read-Eval-Print Loop) tool for executing Python code.

It accepts the following parameters:

NameTypeDescription
nameStringInput parameter. The name of the tool. Default: python_repl.
descriptionStringInput parameter. A description of the tool's functionality.
global_importsList[String]Input parameter. A list of modules to import globally. Default: math.
toolToolOutput parameter. A Python REPL tool for use in LangChain.
Python Code Structured

Replace this legacy component with the Python Interpreter component or another processing or logic component.

This component creates a structured tool from Python code using a dataclass.

The component dynamically updates its configuration based on the provided Python code, allowing for custom function arguments and descriptions.

It accepts the following parameters:

NameTypeDescription
tool_codeStringInput parameter. The Python code for the tool's dataclass.
tool_nameStringInput parameter. The name of the tool.
tool_descriptionStringInput parameter. The description of the tool.
return_directBooleanInput parameter. Whether to return the function output directly.
tool_functionStringInput parameter. The selected function for the tool.
global_variablesDictInput parameter. Global variables or data for the tool.
result_toolToolOutput parameter. A structured tool created from the Python code.
Regex Extractor

Replace this legacy component with the Parser component.

This component extracts patterns in text using regular expressions. It can be used to find and extract specific patterns or information in text.

Select Data

Replace this legacy component with the Data Operations component.

This component selects a single Data object from a list.

It accepts the following parameters:

NameDisplay NameInfo
data_listData ListInput parameter. List of data to select from
data_indexData IndexInput parameter. Index of the data to select
selected_dataSelected DataOutput parameter. The selected Data object.
Update Data

Replace this legacy component with the Data Operations component.

This component dynamically updates or appends data with specified fields.

It accepts the following parameters:

NameDisplay NameInfo
old_dataDataInput parameter. The records to update.
number_of_fieldsNumber of FieldsInput parameter. The number of fields to add. The maximum is 15.
text_keyText KeyInput parameter. The key for text content.
text_key_validatorText Key ValidatorInput parameter. Validates the text key presence.
dataDataOutput parameter. The updated Data objects.
Search