Summarize Content

Audience: Low-code Engineers

Skill Prerequisites: Tokens, Connectors

Sends text to OpenAI, or to OpenAI on Microsoft Azure, and saves the summary it returns in a token. You choose how detailed the summary is, or write your own instructions.

Long text can be cut to fit the model (Truncate), or split into chunks that are summarized one by one and then joined (Split).

note

This action is part of the AI add-on (PlantAnApp.OpenAi). The add-on is installed separately and needs the AI feature in your license. If it isn't licensed, the action fails with an "AI package is unlicensed" error. If you don't see the OpenAi actions, the add-on isn't installed.

Typical Use Cases

• Summarize a support ticket, email thread or meeting transcript before saving it or emailing it
• Shorten a long document to a paragraph for a listing or a notification
• Summarize a transcript created by Speech to Text (Whisper)
• Pull the key facts out of a document with your own instructions

Don't use it to

• Have a conversation or answer questions about content. Use Chat instead.
• Turn one long document into several separate articles. Use Create Articles instead.
• Summarize with Amazon Bedrock or Google Vertex AI models. This action only supports OpenAI and Azure OpenAI. Use AWS AI Chat or VertexAI Chat with summary instructions.
• Process text you're not allowed to send to a third party. See Considerations.

Related Actions

Action Name	Description
Chat	Sends messages to OpenAI and returns the response.
Create Articles	Splits long content into topics and writes an article for each.
Count Tokens	Counts the AI model tokens in a text, to check its size before you send it.
Speech to Text (Whisper)	Turns an audio file into text you can summarize.
Add Connector	Creates a connector, for example an OpenAI connector, from actions.
Test Connector	Checks that a connector works.

Input Parameter Reference

Parameter	Description	Supports Tokens	Default	Required
Provider	The AI service: OpenAI or Azure (Azure OpenAI). It decides which connector parameter is shown.	No	OpenAI	Yes
OpenAI Connector	OpenAI only. The OpenAI connector that holds your API key. See Connectors.	No	none selected	Yes
Azure Connector	Azure only. The Microsoft Azure OpenAI connector that holds your resource name and API key.	No	none selected	Yes
Deployment Id	Azure only. The name of your model deployment in Azure. You need to deploy a model in Azure before you can use it.	Yes	empty string	Yes
Model	The model, for example gpt-4o or gpt-4. The list comes from the OpenAI models known to PAA. The model's context window sets how much text fits in one request. With Azure, pick the model your deployment runs, so the size limits are right.	Yes	none selected	Yes
Content	The text to summarize, for example [TicketHistory].	Yes	empty string	Yes
Large Content Strategy	What to do when the content is too big for one request. Truncate cuts it. Split summarizes it in chunks, which makes more requests and costs more. See How long content is handled.	Yes	none selected	Yes
Detail Level	How detailed the summary is: Brief, Normal, Detailed or Custom Instructions. See Detail Level.	Yes	none selected	Yes
Instructions	Custom Instructions only. Your own instructions for the model, for example List the customer's problem, the fix and any follow-up actions as bullet points. They replace the built-in instructions.	Yes	empty string	No
Concatenation Instructions	Split only. The instructions used to join the chunk summaries into the final summary.	Yes	See How long content is handled	No
Temperature	How random the output is, from 0 to 2, for example 0.3. Lower values give more focused, repeatable results.	No	0	No
Maximum Length	The most tokens the model can write in each response. Leave empty to use the provider's default.	No	empty	No
Resource ID	A label saved with the usage record, so you can tell where AI usage came from, for example Support/Ticket/[TicketId]/summary.	Yes	empty string	No
Ignore Errors	When on, an error doesn't stop the actions that follow. The error is written to the site's event log. On Error still runs.	No	Off	No
On Error	Actions that run when this action fails. See Errors.	No	empty	No

Output Parameters Reference

Parameter	Description
Store Summary	Token that receives the summary text, for example Summary.
Store Chunk Count	Token that receives the number of chunks the content was split into. It's 1 when the content wasn't split. If the chunk summaries had to be split again, it's the count from the last round.
Store Chunks - JSON	Split only. Token that receives a JSON array with each chunk's request messages (Prompt) and its summary (Response). Only set when the content was split into more than one chunk.
Store JSON Response	Token that receives the raw JSON response from the provider. With Split, it's the response of the last request.
Store Usage ID	Token that receives the ID of the AI usage record for this run.

Store Summary and Store JSON Response are both marked as required in the action editor. The action only needs one of them. If both are empty, it fails with "There are no output tokens configured to store summarization result."

Detail Level

Each detail level sends fixed instructions to the model as the system message. The content is sent as the user message.

Detail Level	Instructions sent to the model
Brief	You are an assistant that creates brief summaries. Return just the summary.
Normal	You are an assistant that creates rich summaries. Make sure to capture all ideas that are not considered public knowledge. Return just the summary.
Detailed	You are an assistant that creates structured, detailed and accurate descriptions from content. Make sure to capture details of all ideas, and capture extra details when the content is likely not public knowledge. Skip mentioning conclusions.
Custom Instructions	The text in Instructions.

In expression mode, use the values brief, regular (Normal), detailed or custom.

How long content is handled

The action works out how many tokens fit in one request: 60% of the model's context window, minus the tokens used by the instructions. For example, that's about 76,000 tokens for gpt-4o and about 4,900 for gpt-4. If the model isn't known to PAA, a context window of 8,192 is used for names starting with gpt-4, and 4,096 for anything else.

