How to Use Advanced Prompting Techniques#

Download Python Script

Python script/notebook for this guide.

Prerequisites

This guide assumes familiarity with:

LLMs
Agent

PromptTemplate is a powerful way to configure how to prompt various LLMs. Although WayFlow has very good defaults for most tasks and LLM providers, some specific use cases or providers require adapting prompt formatting to improve efficiency (e.g., token cost) or performance. To address this, WayFlow introduces the concept of PromptTemplate, which enables you to define prompts in a very generic way, applicable across different scenarios.

This guide will show you how to:

Recap how to use variables in prompts
Learn how to configure a custom PromptTemplate
Learn how to configure a prompt template for an Agent
Learn best practices for writing prompts

Basics of prompting#

WayFlow leverages LLMs to perform chat completion, meaning that given a list of messages (which can be system (for instructions to the LLM), agent (a message generated by the LLM), and user (a message from the user)), it returns a new message.

To perform agentic tasks, LLMs are equipped with tools, which are defined functions with names and arguments that the LLM may decide to call. Prompting the LLM to generate such calls can be done using native_tool_calling, where the LLM provider handles how tools are presented to the model and how tool calls are parsed, or through custom tool calling, where the presentation of tools to the model is controlled externally and the raw text output from the model must be parsed manually.

In many use cases, generating raw text is not enough because it is difficult to use in further pipeline steps. LLMs can produce specific structured output, often through structured_generation. Most LLM providers support this feature natively (the provider takes care of formatting the expected response and parsing the LLM output), but you can also do it in a custom way, using a specific prompt combined with custom parsing.

The PromptTemplate abstraction is designed so that configuring all these parameters is as simple as possible, while guaranteeing maximum customization. Using PromptTemplate usually involves 3 steps:

Create the basic template. This is done using either the constructor (PromptTemplate()) or the helper function from a string (PromptTemplate.from_string()).
Equip the template with partial values, tools, or response_format. This can be done dynamically, and is useful when these elements are unknown at template creation but can be reused across multiple generations.
Render the template: use template.format() to fill all variables and create a Prompt object, which can then be passed to an LLM (e.g., llm.generate(prompt)). This object contains all the information needed for the LLM generation.

Configure the LLM#

WayFlow supports several LLM API providers. Select an LLM from the options below:

from wayflowcore.models import OCIGenAIModel

if __name__ == "__main__":

    llm = OCIGenAIModel(
        model_id="provider.model-id",
        service_endpoint="https://url-to-service-endpoint.com",
        compartment_id="compartment-id",
        auth_type="API_KEY",
    )

from wayflowcore.models import VllmModel

llm = VllmModel(
    model_id="model-id",
    host_port="VLLM_HOST_PORT",
)

from wayflowcore.models import OllamaModel

llm = OllamaModel(
    model_id="model-id",
)

Basic text prompt with Regex parsing#

One possible use case is prompting an LLM and extracting some information from the raw text output. This is especially relevant in a prompt template, since the parsing method highly depends on how the LLM is prompted in the first place.

The example below shows how to write a simple Chain-of-Thoughts prompt. The RegexOutputParser is used to configure how output is extracted from the raw text.

import re

from wayflowcore.outputparser import JsonOutputParser, RegexOutputParser, RegexPattern
from wayflowcore.templates import PromptTemplate

prompt_template = PromptTemplate.from_string(
    template="What is the result of 100+(454-3). Think step by step and then give your answer between <result>...</result> delimiters",
    output_parser=RegexOutputParser(
        regex_pattern=RegexPattern(pattern=r"<result>(.*)</result>", flags=re.DOTALL)
    ),
)
prompt = prompt_template.format()  # no inputs needed since the template has no variable
result = llm.generate(prompt).message.content
print(result)
# 551

API reference: PromptTemplate, RegexOutputParser, RegexPattern, JsonOutputParser.

Prompt with chat history#

In many cases—especially when working with agents—it is necessary to format a list of messages within a prompt. There are two ways to achieve this. Assume a list of messages is available:

from wayflowcore.messagelist import Message, MessageType

messages = [
    Message(content="What is the capital of Switzerland?", message_type=MessageType.USER),
    Message(content="The capital of Switzerland is Bern?", message_type=MessageType.AGENT),
    Message(content="Really? I thought it was Zurich?", message_type=MessageType.USER),
]

