a!callLanguageModel() Function

Function

a!callLanguageModel( prompt, messages, isStreaming )

Allows users to call the Appian provided default language model.

The a!callLanguageModel() function allows you to call the Appian-provided default language model. You can use this function independently to process AI responses in your expressions, or pair it with the Chat component to build conversational AI experiences for end users.

This function can be used in multiple contexts:

• In an interface: Use it within the saveInto parameter of an a!chatField() component to build interactive chat experiences for end users.
• In a process model: Use it in a script task to generate AI responses as part of automated workflows.
• In an expression rule: Use it anywhere you need to call a language model and process the response programmatically, without requiring a chat interface.

Function behavior

The function operates in two modes depending on the isStreaming parameter:

Non-streaming mode (default): The function waits for the complete response from the language model and returns the full message text.

Streaming mode: When isStreaming is set to true, the function executes asynchronously in the background. Instead of waiting for the complete response, it immediately returns results to the a!chatField() component in real-time.

Parameters

Considerations

• This function uses the Appian-provided default AI model. If you want to use your own AI model, see the Use the chat component with your preferred AI mode topic on the Chat Component page.
• In streaming mode, the function executes asynchronously and provides real-time updates to the chat interface.
• Use streaming mode for better user experience in chat interfaces, as responses appear progressively rather than all at once.
• Streaming functionality is automatically handled by the a!chatField() component when used together.
• You can also use this function in a process model via a script task.
• When AI Guardrails are enabled and a Block action triggers, the function returns the administrator-configured block message as the response text (non-streaming mode). Developers can check whether the response is a guardrail block message and handle it accordingly in their application logic.

Example

This example shows how to use a!callLanguageModel with the saveInto parameter in aa!chatField.

When a user sends a message, the message is added to the local!messages variable. Then, a!callLanguageModel runs with the full message history as context. The AI model's response is saved to local!modelResponse and added to the local!messages list, which updates the interface with the new response.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
a!localVariables(
  local!messages: {},
  local!roles: {},
  local!modelResponse: "",
  a!chatField(
    title: "Chat",
    messages: a!forEach(
      local!messages,
      a!chatMessage(
        messageContent: fv!item,
        role: local!roles[fv!index]
      )
    ),
    placeholder: "Ask a question...",
    saveInto: {
      /* 1. Append the user's message */
      a!save(local!messages, append(local!messages, save!value)),
      a!save(local!roles, append(local!roles, "USER")),
      /* 2. Call the language model */
      a!save(
        local!modelResponse,
        a!callLanguageModel(
          messages: a!forEach(
            local!messages,
            a!map(
              messageContent: fv!item,
              role: local!roles[fv!index]
            )
          ),
          prompt: "You are a helpful assistant."
        )
      ),
      /* 3. Append the model's response */
      a!save(local!messages, append(local!messages, local!modelResponse)),
      a!save(local!roles, append(local!roles, "ASSISTANT"))
    }
  )
)

Feature compatibility

Feedback