• Truncate. Content over the limit is cut at the limit. Anything after it is ignored. One request is made.
• Split. The content is split into chunks that fit the limit. Chunks overlap by about 100 tokens, and they end at a space or punctuation mark. Each chunk is summarized separately with the detail level's instructions. If there's more than one chunk, the chunk summaries are joined and summarized again with the Concatenation Instructions. If the joined summaries are still too long, they're split and summarized again first.

Chunk sizes are estimated at 4 characters per token, so chunks can be a bit bigger or smaller than the limit.

The default Concatenation Instructions are:

Here are several chunks of summaries extracted from the same base content but split into various parts. Concatenate these chunks maintaining the proper sequence as per the information provided, which may be aided by timestamps. When you encounter similar titles, group those sections together in the correct order.

Errors

If the action fails, the On Error actions run with these tokens:

Token	Value
[ErrorMessage]	The error message. For provider errors, the message returned by OpenAI or Azure.
[ErrorCode]	The HTTP status code returned by the provider. Empty for other errors.
[ErrorJson]	The provider's error response as JSON. Empty for other errors.

These tokens are removed after On Error finishes. Unless Ignore Errors is on, the action then fails.

When the provider responds with "Too Many Requests" (a rate limit), the action waits 20 seconds and tries again, with no limit on retries. Request timeouts are also retried.

Considerations

• Your content is sent to OpenAI or Microsoft. Everything in Content leaves your server and is processed by the provider under your account's terms. Don't send personal, confidential or regulated data unless your agreement with the provider allows it.
• Costs. Each request is billed by the provider. With Split, long content means many requests, plus the final joining request. Use Count Tokens to check the size first.
• Truncate loses content. The end of long content isn't summarized, and there's no warning. Use Split if the whole text matters.
• Set the Detail Level and Large Content Strategy. If Large Content Strategy isn't Truncate or Split, the action fails with "Invalid Large Content Strategy". If Detail Level is empty, the action can fail with an "Object reference not set" error.
• Empty content fails. If Content is empty, the action fails with "Text and model name must not be null or empty." Add a condition such as "[Content]" != "".
• Maximum Length applies to each request. With Split, it limits each chunk summary and the final summary.
• Usage tracking. PAA records the tokens used by each run. Use Resource ID to label where the usage came from, and Store Usage ID to keep the record's ID.
• Connectors. Create the OpenAI or Azure OpenAI connector first. See Connectors, Add Connector and Test Connector.

Examples

tip

To understand how to use the below examples, please see Running Examples.

After importing an example, select your connector in the action. The connector ID in the JSON is a placeholder.

1. Summarize a support ticket

This action creates a brief summary of the TicketHistory token with gpt-4o, and saves it in the TicketSummary token. Long histories are cut to fit.

{
    "Title": "Summarize Content",
    "ActionType": "OpenAi.SummarizeContent",
    "Description": "Summarize the ticket history",
    "Condition": "\"[TicketHistory]\" != \"\"",
    "Parameters": {
        "Provider": "openAi",
        "OpenAiConnector": {
            "Entry": "00000000-0000-0000-0000-000000000000"
        },
        "Model": {
            "Expression": "",
            "Value": "gpt-4o",
            "IsExpression": false,
            "Parameters": {}
        },
        "Content": "[TicketHistory]",
        "LargeContentStrategy": {
            "Expression": "",
            "Value": "Truncate",
            "IsExpression": false,
            "Parameters": {}
        },
        "DetailLevel": {
            "Expression": "",
            "Value": "brief",
            "IsExpression": false,
            "Parameters": {}
        },
        "ResourceId": "Support/Ticket/[TicketId]/summary",
        "StoreSummary": "TicketSummary",
        "StoreJsonResponse": "",
        "StoreUsageId": "SummaryUsageId"
    }
}

2. Summarize a long transcript with custom instructions

This action splits a meeting transcript into chunks, summarizes each one with custom instructions, and joins them into one summary. The number of chunks is saved in ChunkCount, so you can see how many requests were made.

{
    "Title": "Summarize Content",
    "ActionType": "OpenAi.SummarizeContent",
    "Description": "Summarize the meeting transcript",
    "Parameters": {
        "Provider": "openAi",
        "OpenAiConnector": {
            "Entry": "00000000-0000-0000-0000-000000000000"
        },
        "Model": {
            "Expression": "",
            "Value": "gpt-4o",
            "IsExpression": false,
            "Parameters": {}
        },
        "Content": "[Transcript]",
        "LargeContentStrategy": {
            "Expression": "",
            "Value": "Split",
            "IsExpression": false,
            "Parameters": {}
        },
        "DetailLevel": {
            "Expression": "",
            "Value": "custom",
            "IsExpression": false,
            "Parameters": {}
        },
        "Instructions": "Summarize this meeting transcript. List the decisions made and the action items, with the owner of each item.",
        "ConcatenationInstructions": "Here are summaries of consecutive parts of one meeting. Combine them into one list of decisions and one list of action items, in the order they were discussed. Remove duplicates.",
        "Temperature": 0.2,
        "StoreSummary": "MeetingSummary",
        "StoreChunkCount": "ChunkCount",
        "StoreJsonResponse": ""
    }
}

Revised 09/27/2026