The first way is to integrate the history of messages directly into the prompt’s list of messages. This helps the model by presenting the entire conversation as a single context. For example, to format the conversation as messages within a template, you can use the CHAT_HISTORY_PLACEHOLDER:

prompt_template = PromptTemplate(
    messages=[
        {"role": "system", "content": "You are a helpful assistant. Answer the user questions"},
        PromptTemplate.CHAT_HISTORY_PLACEHOLDER,
    ]
)

prompt = prompt_template.format(inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: messages})
print(prompt.messages)
# [
#   Message(content='You are a helpful assistant. Answer the user questions', message_type=MessageType.SYSTEM),
#   Message(content='What is the capital of Switzerland?', message_type=MessageType.USER),
#   Message(content='The capital of Switzerland is Bern?', message_type=MessageType.AGENT),
#   Message(content='Really? I thought it was Zurich?', message_type=MessageType.USER)
# ]
result = llm.generate(prompt).message.content
print(result)
# While Zurich is a major city in Switzerland and home to many international organizations, the capital is indeed Bern (also known as Berne).

You can also format the chat history directly in a message, by using the CHAT_HISTORY_PLACEHOLDER_NAME placeholder (whose underlying value is the string "__CHAT_HISTORY__" as shown in the code snippet below):

prompt_text = """You are a helpful assistant. Answer the user questions.
For context, the conversation was:
{% for msg in __CHAT_HISTORY__ %}
{{ msg.message_type.value }} >> {{msg.content}}
{%- endfor %}

Just answer the user question.
"""
prompt_template = PromptTemplate(messages=[{"role": "system", "content": prompt_text}])

prompt = prompt_template.format(inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: messages})
print(prompt.messages)
# [Message(content="""You are a helpful assistant. Answer the user questions.
# For context, the conversation was:
#
# USER >> What is the capital of Switzerland?
# AGENT >> The capital of Switzerland is Bern?
# USER >> Really? I thought it was Zurich?
#
# Just answer the user question.""", message_type=MessageType.SYSTEM]
result = llm.generate(prompt).message.content
print(result)
# While Zurich is a major city and financial hub in Switzerland, the capital is indeed Bern.

If you need to filter some part of the chat history before rendering it in the template, you may use some pre-rendering message transforms:

from typing import List
from wayflowcore.transforms import MessageTransform

class OnlyLastChatMessageTransform(MessageTransform):
    def __call__(self, messages: List[Message]) -> List[Message]:
        if len(messages) == 0:
            return []
        return [messages[-1]]

prompt_template = PromptTemplate(
    messages=[
        {"role": "system", "content": "You are a helpful assistant. Answer the user questions"},
        PromptTemplate.CHAT_HISTORY_PLACEHOLDER,
    ],
    pre_rendering_transforms=[OnlyLastChatMessageTransform()],
)
prompt = prompt_template.format(inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: messages})
print(prompt.messages)
# [
#   Message(content='You are a helpful assistant. Answer the user questions', message_type=MessageType.SYSTEM),
#   Message(content='Really? I thought it was Zurich?', message_type=MessageType.USER)
# ]

API reference: MessageTransform.

This will ensure only the last chat history message is formatted in the prompt.

Configure how to use tools in templates#

Assume a tool is available and should be used for LLM generation.

from typing import Annotated
from wayflowcore.tools import tool

@tool
def some_tool(param1: Annotated[str, "name of the user"]) -> Annotated[str, "tool_output"]:
    """Performs some action"""
    return "some_tool_output"

If the LLM provider supports native_tool_calling, integrating it into templates is straightforward:

template = PromptTemplate(
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        PromptTemplate.CHAT_HISTORY_PLACEHOLDER,
    ],
)
template = template.with_tools([some_tool])
prompt = template.format(
    inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: [Message("call the some_output tool")]}
)
print(prompt.tools)
# [ServerTool()]
response = llm.generate(prompt).message
print(response)
# Message(content='', message_type=<MessageType.TOOL_REQUEST, tool_requests=[ToolRequest(name='some_output', args={'param1': 'call the some_output tool'}, tool_request_id='chatcmpl-tool-ae924a4829324411add8760d3ae265bd')])

In this case, the template uses native tool calling, so the prompt includes separate tools that are passed to the LLM endpoint. The provider directly parses the output and returns a ToolRequest.

Sometimes, the provider’s native tool calling might not be available or may not work as needed (for example, when performing Chain-of-Thought reasoning with Llama native models, which do not support this feature). In such cases, tool calling can be configured directly within the prompt template.

from wayflowcore.models.llmgenerationconfig import LlmGenerationConfig
from wayflowcore.templates.reacttemplates import (
    REACT_SYSTEM_TEMPLATE,
    ReactToolOutputParser,
    _ReactMergeToolRequestAndCallsTransform,
)
from wayflowcore.transforms import (
    CoalesceSystemMessagesTransform,
    RemoveEmptyNonUserMessageTransform,
)

REACT_CHAT_TEMPLATE = PromptTemplate(
    messages=[
        {"role": "system", "content": REACT_SYSTEM_TEMPLATE},
        PromptTemplate.CHAT_HISTORY_PLACEHOLDER,
    ],
    native_tool_calling=False,
    post_rendering_transforms=[
        _ReactMergeToolRequestAndCallsTransform(),
        CoalesceSystemMessagesTransform(),
        RemoveEmptyNonUserMessageTransform(),
    ],
    output_parser=ReactToolOutputParser(),
    generation_config=LlmGenerationConfig(stop=["## Observation"]),
)
template = REACT_CHAT_TEMPLATE.with_tools([some_tool])
prompt = template.format(
    inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: [Message("call the some_output tool")]}
)
print(prompt.tools)
# [ServerTool()]
response = llm.generate(prompt).message
print(response)
# Message(content='', message_type=MessageType.TOOL_REQUEST, tool_requests=[ToolRequest(name='some_tool', args={'param1': 'call the some_output tool'}, tool_request_id='chatcmpl-tool-69c7e27e55474501be0dfc2509e5d4f2')]

For custom tool calling, the important parameters to configure are:

native_tool_calling indicates that the tools will be formatted in the prompt. This requires the __TOOLS__ placeholder in one of the messages.
post_rendering_transforms: transformations applied to messages just before passing them to the LLM. These allow transformations specific to a tool-calling technique or an LLM provider’s requirements. The following post-transforms are used here:
- _ReactMergeToolRequestAndCallsTransform formats tool calls and tool requests into standard user or agent messages.
- CoalesceSystemMessagesTransform allows merging consecutive system messages into a single system message, as required by some LLM providers.
- RemoveEmptyNonUserMessageTransform removes empty agent or system messages, since some LLMs do not support them.
output_parser: specifies how the raw LLM text output is parsed into a tool request. Several examples can be found in the wayflowcore.templates subpackage.
generation_config: for this ReAct-style template, specific generation parameters are added to help reduce hallucinations.

Configure how to use structured generation in templates#

Structured generation can be handled using either native_tool_calling (if the LLM provider supports it) or custom methods. Assume the goal is to generate the following output:

from wayflowcore.property import ObjectProperty, StringProperty

output = ObjectProperty(
    name="output",
    description="information about a person",
    properties={
        "name": StringProperty(description="name of the person"),
        "age": StringProperty(description="age of the person"),
    },
)

API reference: ObjectProperty, StringProperty.

With native structured generation#

Some providers allow passing the desired output format separately and ensure the generated output follows the given format. If the LLM provider supports it, then using a template is straightforward:

template = PromptTemplate.from_string(
    template="Extract information about a person. The person is 65 years old, named Johnny",
    response_format=output,
)
prompt = template.format()
print(prompt.response_format)
# ObjectProperty(...)
response = llm.generate(prompt).message
print(response)
# Message(content='{"name": "Johnny", "age": "65"}', message_type=MessageType.AGENT)

With custom structured generation#

If the LLM provider does not support native structured generation, it is possible to prompt the LLM to produce output in the desired format manually:

text_template = """Extract information about a person. The person is 65 years old, named Johnny.
Just return a json document that respects this JSON Schema:
{{__RESPONSE_FORMAT__.to_json_schema() | tojson }}

Reminder: only output the required json document, no need to repeat the title of the description, just the properties are required!
"""

template = PromptTemplate(
    messages=[{"role": "user", "content": text_template}],
    native_structured_generation=False,
    output_parser=JsonOutputParser(),
    response_format=output,
)
prompt = template.format()
# ^no input needed since __RESPONSE_FORMAT__ is filled with `response_format`
print(prompt.response_format)
# None  # it is not passed separately, but will be taken care of by the output parser
print(prompt.messages)
# [Message(content="""Extract information about a person. The person is 65 years old, named Johnny.
# Just return a json document that respects this JSON Schema:
# {"type": "object", "properties": {"name": {"type": "string", "description": "name of the person"}, "age": {"type": "string", "description": "age of the person"}}, "title": "output", "description": "information about a person"}
#
# Reminder: only output the required json document, no need to repeat the title of the description, just the properties are required!""", message_type=MessageType.USER)]
response = llm.generate(prompt).message
print(response)
# Message(content='{"name": "Johnny", "age": "65"}', message_type=MessageType.AGENT)

The main parameters to configure are:

native_structured_generation=False: prevents the response_format from being passed separately. If a __RESPONSE_FORMAT__ placeholder is used, the response_format will be inserted there.
output_parser: to correctly parse the raw LLM output into the expected object. In this example, a simple output parser is used that can repair malformed JSON output.

You can also use custom output parser to ensure the expected format. In such cases, it is beneficial to include the response_format in the template to clearly indicate the structured output format being generated. For example, parsing the content of the chain-of-thoughts can be done as follows:

prompt_template = PromptTemplate.from_string(
    template="What is the result of 100+(454-3). Think step by step and then give your answer between <result>...</result> delimiters",
    output_parser=RegexOutputParser(
        regex_pattern={
            "thoughts": RegexPattern(pattern=r"(.*)<result>", flags=re.DOTALL),
            "result": RegexPattern(pattern=r"<result>(.*)</result>", flags=re.DOTALL),
        }
    ),
    response_format=ObjectProperty(
        properties={
            "thoughts": StringProperty(description="step by step thinking of the LLM"),
            "result": StringProperty(description="result of the computation"),
        }
    ),
)
prompt = prompt_template.format()  # no inputs needed since the template has no variable
result = llm.generate(prompt).message.content
print(result)
# {"thoughts": "To solve the expression step by step:\n\n1. Evaluate the expression inside the parentheses: 454 - 3 = 451\n2. Add the result to 100: 100 + 451 = 551\n\nSo, the final result is:\n\n", "result": "551"}

Tip

Wayflow also provides a helper function to set up a simple JSON structured generation prompt and the associated output parser from an existing prompt template leveraging native structured generation. Check out the helper method’s API Reference.

Agent Spec Exporting/Loading#

You can export the assistant configuration to its Agent Spec configuration using the AgentSpecExporter.

from wayflowcore.agent import Agent
from wayflowcore.agentspec import AgentSpecExporter, AgentSpecLoader
from wayflowcore.agentspec.components.template import prompttemplate_serialization_plugin, prompttemplate_deserialization_plugin
assistant = Agent(llm=llm, agent_template=prompt_template)
serialized_assistant = AgentSpecExporter(plugins=[prompttemplate_serialization_plugin]).to_json(assistant)

Here is what the Agent Spec representation will look like ↓

Click here to see the assistant configuration.

{
  "component_type": "ExtendedAgent",
  "id": "0d75db5b-68bd-42b5-8a9f-79f2f3f5f85c",
  "name": "agent_6a2dfe98",
  "description": "",
  "metadata": {
    "__metadata_info__": {
      "name": "agent_6a2dfe98",
      "description": ""
    }
  },
  "inputs": [],
  "outputs": [],
  "llm_config": {
    "component_type": "VllmConfig",
    "id": "8534806a-5201-4c59-afee-e8a46ac8a17d",
    "name": "LLAMA_MODEL_ID",
    "description": null,
    "metadata": {
      "__metadata_info__": {}
    },
    "default_generation_parameters": null,
    "url": "LLAMA_API_URL",
    "model_id": "LLAMA_MODEL_ID"
  },
  "system_prompt": "",
  "tools": [],
  "toolboxes": [],
  "context_providers": null,
  "can_finish_conversation": false,
  "max_iterations": 10,
  "initial_message": "Hi! How can I help you?",
  "caller_input_mode": "always",
  "agents": [],
  "flows": [],
  "agent_template": {
    "component_type": "PluginPromptTemplate",
    "id": "d3a8c0b1-722a-44a1-a2a7-c5aa727742e0",
    "name": "prompt_template",
    "description": "",
    "metadata": {
      "__metadata_info__": {}
    },
    "messages": [
      {
        "role": "user",
        "contents": [
          {
            "type": "text",
            "content": "What is the result of 100+(454-3). Think step by step and then give your answer between <result>...</result> delimiters"
          }
        ],
        "tool_requests": null,
        "tool_result": null,
        "display_only": false,
        "sender": null,
        "recipients": [],
        "time_created": "2025-08-15T13:31:44.684406+00:00",
        "time_updated": "2025-08-15T13:31:44.684406+00:00"
      }
    ],
    "output_parser": {
      "component_type": "PluginRegexOutputParser",
      "id": "09cdd631-0189-44bd-800f-4e924ab1ff15",
      "name": "regex_outputparser",
      "description": null,
      "metadata": {
        "__metadata_info__": {}
      },
      "regex_pattern": {
        "result": {
          "pattern": "<result>(.*)</result>",
          "match": "first",
          "flags": 16
        },
        "thoughts": {
          "pattern": "(.*)<result>",
          "match": "first",
          "flags": 16
        }
      },
      "strict": true,
      "component_plugin_name": "OutputParserPlugin",
      "component_plugin_version": "25.4.0.dev0"
    },
    "inputs": [],
    "pre_rendering_transforms": null,
    "post_rendering_transforms": null,
    "tools": null,
    "native_tool_calling": true,
    "response_format": {
      "type": "object",
      "properties": {
        "result": {
          "description": "result of the computation",
          "type": "string"
        },
        "thoughts": {
          "description": "step by step thinking of the LLM",
          "type": "string"
        }
      }
    },
    "native_structured_generation": true,
    "generation_config": null,
    "component_plugin_name": "PromptTemplatePlugin",
    "component_plugin_version": "25.4.0.dev0"
  },
  "component_plugin_name": "AgentPlugin",
  "component_plugin_version": "25.4.0.dev0",
  "agentspec_version": "25.4.1"
}

component_type: ExtendedAgent
id: 0d75db5b-68bd-42b5-8a9f-79f2f3f5f85c
name: agent_6a2dfe98
description: ''
metadata:
  __metadata_info__:
    name: agent_6a2dfe98
    description: ''
inputs: []
outputs: []
llm_config:
  component_type: VllmConfig
  id: 8534806a-5201-4c59-afee-e8a46ac8a17d
  name: LLAMA_MODEL_ID
  description: null
  metadata:
    __metadata_info__: {}
  default_generation_parameters: null
  url: LLAMA_API_URL
  model_id: LLAMA_MODEL_ID
system_prompt: ''
tools: []
toolboxes: []
context_providers: null
can_finish_conversation: false
max_iterations: 10
initial_message: Hi! How can I help you?
caller_input_mode: always
agents: []
flows: []
agent_template:
  component_type: PluginPromptTemplate
  id: d3a8c0b1-722a-44a1-a2a7-c5aa727742e0
  name: prompt_template
  description: ''
  metadata:
    __metadata_info__: {}
  messages:
  - role: user
    contents:
    - type: text
      content: What is the result of 100+(454-3). Think step by step and then give
        your answer between <result>...</result> delimiters
    tool_requests: null
    tool_result: null
    display_only: false
    sender: null
    recipients: []
    time_created: '2025-08-15T13:31:44.684406+00:00'
    time_updated: '2025-08-15T13:31:44.684406+00:00'
  output_parser:
    component_type: PluginRegexOutputParser
    id: 09cdd631-0189-44bd-800f-4e924ab1ff15
    name: regex_outputparser
    description: null
    metadata:
      __metadata_info__: {}
    regex_pattern:
      result:
        pattern: <result>(.*)</result>
        match: first
        flags: 16
      thoughts:
        pattern: (.*)<result>
        match: first
        flags: 16
    strict: true
    component_plugin_name: OutputParserPlugin
    component_plugin_version: 25.4.0.dev0
  inputs: []
  pre_rendering_transforms: null
  post_rendering_transforms: null
  tools: null
  native_tool_calling: true
  response_format:
    type: object
    properties:
      result:
        description: result of the computation
        type: string
      thoughts:
        description: step by step thinking of the LLM
        type: string
  native_structured_generation: true
  generation_config: null
  component_plugin_name: PromptTemplatePlugin
  component_plugin_version: 25.4.0.dev0
component_plugin_name: AgentPlugin
component_plugin_version: 25.4.0.dev0
agentspec_version: 25.4.1

You can then load the configuration back to an assistant using the AgentSpecLoader.

new_agent: Agent = AgentSpecLoader(plugins=[prompttemplate_deserialization_plugin]).load_json(serialized_assistant)

Note

This guide uses the following extension/plugin Agent Spec components:

PluginPromptTemplate
PluginRegexOutputParser
ExtendedAgent

See the list of available Agent Spec extension/plugin components in the API Reference

Note

By default, all WayFlow serialization/deserialization plugins are used when loading or exporting from/to Agent Spec. Passing a list of plugins overrides the default ones.

Next steps#

Having learned how to use the PromptTemplate, you may now proceed to using it in PromptExecutionStep or Agents.

Full code#

Click on the card at the top of this page to download the full code for this guide or copy the code below.

# Copyright © 2025 Oracle and/or its affiliates.
#
# This software is under the Universal Permissive License
# %%[markdown]
# Code Example - How to Use Advanced Prompting Techniques
# -------------------------------------------------------

# How to use:
# Create a new Python virtual environment and install the latest WayFlow version.
# ```bash
# python -m venv venv-wayflowcore
# source venv-wayflowcore/bin/activate
# pip install --upgrade pip
# pip install "wayflowcore==26.1" 
# ```

# You can now run the script
# 1. As a Python file:
# ```bash
# python howto_prompttemplate.py
# ```
# 2. As a Notebook (in VSCode):
# When viewing the file,
#  - press the keys Ctrl + Enter to run the selected cell
#  - or Shift + Enter to run the selected cell and move to the cell below# (UPL) 1.0 (LICENSE-UPL or https://oss.oracle.com/licenses/upl) or Apache License
# 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0), at your option.



# %%[markdown]
## Configure your LLM

# %%
from wayflowcore.models import VllmModel

llm = VllmModel(
    model_id="model-id",
    host_port="VLLM_HOST_PORT",
)

# %%[markdown]
## Basic text prompt with Regex parsing

# %%
import re

from wayflowcore.outputparser import JsonOutputParser, RegexOutputParser, RegexPattern
from wayflowcore.templates import PromptTemplate

prompt_template = PromptTemplate.from_string(
    template="What is the result of 100+(454-3). Think step by step and then give your answer between <result>...</result> delimiters",
    output_parser=RegexOutputParser(
        regex_pattern=RegexPattern(pattern=r"<result>(.*)</result>", flags=re.DOTALL)
    ),
)
prompt = prompt_template.format()  # no inputs needed since the template has no variable
result = llm.generate(prompt).message.content
print(result)
# 551

# %%[markdown]
## Prompt with chat history

# %%
from wayflowcore.messagelist import Message, MessageType

messages = [
    Message(content="What is the capital of Switzerland?", message_type=MessageType.USER),
    Message(content="The capital of Switzerland is Bern?", message_type=MessageType.AGENT),
    Message(content="Really? I thought it was Zurich?", message_type=MessageType.USER),
]

# %%[markdown]
### As inlined messages

# %%
prompt_template = PromptTemplate(
    messages=[
        {"role": "system", "content": "You are a helpful assistant. Answer the user questions"},
        PromptTemplate.CHAT_HISTORY_PLACEHOLDER,
    ]
)

prompt = prompt_template.format(inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: messages})
print(prompt.messages)
# [
#   Message(content='You are a helpful assistant. Answer the user questions', message_type=MessageType.SYSTEM),
#   Message(content='What is the capital of Switzerland?', message_type=MessageType.USER),
#   Message(content='The capital of Switzerland is Bern?', message_type=MessageType.AGENT),
#   Message(content='Really? I thought it was Zurich?', message_type=MessageType.USER)
# ]
result = llm.generate(prompt).message.content
print(result)
# While Zurich is a major city in Switzerland and home to many international organizations, the capital is indeed Bern (also known as Berne).

# %%[markdown]
### In the system prompt

# %%
prompt_text = """You are a helpful assistant. Answer the user questions.
For context, the conversation was:
{% for msg in __CHAT_HISTORY__ %}
{{ msg.message_type.value }} >> {{msg.content}}
{%- endfor %}

Just answer the user question.
"""
prompt_template = PromptTemplate(messages=[{"role": "system", "content": prompt_text}])

prompt = prompt_template.format(inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: messages})
print(prompt.messages)
# [Message(content="""You are a helpful assistant. Answer the user questions.
# For context, the conversation was:
#
# USER >> What is the capital of Switzerland?
# AGENT >> The capital of Switzerland is Bern?
# USER >> Really? I thought it was Zurich?
#
# Just answer the user question.""", message_type=MessageType.SYSTEM]
result = llm.generate(prompt).message.content
print(result)
# While Zurich is a major city and financial hub in Switzerland, the capital is indeed Bern.

# %%[markdown]
### With message transform

# %%
from typing import List
from wayflowcore.transforms import MessageTransform

class OnlyLastChatMessageTransform(MessageTransform):
    def __call__(self, messages: List[Message]) -> List[Message]:
        if len(messages) == 0:
            return []
        return [messages[-1]]

prompt_template = PromptTemplate(
    messages=[
        {"role": "system", "content": "You are a helpful assistant. Answer the user questions"},
        PromptTemplate.CHAT_HISTORY_PLACEHOLDER,
    ],
    pre_rendering_transforms=[OnlyLastChatMessageTransform()],
)
prompt = prompt_template.format(inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: messages})
print(prompt.messages)
# [
#   Message(content='You are a helpful assistant. Answer the user questions', message_type=MessageType.SYSTEM),
#   Message(content='Really? I thought it was Zurich?', message_type=MessageType.USER)
# ]

# %%[markdown]
## Configure how to use tools in templates

# %%
from typing import Annotated
from wayflowcore.tools import tool

@tool
def some_tool(param1: Annotated[str, "name of the user"]) -> Annotated[str, "tool_output"]:
    """Performs some action"""
    return "some_tool_output"

# %%[markdown]
### With native tool calling

# %%
template = PromptTemplate(
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        PromptTemplate.CHAT_HISTORY_PLACEHOLDER,
    ],
)
template = template.with_tools([some_tool])
prompt = template.format(
    inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: [Message("call the some_output tool")]}
)
print(prompt.tools)
# [ServerTool()]
response = llm.generate(prompt).message
print(response)
# Message(content='', message_type=<MessageType.TOOL_REQUEST, tool_requests=[ToolRequest(name='some_output', args={'param1': 'call the some_output tool'}, tool_request_id='chatcmpl-tool-ae924a4829324411add8760d3ae265bd')])

# %%[markdown]
### With custom tool calling

# %%
from wayflowcore.models.llmgenerationconfig import LlmGenerationConfig
from wayflowcore.templates.reacttemplates import (
    REACT_SYSTEM_TEMPLATE,
    ReactToolOutputParser,
    _ReactMergeToolRequestAndCallsTransform,
)
from wayflowcore.transforms import (
    CoalesceSystemMessagesTransform,
    RemoveEmptyNonUserMessageTransform,
)

REACT_CHAT_TEMPLATE = PromptTemplate(
    messages=[
        {"role": "system", "content": REACT_SYSTEM_TEMPLATE},
        PromptTemplate.CHAT_HISTORY_PLACEHOLDER,
    ],
    native_tool_calling=False,
    post_rendering_transforms=[
        _ReactMergeToolRequestAndCallsTransform(),
        CoalesceSystemMessagesTransform(),
        RemoveEmptyNonUserMessageTransform(),
    ],
    output_parser=ReactToolOutputParser(),
    generation_config=LlmGenerationConfig(stop=["## Observation"]),
)
template = REACT_CHAT_TEMPLATE.with_tools([some_tool])
prompt = template.format(
    inputs={PromptTemplate.CHAT_HISTORY_PLACEHOLDER_NAME: [Message("call the some_output tool")]}
)
print(prompt.tools)
# [ServerTool()]
response = llm.generate(prompt).message
print(response)
# Message(content='', message_type=MessageType.TOOL_REQUEST, tool_requests=[ToolRequest(name='some_tool', args={'param1': 'call the some_output tool'}, tool_request_id='chatcmpl-tool-69c7e27e55474501be0dfc2509e5d4f2')]

# %%[markdown]
## Configure how to use structured generation in templates

# %%
from wayflowcore.property import ObjectProperty, StringProperty

output = ObjectProperty(
    name="output",
    description="information about a person",
    properties={
        "name": StringProperty(description="name of the person"),
        "age": StringProperty(description="age of the person"),
    },
)

# %%[markdown]
### With native structured generation

# %%
template = PromptTemplate.from_string(
    template="Extract information about a person. The person is 65 years old, named Johnny",
    response_format=output,
)
prompt = template.format()
print(prompt.response_format)
# ObjectProperty(...)
response = llm.generate(prompt).message
print(response)
# Message(content='{"name": "Johnny", "age": "65"}', message_type=MessageType.AGENT)

# %%[markdown]
### With custom structured generation

# %%
text_template = """Extract information about a person. The person is 65 years old, named Johnny.
Just return a json document that respects this JSON Schema:
{{__RESPONSE_FORMAT__.to_json_schema() | tojson }}

Reminder: only output the required json document, no need to repeat the title of the description, just the properties are required!
"""

template = PromptTemplate(
    messages=[{"role": "user", "content": text_template}],
    native_structured_generation=False,
    output_parser=JsonOutputParser(),
    response_format=output,
)
prompt = template.format()
# ^no input needed since __RESPONSE_FORMAT__ is filled with `response_format`
print(prompt.response_format)
# None  # it is not passed separately, but will be taken care of by the output parser
print(prompt.messages)
# [Message(content="""Extract information about a person. The person is 65 years old, named Johnny.
# Just return a json document that respects this JSON Schema:
# {"type": "object", "properties": {"name": {"type": "string", "description": "name of the person"}, "age": {"type": "string", "description": "age of the person"}}, "title": "output", "description": "information about a person"}
#
# Reminder: only output the required json document, no need to repeat the title of the description, just the properties are required!""", message_type=MessageType.USER)]
response = llm.generate(prompt).message
print(response)
# Message(content='{"name": "Johnny", "age": "65"}', message_type=MessageType.AGENT)

# %%[markdown]
### With additional output parser

# %%
prompt_template = PromptTemplate.from_string(
    template="What is the result of 100+(454-3). Think step by step and then give your answer between <result>...</result> delimiters",
    output_parser=RegexOutputParser(
        regex_pattern={
            "thoughts": RegexPattern(pattern=r"(.*)<result>", flags=re.DOTALL),
            "result": RegexPattern(pattern=r"<result>(.*)</result>", flags=re.DOTALL),
        }
    ),
    response_format=ObjectProperty(
        properties={
            "thoughts": StringProperty(description="step by step thinking of the LLM"),
            "result": StringProperty(description="result of the computation"),
        }
    ),
)
prompt = prompt_template.format()  # no inputs needed since the template has no variable
result = llm.generate(prompt).message.content
print(result)
# {"thoughts": "To solve the expression step by step:\n\n1. Evaluate the expression inside the parentheses: 454 - 3 = 451\n2. Add the result to 100: 100 + 451 = 551\n\nSo, the final result is:\n\n", "result": "551"}

# %%[markdown]
## Export config to Agent Spec

# %%
from wayflowcore.agent import Agent
from wayflowcore.agentspec import AgentSpecExporter, AgentSpecLoader
from wayflowcore.agentspec.components.template import prompttemplate_serialization_plugin, prompttemplate_deserialization_plugin
assistant = Agent(llm=llm, agent_template=prompt_template)
serialized_assistant = AgentSpecExporter(plugins=[prompttemplate_serialization_plugin]).to_json(assistant)

# %%[markdown]
## Load Agent Spec config

# %%
new_agent: Agent = AgentSpecLoader(plugins=[prompttemplate_deserialization_plugin]).load_json(serialized_assistant)