Skip to content

提示词

lazyllm.prompt_templates.prompt_template.PromptTemplate

Bases: BasePromptTemplate

Source code in lazyllm/prompt_templates/prompt_template.py 
  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
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
class PromptTemplate(BasePromptTemplate):
    model_config = ConfigDict(frozen=True)
    template: str = Field(..., description='The prompt template string with {variable} placeholders')
    required_vars: List[str] = Field(default_factory=list, description='List of required variable names')
    partial_vars: Dict[str, Any] = Field(
        default_factory=dict, description='Dictionary of partial variable functions or values'
    )

    @model_validator(mode='after')
    def validate_variables(self):
        """验证模板变量的完整性。

验证规则：
1. partial_vars中的所有键必须存在于模板变量中
2. required_vars和partial_vars的键必须完全等于所有模板变量

Raises:
    ValueError: 当变量验证失败时抛出，包括：
        - partial_vars包含模板中不存在的变量
        - required_vars和partial_vars有重叠变量
        - required_vars和partial_vars的并集不等于所有模板变量

Returns:
    PromptTemplate: 验证后的实例自身
"""
        # 1. All keys in partial_vars must exist in template variables
        # 2. required_vars + partial_vars keys must exactly equal all template variables
        # Extract all variables from template
        all_vars = set(BasePromptTemplate.get_template_variables(self.template))

        # Check if partial_vars.keys() exist in template variables
        partial_vars_keys = set(self.partial_vars.keys())
        invalid_partial_vars = partial_vars_keys - all_vars
        if invalid_partial_vars:
            raise ValueError(f'partial_vars contains variables not found in template: {invalid_partial_vars}')

        required_vars_set = set(self.required_vars)
        # Check if required_vars and partial_vars have overlap
        overlap_vars = required_vars_set & partial_vars_keys
        if overlap_vars:
            raise ValueError(f'required_vars and partial_vars have overlap: {overlap_vars}')

        # Check if required_vars + partial_vars keys exactly equal all template variables
        combined_vars = required_vars_set | partial_vars_keys
        if combined_vars != all_vars:
            missing_vars = all_vars - combined_vars
            extra_vars = combined_vars - all_vars
            error_msg = []
            if missing_vars:
                error_msg.append(f'Missing variables in required_vars or partial_vars: {missing_vars}')
            if extra_vars:
                error_msg.append(f'Extra variables not found in template: {extra_vars}')
            raise ValueError('; '.join(error_msg))

        return self

    def format(self, **kwargs) -> str:
        """格式化提示模板。

使用提供的变量值替换模板中的占位符，支持部分变量的函数调用。

Args:
    **kwargs: 模板变量名和对应的值

Returns:
    str: 格式化后的提示字符串

Raises:
    KeyError: 当缺少必需变量或模板变量不存在时
    TypeError: 当部分变量函数调用出错时
    ValueError: 当模板格式化出错时
"""
        # Check if all required variables are provided
        missing_vars = set(self.required_vars) - set(kwargs.keys())
        if missing_vars:
            raise KeyError(f'Missing required variables: {missing_vars}')

        # 1. Apply partial variables. Note: Overrides the values in kwargs if var_name exists in partial_vars
        format_kwargs = {**kwargs}
        for var_name in self.partial_vars:
            try:
                # Apply partial variable function
                val = self.partial_vars[var_name]
                if callable(val):
                    format_kwargs[var_name] = val()
                else:
                    format_kwargs[var_name] = val
            except Exception as e:
                raise TypeError(f'Error applying partial function for variable "{var_name}": {e}')
        # 2. Format the template
        try:
            return self.template.format(**format_kwargs)
        except KeyError as e:
            raise KeyError(f'Template variable not found: {e}')
        except Exception as e:
            raise ValueError(f'Error formatting template: {e}')

    def partial(self, **partial_kwargs) -> 'PromptTemplate':
        """创建部分填充的模板副本。

为指定的变量设置固定值，生成一个新的模板实例，这些变量将不再需要提供。

Args:
    **partial_kwargs: 要设置为部分变量的变量名和值

Returns:
    PromptTemplate: 新的部分填充模板实例

Raises:
    KeyError: 当指定的变量不存在于模板中时
"""
        # Check if all partial variables exist in the template
        template_vars = set(BasePromptTemplate.get_template_variables(self.template))
        invalid_vars = set(partial_kwargs.keys()) - template_vars
        if invalid_vars:
            raise KeyError(f'Variables not found in template: {invalid_vars}')

        # Create new partial_vars dict with additional partial functions
        new_partial_vars = self.partial_vars.copy()
        new_required_vars = list(set(self.required_vars) - set(partial_kwargs.keys()))
        for var_name, var_value in partial_kwargs.items():
            # Create a function that returns the fixed value
            new_partial_vars[var_name] = var_value

        # Create new template with updated partial_vars
        return PromptTemplate(
            template=self.template,
            required_vars=new_required_vars,
            partial_vars=new_partial_vars
        )

    @classmethod
    def from_template(cls, template: str) -> 'PromptTemplate':
        """从模板字符串创建PromptTemplate实例。

类方法，根据模板字符串自动提取所有变量并设置为必需变量。

Args:
    template (str): 包含{variable}占位符的模板字符串

Returns:
    PromptTemplate: 新创建的PromptTemplate实例
"""
        # Extract all variables from template
        all_vars = BasePromptTemplate.get_template_variables(template)
        return cls(
            template=template,
            required_vars=all_vars,
            partial_vars={}
        )

validate_variables()

验证模板变量的完整性。

验证规则： 1. partial_vars中的所有键必须存在于模板变量中 2. required_vars和partial_vars的键必须完全等于所有模板变量

Raises:

  • ValueError –

    当变量验证失败时抛出，包括： - partial_vars包含模板中不存在的变量 - required_vars和partial_vars有重叠变量 - required_vars和partial_vars的并集不等于所有模板变量

Returns:

  • PromptTemplate –

    验证后的实例自身

Source code in lazyllm/prompt_templates/prompt_template.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
    @model_validator(mode='after')
    def validate_variables(self):
        """验证模板变量的完整性。

验证规则：
1. partial_vars中的所有键必须存在于模板变量中
2. required_vars和partial_vars的键必须完全等于所有模板变量

Raises:
    ValueError: 当变量验证失败时抛出，包括：
        - partial_vars包含模板中不存在的变量
        - required_vars和partial_vars有重叠变量
        - required_vars和partial_vars的并集不等于所有模板变量

Returns:
    PromptTemplate: 验证后的实例自身
"""
        # 1. All keys in partial_vars must exist in template variables
        # 2. required_vars + partial_vars keys must exactly equal all template variables
        # Extract all variables from template
        all_vars = set(BasePromptTemplate.get_template_variables(self.template))

        # Check if partial_vars.keys() exist in template variables
        partial_vars_keys = set(self.partial_vars.keys())
        invalid_partial_vars = partial_vars_keys - all_vars
        if invalid_partial_vars:
            raise ValueError(f'partial_vars contains variables not found in template: {invalid_partial_vars}')

        required_vars_set = set(self.required_vars)
        # Check if required_vars and partial_vars have overlap
        overlap_vars = required_vars_set & partial_vars_keys
        if overlap_vars:
            raise ValueError(f'required_vars and partial_vars have overlap: {overlap_vars}')

        # Check if required_vars + partial_vars keys exactly equal all template variables
        combined_vars = required_vars_set | partial_vars_keys
        if combined_vars != all_vars:
            missing_vars = all_vars - combined_vars
            extra_vars = combined_vars - all_vars
            error_msg = []
            if missing_vars:
                error_msg.append(f'Missing variables in required_vars or partial_vars: {missing_vars}')
            if extra_vars:
                error_msg.append(f'Extra variables not found in template: {extra_vars}')
            raise ValueError('; '.join(error_msg))

        return self

format(**kwargs)

格式化提示模板。

使用提供的变量值替换模板中的占位符，支持部分变量的函数调用。

Parameters:

  • **kwargs –

    模板变量名和对应的值

Returns:

  • str ( str ) –

    格式化后的提示字符串

Raises:

  • KeyError –

    当缺少必需变量或模板变量不存在时

  • TypeError –

    当部分变量函数调用出错时

  • ValueError –

    当模板格式化出错时

Source code in lazyllm/prompt_templates/prompt_template.py 
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
    def format(self, **kwargs) -> str:
        """格式化提示模板。

使用提供的变量值替换模板中的占位符，支持部分变量的函数调用。

Args:
    **kwargs: 模板变量名和对应的值

Returns:
    str: 格式化后的提示字符串

Raises:
    KeyError: 当缺少必需变量或模板变量不存在时
    TypeError: 当部分变量函数调用出错时
    ValueError: 当模板格式化出错时
"""
        # Check if all required variables are provided
        missing_vars = set(self.required_vars) - set(kwargs.keys())
        if missing_vars:
            raise KeyError(f'Missing required variables: {missing_vars}')

        # 1. Apply partial variables. Note: Overrides the values in kwargs if var_name exists in partial_vars
        format_kwargs = {**kwargs}
        for var_name in self.partial_vars:
            try:
                # Apply partial variable function
                val = self.partial_vars[var_name]
                if callable(val):
                    format_kwargs[var_name] = val()
                else:
                    format_kwargs[var_name] = val
            except Exception as e:
                raise TypeError(f'Error applying partial function for variable "{var_name}": {e}')
        # 2. Format the template
        try:
            return self.template.format(**format_kwargs)
        except KeyError as e:
            raise KeyError(f'Template variable not found: {e}')
        except Exception as e:
            raise ValueError(f'Error formatting template: {e}')

partial(**partial_kwargs)

创建部分填充的模板副本。

为指定的变量设置固定值，生成一个新的模板实例，这些变量将不再需要提供。

Parameters:

  • **partial_kwargs –

    要设置为部分变量的变量名和值

Returns:

  • PromptTemplate ( PromptTemplate ) –

    新的部分填充模板实例

Raises:

  • KeyError –

    当指定的变量不存在于模板中时

Source code in lazyllm/prompt_templates/prompt_template.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
    def partial(self, **partial_kwargs) -> 'PromptTemplate':
        """创建部分填充的模板副本。

为指定的变量设置固定值，生成一个新的模板实例，这些变量将不再需要提供。

Args:
    **partial_kwargs: 要设置为部分变量的变量名和值

Returns:
    PromptTemplate: 新的部分填充模板实例

Raises:
    KeyError: 当指定的变量不存在于模板中时
"""
        # Check if all partial variables exist in the template
        template_vars = set(BasePromptTemplate.get_template_variables(self.template))
        invalid_vars = set(partial_kwargs.keys()) - template_vars
        if invalid_vars:
            raise KeyError(f'Variables not found in template: {invalid_vars}')

        # Create new partial_vars dict with additional partial functions
        new_partial_vars = self.partial_vars.copy()
        new_required_vars = list(set(self.required_vars) - set(partial_kwargs.keys()))
        for var_name, var_value in partial_kwargs.items():
            # Create a function that returns the fixed value
            new_partial_vars[var_name] = var_value

        # Create new template with updated partial_vars
        return PromptTemplate(
            template=self.template,
            required_vars=new_required_vars,
            partial_vars=new_partial_vars
        )

from_template(template) classmethod

从模板字符串创建PromptTemplate实例。

类方法，根据模板字符串自动提取所有变量并设置为必需变量。

Parameters:

  • template (str) –

    包含{variable}占位符的模板字符串

Returns:

  • PromptTemplate ( PromptTemplate ) –

    新创建的PromptTemplate实例

Source code in lazyllm/prompt_templates/prompt_template.py 
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
    @classmethod
    def from_template(cls, template: str) -> 'PromptTemplate':
        """从模板字符串创建PromptTemplate实例。

类方法，根据模板字符串自动提取所有变量并设置为必需变量。

Args:
    template (str): 包含{variable}占位符的模板字符串

Returns:
    PromptTemplate: 新创建的PromptTemplate实例
"""
        # Extract all variables from template
        all_vars = BasePromptTemplate.get_template_variables(template)
        return cls(
            template=template,
            required_vars=all_vars,
            partial_vars={}
        )

lazyllm.prompt_templates.base.BasePromptTemplate

Bases: BaseModel, ABC

Source code in lazyllm/prompt_templates/base.py 
 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
class BasePromptTemplate(BaseModel, ABC):

    @staticmethod
    def get_template_variables(template: str) -> list[str]:
        """从给定的模板字符串中提取所有占位符变量名。

使用 Python 内置的 string.Formatter 解析模板，识别占位符，
并返回一个按字母顺序排序的唯一变量名列表。

Args:
    template (str): 包含占位符的提示模板字符串

Returns:
    list[str]: 模板中所有占位符变量名的排序列表

Raises:
    ValueError: 当模板格式非法或解析失败时抛出异常
"""
        try:
            input_variables = {
                v for _, v, _, _ in Formatter().parse(template) if v is not None
            }
            return sorted(input_variables)
        except Exception as e:
            raise ValueError(f'Error getting template variables: {e}')

get_template_variables(template) staticmethod

从给定的模板字符串中提取所有占位符变量名。

使用 Python 内置的 string.Formatter 解析模板，识别占位符， 并返回一个按字母顺序排序的唯一变量名列表。

Parameters:

  • template (str) –

    包含占位符的提示模板字符串

Returns:

  • list[str] –

    list[str]: 模板中所有占位符变量名的排序列表

Raises:

  • ValueError –

    当模板格式非法或解析失败时抛出异常

Source code in lazyllm/prompt_templates/base.py 
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
    @staticmethod
    def get_template_variables(template: str) -> list[str]:
        """从给定的模板字符串中提取所有占位符变量名。

使用 Python 内置的 string.Formatter 解析模板，识别占位符，
并返回一个按字母顺序排序的唯一变量名列表。

Args:
    template (str): 包含占位符的提示模板字符串

Returns:
    list[str]: 模板中所有占位符变量名的排序列表

Raises:
    ValueError: 当模板格式非法或解析失败时抛出异常
"""
        try:
            input_variables = {
                v for _, v, _, _ in Formatter().parse(template) if v is not None
            }
            return sorted(input_variables)
        except Exception as e:
            raise ValueError(f'Error getting template variables: {e}')

lazyllm.prompt_templates.few_shot_prompt_template.FewShotPromptTemplate

Bases: BasePromptTemplate

少样本提示模板类，用于构建包含示例（few-shot examples）的结构化提示。

该模板由三部分组成：前缀（prefix）、多个格式化后的示例（examples）、后缀（suffix）， 并通过指定的示例模板（egs_prompt_template）渲染每个示例。支持变量部分绑定（partial binding）， 允许预先填充部分变量，剩余变量在最终调用 format 时提供。

模板变量必须被明确划分为 required_vars（运行时提供）和 partial_vars（预绑定）， 二者之并集必须恰好等于 prefix 与 suffix 中出现的所有变量。

Attributes:

  • prefix (str) –

    示例前的引导文本，可包含变量占位符

  • suffix (str) –

    示例后的指令或问题文本，可包含变量占位符

  • examples (List[Dict]) –

    示例列表，每个示例为字典，需匹配 egs_prompt_template 的变量

  • egs_prompt_template (PromptTemplate) –

    用于格式化每个示例的子模板

  • required_vars (List[str]) –

    最终 format 时必须提供的变量名列表

  • partial_vars (Dict[str, Any]) –

    预绑定的变量字典，值可以是常量或无参可调用对象

  • separator_for_egs (str) –

    示例之间的分隔符，默认为换行符 '

'

Source code in lazyllm/prompt_templates/few_shot_prompt_template.py 
  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
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
class FewShotPromptTemplate(BasePromptTemplate):
    """少样本提示模板类，用于构建包含示例（few-shot examples）的结构化提示。

该模板由三部分组成：前缀（prefix）、多个格式化后的示例（examples）、后缀（suffix），
并通过指定的示例模板（egs_prompt_template）渲染每个示例。支持变量部分绑定（partial binding），
允许预先填充部分变量，剩余变量在最终调用 format 时提供。

模板变量必须被明确划分为 required_vars（运行时提供）和 partial_vars（预绑定），
二者之并集必须恰好等于 prefix 与 suffix 中出现的所有变量。

Attributes:
    prefix (str): 示例前的引导文本，可包含变量占位符
    suffix (str): 示例后的指令或问题文本，可包含变量占位符
    examples (List[Dict]): 示例列表，每个示例为字典，需匹配 egs_prompt_template 的变量
    egs_prompt_template (PromptTemplate): 用于格式化每个示例的子模板
    required_vars (List[str]): 最终 format 时必须提供的变量名列表
    partial_vars (Dict[str, Any]): 预绑定的变量字典，值可以是常量或无参可调用对象
    separator_for_egs (str): 示例之间的分隔符，默认为换行符 '\n'
"""
    model_config = ConfigDict(frozen=True)
    prefix: str = Field(..., description='The prefix text that comes before examples, it may include variables')
    suffix: str = Field(..., description='The suffix text that comes after examples, it may include variables')
    examples: List[Dict[str, Any]] = Field(default_factory=list, description='List of example dictionaries')
    egs_prompt_template: PromptTemplate = Field(..., description='Template for formatting each example')
    required_vars: List[str] = Field(
        default_factory=list, description='List of required variable names for the final prompt'
    )
    partial_vars: Dict[str, Any] = Field(
        default_factory=dict, description='Dictionary of partial variable functions or values'
    )
    separator_for_egs: str = Field(default='\n', description='The separator between examples')

    @model_validator(mode='after')
    def validate_variables(self):
        """模型验证器，在实例创建后自动调用，用于校验模板变量和示例的一致性。

执行以下检查：
1. partial_vars 中的所有键必须存在于 prefix 或 suffix 的模板变量中；
2. required_vars 与 partial_vars 不能有交集；
3. required_vars 和 partial_vars 的并集必须恰好等于 prefix 与 suffix 中出现的所有变量；
4. 每个示例字典必须包含 egs_prompt_template 所需的全部变量。

若任一检查失败，将抛出 ValueError。

此方法确保模板在使用前处于合法、自洽的状态。
"""
        # 1. All keys in partial_vars must exist in the combined prefix+suffix variables
        # 2. required_vars + partial_vars keys must exactly equal all template variables
        # 3. Examples must be compatible with egs_prompt_template

        # all variables: variables in prefix + suffix.
        # Note: egs_prompt_template variables are not included here.
        all_vars = self._get_all_variables()

        # Check if partial_vars.keys() exist in template variables
        partial_vars_keys = set(self.partial_vars.keys())
        invalid_partial_vars = partial_vars_keys - all_vars
        if invalid_partial_vars:
            raise ValueError(f'partial_vars contains variables not found in template: {invalid_partial_vars}')

        required_vars_set = set(self.required_vars)
        # Check if required_vars and partial_vars have overlap
        overlap_vars = required_vars_set & partial_vars_keys
        if overlap_vars:
            raise ValueError(f'required_vars and partial_vars have overlap: {overlap_vars}')

        # Check if required_vars + partial_vars keys exactly equal all template variables
        combined_vars = required_vars_set | partial_vars_keys
        if combined_vars != all_vars:
            missing_vars = all_vars - combined_vars
            extra_vars = combined_vars - all_vars
            error_msg = []
            if missing_vars:
                error_msg.append(f'Missing variables in required_vars or partial_vars: {missing_vars}')
            if extra_vars:
                error_msg.append(f'Extra variables not found in template: {extra_vars}')
            raise ValueError('; '.join(error_msg))

        # Check each example is compatible with egs_prompt_template
        if self.examples:
            egs_required_vars = set(self.egs_prompt_template.required_vars)
            for i, example in enumerate(self.examples):
                example_keys = set(example.keys())
                missing_egs_vars = egs_required_vars - example_keys
                if missing_egs_vars:
                    raise ValueError(f'Example {i} missing required variables : {missing_egs_vars}')
        return self

    def format(self, **kwargs) -> str:
        """根据提供的变量值生成完整的少样本提示字符串。

必须提供所有 required_vars 中声明的变量。partial_vars 中的变量会自动应用（若为可调用对象则执行），
并覆盖 kwargs 中同名的值。每个示例通过 egs_prompt_template 格式化后，按 separator_for_egs 拼接，
最终与 prefix 和 suffix 合并并填充变量。

Args:
    **kwargs: 包含所有 required_vars 的关键字参数

Returns:
    str: 完整渲染后的提示文本

Raises:
    KeyError: 缺少 required_vars 中的变量，或模板中存在未绑定的变量
    ValueError: 示例格式化失败或最终模板渲染出错
"""
        # Check if all required variables are provided
        missing_vars = set(self.required_vars) - set(kwargs.keys())
        if missing_vars:
            raise KeyError(f'Missing required variables: {missing_vars}')

        # 1. Apply partial variables. Note: Overrides the values in kwargs if var_name exists in partial_vars
        format_kwargs = {**kwargs}
        for var_name in self.partial_vars:
            try:
                # Apply partial variable function
                val = self.partial_vars[var_name]
                if callable(val):
                    format_kwargs[var_name] = val()
                else:
                    format_kwargs[var_name] = val
            except Exception as e:
                raise TypeError(f'Error applying partial function for variable "{var_name}": {e}')

        # 2. Format examples
        formatted_examples = []
        sep = self.separator_for_egs
        for example in self.examples:
            try:
                formatted_example = self.egs_prompt_template.format(**example)
                formatted_examples.append(formatted_example)
            except Exception as e:
                raise ValueError(f'Error formatting example {example}: {e}')

        # 3. Combine prefix, examples(already formatted), and suffix
        examples_text = sep.join(formatted_examples)

        # 4. Format the final prompt
        try:
            final_template = f'{self.prefix}\n{examples_text}\n{self.suffix}'
            return final_template.format(**format_kwargs)
        except KeyError as e:
            raise KeyError(f'Template variable not found: {e}')
        except Exception as e:
            raise ValueError(f'Error formatting template: {e}')

    def partial(self, **kwargs) -> 'FewShotPromptTemplate':
        """对模板进行部分变量绑定，返回一个新的 FewShotPromptTemplate 实例。

新实例中，传入的变量将从 required_vars 移至 partial_vars，后续调用 format 时无需再提供这些变量。
可用于逐步绑定变量或构建可复用的半成品模板。

Args:
    **kwargs: 要预绑定的变量名和值（值可为常量或无参函数）

Returns:
    FewShotPromptTemplate: 新的模板实例，已绑定指定变量

Raises:
    KeyError: 若 kwargs 中包含模板中不存在的变量名
"""
        # Check if all partial variables exist in the template
        all_vars = self._get_all_variables()

        invalid_vars = set(kwargs.keys()) - all_vars
        if invalid_vars:
            raise KeyError(f'Variables not found in template: {invalid_vars}')

        # Create new partial_vars dict with additional partial functions
        new_partial_vars = self.partial_vars.copy()
        new_required_vars = list(set(self.required_vars) - set(kwargs.keys()))
        for var_name, var_value in kwargs.items():
            new_partial_vars[var_name] = var_value

        # Create new template with updated partial_vars
        return FewShotPromptTemplate(
            prefix=self.prefix,
            suffix=self.suffix,
            examples=self.examples.copy(),
            egs_prompt_template=self.egs_prompt_template,
            required_vars=new_required_vars,
            partial_vars=new_partial_vars
        )

    def _get_all_variables(self) -> Set[str]:
        prefix_vars = set(BasePromptTemplate.get_template_variables(self.prefix))
        suffix_vars = set(BasePromptTemplate.get_template_variables(self.suffix))
        return prefix_vars | suffix_vars

validate_variables()

模型验证器，在实例创建后自动调用，用于校验模板变量和示例的一致性。

执行以下检查： 1. partial_vars 中的所有键必须存在于 prefix 或 suffix 的模板变量中； 2. required_vars 与 partial_vars 不能有交集； 3. required_vars 和 partial_vars 的并集必须恰好等于 prefix 与 suffix 中出现的所有变量； 4. 每个示例字典必须包含 egs_prompt_template 所需的全部变量。

若任一检查失败，将抛出 ValueError。

此方法确保模板在使用前处于合法、自洽的状态。

Source code in lazyllm/prompt_templates/few_shot_prompt_template.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
    @model_validator(mode='after')
    def validate_variables(self):
        """模型验证器，在实例创建后自动调用，用于校验模板变量和示例的一致性。

执行以下检查：
1. partial_vars 中的所有键必须存在于 prefix 或 suffix 的模板变量中；
2. required_vars 与 partial_vars 不能有交集；
3. required_vars 和 partial_vars 的并集必须恰好等于 prefix 与 suffix 中出现的所有变量；
4. 每个示例字典必须包含 egs_prompt_template 所需的全部变量。

若任一检查失败，将抛出 ValueError。

此方法确保模板在使用前处于合法、自洽的状态。
"""
        # 1. All keys in partial_vars must exist in the combined prefix+suffix variables
        # 2. required_vars + partial_vars keys must exactly equal all template variables
        # 3. Examples must be compatible with egs_prompt_template

        # all variables: variables in prefix + suffix.
        # Note: egs_prompt_template variables are not included here.
        all_vars = self._get_all_variables()

        # Check if partial_vars.keys() exist in template variables
        partial_vars_keys = set(self.partial_vars.keys())
        invalid_partial_vars = partial_vars_keys - all_vars
        if invalid_partial_vars:
            raise ValueError(f'partial_vars contains variables not found in template: {invalid_partial_vars}')

        required_vars_set = set(self.required_vars)
        # Check if required_vars and partial_vars have overlap
        overlap_vars = required_vars_set & partial_vars_keys
        if overlap_vars:
            raise ValueError(f'required_vars and partial_vars have overlap: {overlap_vars}')

        # Check if required_vars + partial_vars keys exactly equal all template variables
        combined_vars = required_vars_set | partial_vars_keys
        if combined_vars != all_vars:
            missing_vars = all_vars - combined_vars
            extra_vars = combined_vars - all_vars
            error_msg = []
            if missing_vars:
                error_msg.append(f'Missing variables in required_vars or partial_vars: {missing_vars}')
            if extra_vars:
                error_msg.append(f'Extra variables not found in template: {extra_vars}')
            raise ValueError('; '.join(error_msg))

        # Check each example is compatible with egs_prompt_template
        if self.examples:
            egs_required_vars = set(self.egs_prompt_template.required_vars)
            for i, example in enumerate(self.examples):
                example_keys = set(example.keys())
                missing_egs_vars = egs_required_vars - example_keys
                if missing_egs_vars:
                    raise ValueError(f'Example {i} missing required variables : {missing_egs_vars}')
        return self

format(**kwargs)

根据提供的变量值生成完整的少样本提示字符串。

必须提供所有 required_vars 中声明的变量。partial_vars 中的变量会自动应用（若为可调用对象则执行）， 并覆盖 kwargs 中同名的值。每个示例通过 egs_prompt_template 格式化后，按 separator_for_egs 拼接， 最终与 prefix 和 suffix 合并并填充变量。

Parameters:

  • **kwargs –

    包含所有 required_vars 的关键字参数

Returns:

  • str ( str ) –

    完整渲染后的提示文本

Raises:

  • KeyError –

    缺少 required_vars 中的变量，或模板中存在未绑定的变量

  • ValueError –

    示例格式化失败或最终模板渲染出错

Source code in lazyllm/prompt_templates/few_shot_prompt_template.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
    def format(self, **kwargs) -> str:
        """根据提供的变量值生成完整的少样本提示字符串。

必须提供所有 required_vars 中声明的变量。partial_vars 中的变量会自动应用（若为可调用对象则执行），
并覆盖 kwargs 中同名的值。每个示例通过 egs_prompt_template 格式化后，按 separator_for_egs 拼接，
最终与 prefix 和 suffix 合并并填充变量。

Args:
    **kwargs: 包含所有 required_vars 的关键字参数

Returns:
    str: 完整渲染后的提示文本

Raises:
    KeyError: 缺少 required_vars 中的变量，或模板中存在未绑定的变量
    ValueError: 示例格式化失败或最终模板渲染出错
"""
        # Check if all required variables are provided
        missing_vars = set(self.required_vars) - set(kwargs.keys())
        if missing_vars:
            raise KeyError(f'Missing required variables: {missing_vars}')

        # 1. Apply partial variables. Note: Overrides the values in kwargs if var_name exists in partial_vars
        format_kwargs = {**kwargs}
        for var_name in self.partial_vars:
            try:
                # Apply partial variable function
                val = self.partial_vars[var_name]
                if callable(val):
                    format_kwargs[var_name] = val()
                else:
                    format_kwargs[var_name] = val
            except Exception as e:
                raise TypeError(f'Error applying partial function for variable "{var_name}": {e}')

        # 2. Format examples
        formatted_examples = []
        sep = self.separator_for_egs
        for example in self.examples:
            try:
                formatted_example = self.egs_prompt_template.format(**example)
                formatted_examples.append(formatted_example)
            except Exception as e:
                raise ValueError(f'Error formatting example {example}: {e}')

        # 3. Combine prefix, examples(already formatted), and suffix
        examples_text = sep.join(formatted_examples)

        # 4. Format the final prompt
        try:
            final_template = f'{self.prefix}\n{examples_text}\n{self.suffix}'
            return final_template.format(**format_kwargs)
        except KeyError as e:
            raise KeyError(f'Template variable not found: {e}')
        except Exception as e:
            raise ValueError(f'Error formatting template: {e}')

partial(**kwargs)

对模板进行部分变量绑定，返回一个新的 FewShotPromptTemplate 实例。

新实例中，传入的变量将从 required_vars 移至 partial_vars，后续调用 format 时无需再提供这些变量。 可用于逐步绑定变量或构建可复用的半成品模板。

Parameters:

  • **kwargs –

    要预绑定的变量名和值（值可为常量或无参函数）

Returns:

Raises:

  • KeyError –

    若 kwargs 中包含模板中不存在的变量名

Source code in lazyllm/prompt_templates/few_shot_prompt_template.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
    def partial(self, **kwargs) -> 'FewShotPromptTemplate':
        """对模板进行部分变量绑定，返回一个新的 FewShotPromptTemplate 实例。

新实例中，传入的变量将从 required_vars 移至 partial_vars，后续调用 format 时无需再提供这些变量。
可用于逐步绑定变量或构建可复用的半成品模板。

Args:
    **kwargs: 要预绑定的变量名和值（值可为常量或无参函数）

Returns:
    FewShotPromptTemplate: 新的模板实例，已绑定指定变量

Raises:
    KeyError: 若 kwargs 中包含模板中不存在的变量名
"""
        # Check if all partial variables exist in the template
        all_vars = self._get_all_variables()

        invalid_vars = set(kwargs.keys()) - all_vars
        if invalid_vars:
            raise KeyError(f'Variables not found in template: {invalid_vars}')

        # Create new partial_vars dict with additional partial functions
        new_partial_vars = self.partial_vars.copy()
        new_required_vars = list(set(self.required_vars) - set(kwargs.keys()))
        for var_name, var_value in kwargs.items():
            new_partial_vars[var_name] = var_value

        # Create new template with updated partial_vars
        return FewShotPromptTemplate(
            prefix=self.prefix,
            suffix=self.suffix,
            examples=self.examples.copy(),
            egs_prompt_template=self.egs_prompt_template,
            required_vars=new_required_vars,
            partial_vars=new_partial_vars
        )

lazyllm.prompt_templates.LazyLLMPromptLibraryBase

提示语库基类，用于管理多语言的提示语集合并提供统一访问接口。

行为简介：

  • 维护按语言划分的提示语字典（_prompts）。
  • 提供获取单条提示语和列举某语言全部键（key）的能力。
  • 在初始化时可指定实例默认语言。

主要方法：

  • get_prompt(key, lang=None): 按 key 与语言获取对应提示语字符串或结构，若未提供语言则使用实例语言或默认语言。
  • get_all_keys(lang=None): 列出指定语言下的所有提示语键名，若未提供语言则使用实例语言或默认语言。
Source code in lazyllm/prompt_templates/prompt_library.py 
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
class LazyLLMPromptLibraryBase(metaclass=LazyLLMRegisterMetaClass):
    """提示语库基类，用于管理多语言的提示语集合并提供统一访问接口。

行为简介：

- 维护按语言划分的提示语字典（_prompts）。
- 提供获取单条提示语和列举某语言全部键（key）的能力。
- 在初始化时可指定实例默认语言。

主要方法：

- get_prompt(key, lang=None): 按 key 与语言获取对应提示语字符串或结构，若未提供语言则使用实例语言或默认语言。
- get_all_keys(lang=None): 列出指定语言下的所有提示语键名，若未提供语言则使用实例语言或默认语言。
"""
    _prompts = {}
    _default_lang = 'zh'

    def __init__(self, lang=None):
        self.lang = lang
        if self.lang and self.lang not in self.supported_langs:
            LOG.warning(f'Language "{self.lang}" passed to init is not supported. Supported: {self.supported_langs}')

    @property
    def supported_langs(self):
        return list(self._prompts.keys())

    def get_prompt(self, key: str, lang=None):
        """按键名获取指定语言的提示语。

Args:
    key (str): 提示语的键名。
    lang (str): 可选，语言代码 ('zh' 或 'en')。若未提供，使用实例语言或类默认语言。

**Returns:**

- str 或 dict: 返回对应的提示语（可能是字符串或结构化 dict），若未找到则抛出 ValueError。
"""
        lang = lang or self.lang or self._default_lang
        if lang not in self._prompts:
            raise ValueError(f'Language "{lang}" not supported. Supported: {self.supported_langs}')
        prompt = self._prompts[lang].get(key)
        if prompt is None:
            raise ValueError(f'Prompt for key "{key}" not found in library (lang: {lang}).')
        return prompt

    def get_all_keys(self, lang=None) -> list:
        """列出指定语言下所有可用的提示语键名。

Args:
    lang (str): 可选，语言代码 ('zh' 或 'en')。若未提供，使用实例语言或类默认语言。

**Returns:**

- list: 包含所有键名的列表；若语言不受支持则返回空列表并记录警告。
"""
        if lang is None:
            if self.lang:
                lang = self.lang
                LOG.info(f'get_all_keys: no lang passed, using instance language "{self.lang}"')
            else:
                lang = self._default_lang
                LOG.info(f'get_all_keys: no lang passed, using default language "{self._default_lang}"')

        if lang not in self._prompts:
            LOG.warning(f'Language "{lang}" not supported. Supported: {self.supported_langs}')
            return []
        return list(self._prompts[lang].keys())

get_all_keys(lang=None)

列出指定语言下所有可用的提示语键名。

Parameters:

  • lang (str, default: None ) –

    可选，语言代码 ('zh' 或 'en')。若未提供，使用实例语言或类默认语言。

Returns:

  • list: 包含所有键名的列表；若语言不受支持则返回空列表并记录警告。
Source code in lazyllm/prompt_templates/prompt_library.py 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
    def get_all_keys(self, lang=None) -> list:
        """列出指定语言下所有可用的提示语键名。

Args:
    lang (str): 可选，语言代码 ('zh' 或 'en')。若未提供，使用实例语言或类默认语言。

**Returns:**

- list: 包含所有键名的列表；若语言不受支持则返回空列表并记录警告。
"""
        if lang is None:
            if self.lang:
                lang = self.lang
                LOG.info(f'get_all_keys: no lang passed, using instance language "{self.lang}"')
            else:
                lang = self._default_lang
                LOG.info(f'get_all_keys: no lang passed, using default language "{self._default_lang}"')

        if lang not in self._prompts:
            LOG.warning(f'Language "{lang}" not supported. Supported: {self.supported_langs}')
            return []
        return list(self._prompts[lang].keys())

get_prompt(key, lang=None)

按键名获取指定语言的提示语。

Parameters:

  • key (str) –

    提示语的键名。

  • lang (str, default: None ) –

    可选，语言代码 ('zh' 或 'en')。若未提供，使用实例语言或类默认语言。

Returns:

  • str 或 dict: 返回对应的提示语（可能是字符串或结构化 dict），若未找到则抛出 ValueError。
Source code in lazyllm/prompt_templates/prompt_library.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
    def get_prompt(self, key: str, lang=None):
        """按键名获取指定语言的提示语。

Args:
    key (str): 提示语的键名。
    lang (str): 可选，语言代码 ('zh' 或 'en')。若未提供，使用实例语言或类默认语言。

**Returns:**

- str 或 dict: 返回对应的提示语（可能是字符串或结构化 dict），若未找到则抛出 ValueError。
"""
        lang = lang or self.lang or self._default_lang
        if lang not in self._prompts:
            raise ValueError(f'Language "{lang}" not supported. Supported: {self.supported_langs}')
        prompt = self._prompts[lang].get(key)
        if prompt is None:
            raise ValueError(f'Prompt for key "{key}" not found in library (lang: {lang}).')
        return prompt

lazyllm.ActorPrompt

Bases: LazyLLMPromptLibraryBase

提示语库模块。内置了丰富的预设提示语（Prompts），支持中英文分类，可基于角色（act）名称获取。

Parameters:

  • lang (str, default: None ) –

    默认语言，可选 'zh' (中文) 或 'en' (英文)。若不指定，默认为 'zh'。

Examples:

>>> from lazyllm import ActorPrompt
>>> lib = ActorPrompt(lang='en')
>>> # Get all available acts
>>> acts = lib.get_all_acts()
>>> # Get prompt for a specific act
>>> prompt = lib.get_prompt('English Translator and Improver')
>>> # Also callable directly
>>> prompt = lib('English Translator and Improver')
>>> print(prompt[:50])
I want you to act as an English translator, spelli...
Source code in lazyllm/prompt_templates/prompt_library.py 
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
class ActorPrompt(LazyLLMPromptLibraryBase):
    """提示语库模块。内置了丰富的预设提示语（Prompts），支持中英文分类，可基于角色（act）名称获取。

Args:
    lang (str): 默认语言，可选 'zh' (中文) 或 'en' (英文)。若不指定，默认为 'zh'。


Examples:
        >>> from lazyllm import ActorPrompt
        >>> lib = ActorPrompt(lang='en')
        >>> # Get all available acts
        >>> acts = lib.get_all_acts()
        >>> # Get prompt for a specific act
        >>> prompt = lib.get_prompt('English Translator and Improver')
        >>> # Also callable directly
        >>> prompt = lib('English Translator and Improver')
        >>> print(prompt[:50])
        I want you to act as an English translator, spelli...
    """
    _prompts: dict = {}
    _prompts_paths = [
        ('awesome-chatgpt-prompts-zh.json', 'zh'),
        ('prompts.chat.json', 'en'),
    ]
    _loaded = False
    _load_lock = threading.Lock()
    _default_lang = 'zh'

    def __init__(self, lang=None):
        if not ActorPrompt._loaded:
            with ActorPrompt._load_lock:
                if not ActorPrompt._loaded:  # Double-checked locking
                    self._build_library()
                    ActorPrompt._loaded = True

        super().__init__(lang)

    def _load_prompts(self, path, lang):
        if lang not in self._prompts:
            self._prompts[lang] = {}

        if not os.path.exists(path):
            LOG.warning(f'ActorPrompt file not found: {path}')
            return

        try:
            with open(path, 'r', encoding='utf-8') as f:
                prompts = json.load(f)

            count = 0
            for item in prompts:
                act = item.get('act')
                prompt = item.get('prompt')
                if act and prompt:
                    if act in self._prompts[lang]:
                        LOG.warning(
                            f'Duplicate act "{act}" found in {path} for '
                            f'lang {lang}. Overwriting existing prompt.')
                    self._prompts[lang][act] = prompt
                    count += 1
            LOG.debug(f'Loaded {count} prompts from {path} for lang {lang}')
        except json.JSONDecodeError:
            LOG.error(f'Failed to decode JSON from {path}')
        except Exception as e:
            LOG.error(f'Error loading prompts from {path}: {e}')

    def _build_library(self):
        base_path = os.path.dirname(__file__)
        for rel_path, lang in self._prompts_paths:
            abs_path = os.path.join(base_path, 'prompts_actor', rel_path)
            self._load_prompts(abs_path, lang)
            # Show summary of loaded prompts
            if lang in self._prompts:
                LOG.info(f'After loading {rel_path}, total prompts for lang "{lang}": {len(self._prompts[lang])}')

    def __call__(self, act: str, lang=None, return_raw=False) -> 'Union[ChatPrompter, str]':
        prompt = self.get_prompt(act, lang)  # Get the raw prompt string
        if return_raw:
            return prompt
        return ChatPrompter(prompt)

    def get_all_acts(self, lang=None) -> list:
        """获取指定语言下所有支持的角色（act）列表。

Args:
    lang (str): 语言代码 ('zh' 或 'en')。若未提供，则使用实例初始化时的语言。

**Returns:**

- list: 包含所有可用角色名称的列表。
"""
        return self.get_all_keys(lang)

get_all_acts(lang=None)

获取指定语言下所有支持的角色（act）列表。

Parameters:

  • lang (str, default: None ) –

    语言代码 ('zh' 或 'en')。若未提供，则使用实例初始化时的语言。

Returns:

  • list: 包含所有可用角色名称的列表。
Source code in lazyllm/prompt_templates/prompt_library.py 
161
162
163
164
165
166
167
168
169
170
171
    def get_all_acts(self, lang=None) -> list:
        """获取指定语言下所有支持的角色（act）列表。

Args:
    lang (str): 语言代码 ('zh' 或 'en')。若未提供，则使用实例初始化时的语言。

**Returns:**

- list: 包含所有可用角色名称的列表。
"""
        return self.get_all_keys(lang)

lazyllm.DataPrompt

Bases: LazyLLMPromptLibraryBase

结构化提示语库(用于数据处理模块)，支持将提示语以字典形式存储（包含 system/user/tools/history/extra_keys 等字段），并通过 ChatPrompter 构建可用的对话提示器。

特点：

  • 支持以类方法 add_prompt 动态添加提示语。
  • call 可返回 ChatPrompter 或原始字典（return_raw=True）。

Examples:

>>> from lazyllm import DataPrompt
>>> DataPrompt.add_prompt(
...     act='simple_summarize',
...     system_prompt='You are a concise summarizer.',
...     user_prompt='Please summarize the following text: {text}',
...     lang='en'
... )
>>> lib = DataPrompt(lang='en')
>>> prompter = lib('simple_summarize')
>>> print(type(prompter))
<class 'lazyllm.components.prompter.chatPrompter.ChatPrompter'>
>>> raw = lib('simple_summarize', return_raw=True)
>>> print(raw['system'][:20])
You are a concise su
Source code in lazyllm/prompt_templates/prompt_library.py 
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
class DataPrompt(LazyLLMPromptLibraryBase):
    """结构化提示语库(用于数据处理模块)，支持将提示语以字典形式存储（包含 system/user/tools/history/extra_keys 等字段），并通过 ChatPrompter 构建可用的对话提示器。

特点：

- 支持以类方法 add_prompt 动态添加提示语。
- __call__ 可返回 ChatPrompter 或原始字典（return_raw=True）。


Examples:
    >>> from lazyllm import DataPrompt
    >>> DataPrompt.add_prompt(
    ...     act='simple_summarize',
    ...     system_prompt='You are a concise summarizer.',
    ...     user_prompt='Please summarize the following text: {text}',
    ...     lang='en'
    ... )
    >>> lib = DataPrompt(lang='en')
    >>> prompter = lib('simple_summarize')
    >>> print(type(prompter))
    <class 'lazyllm.components.prompter.chatPrompter.ChatPrompter'>
    >>> raw = lib('simple_summarize', return_raw=True)
    >>> print(raw['system'][:20])
    You are a concise su
    """
    _prompts: dict = {}
    _default_lang = 'zh'
    _load_lock = threading.Lock()

    def __init__(self, lang=None):
        super().__init__(lang)

    def __call__(self, key: str, lang=None, return_raw=False) -> 'Union[ChatPrompter, str]':
        """根据 key 和语言构建并返回 ChatPrompter，或在 return_raw=True 时返回原始提示语字典。

Args:
    key (str): 提示语键名。
    lang (str): 可选，语言代码。
    return_raw (bool): 若为 True，返回原始字典；否则返回 ChatPrompter 实例。

**Returns:**

- ChatPrompter 或 dict: 根据 return_raw 决定返回类型。若未找到会抛出 ValueError。
"""
        prompt = self.get_prompt(key, lang)  # Get the raw prompt dict
        if return_raw:
            return prompt  # Dict

        prompt = copy.deepcopy(prompt)
        tools = prompt.get('tools')
        history = prompt.get('history')
        extra_keys = prompt.get('extra_keys')
        system = prompt.get('system', '')
        user = prompt.get('user', '')

        return ChatPrompter({'system': system, 'user': user}, tools=tools, history=history, extra_keys=extra_keys)

    @classmethod
    def add_prompt(cls, act, system_prompt=None, user_prompt=None, tools=None, history=None, extra_keys=None, lang='zh'):
        """以结构化形式添加或覆盖一个提示语条目。

Args:
    act (str): 提示语键名。
    system_prompt (str): 可选，system 消息内容。
    user_prompt (str): 可选，user 消息内容。
    tools (any): 可选，工具描述或配置。
    history (any): 可选，历史上下文。
    extra_keys (any): 可选，额外字段。
    lang (str): 目标语言代码，默认 'zh'。

注意：至少要提供 system_prompt 或 user_prompt。
"""
        assert system_prompt or user_prompt, 'At least one of system_prompt or user_prompt must be provided'
        with cls._load_lock:
            if lang not in cls._prompts:
                cls._prompts[lang] = {}

            if act in cls._prompts[lang]:
                LOG.warning(f'Duplicate act "{act}" found in DataPrompt for lang {lang}. Overwriting.')

            cls._prompts[lang][act] = {
                'system': system_prompt if system_prompt is not None else '',
                'user': user_prompt if user_prompt is not None else '',
                'tools': tools,
                'history': history,
                'extra_keys': extra_keys
            }

__call__(key, lang=None, return_raw=False)

根据 key 和语言构建并返回 ChatPrompter，或在 return_raw=True 时返回原始提示语字典。

Parameters:

  • key (str) –

    提示语键名。

  • lang (str, default: None ) –

    可选，语言代码。

  • return_raw (bool, default: False ) –

    若为 True，返回原始字典；否则返回 ChatPrompter 实例。

Returns:

  • ChatPrompter 或 dict: 根据 return_raw 决定返回类型。若未找到会抛出 ValueError。
Source code in lazyllm/prompt_templates/prompt_library.py 
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
    def __call__(self, key: str, lang=None, return_raw=False) -> 'Union[ChatPrompter, str]':
        """根据 key 和语言构建并返回 ChatPrompter，或在 return_raw=True 时返回原始提示语字典。

Args:
    key (str): 提示语键名。
    lang (str): 可选，语言代码。
    return_raw (bool): 若为 True，返回原始字典；否则返回 ChatPrompter 实例。

**Returns:**

- ChatPrompter 或 dict: 根据 return_raw 决定返回类型。若未找到会抛出 ValueError。
"""
        prompt = self.get_prompt(key, lang)  # Get the raw prompt dict
        if return_raw:
            return prompt  # Dict

        prompt = copy.deepcopy(prompt)
        tools = prompt.get('tools')
        history = prompt.get('history')
        extra_keys = prompt.get('extra_keys')
        system = prompt.get('system', '')
        user = prompt.get('user', '')

        return ChatPrompter({'system': system, 'user': user}, tools=tools, history=history, extra_keys=extra_keys)

add_prompt(act, system_prompt=None, user_prompt=None, tools=None, history=None, extra_keys=None, lang='zh') classmethod

以结构化形式添加或覆盖一个提示语条目。

Parameters:

  • act (str) –

    提示语键名。

  • system_prompt (str, default: None ) –

    可选，system 消息内容。

  • user_prompt (str, default: None ) –

    可选，user 消息内容。

  • tools (any, default: None ) –

    可选，工具描述或配置。

  • history (any, default: None ) –

    可选，历史上下文。

  • extra_keys (any, default: None ) –

    可选，额外字段。

  • lang (str, default: 'zh' ) –

    目标语言代码，默认 'zh'。

注意：至少要提供 system_prompt 或 user_prompt。

Source code in lazyllm/prompt_templates/prompt_library.py 
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
    @classmethod
    def add_prompt(cls, act, system_prompt=None, user_prompt=None, tools=None, history=None, extra_keys=None, lang='zh'):
        """以结构化形式添加或覆盖一个提示语条目。

Args:
    act (str): 提示语键名。
    system_prompt (str): 可选，system 消息内容。
    user_prompt (str): 可选，user 消息内容。
    tools (any): 可选，工具描述或配置。
    history (any): 可选，历史上下文。
    extra_keys (any): 可选，额外字段。
    lang (str): 目标语言代码，默认 'zh'。

注意：至少要提供 system_prompt 或 user_prompt。
"""
        assert system_prompt or user_prompt, 'At least one of system_prompt or user_prompt must be provided'
        with cls._load_lock:
            if lang not in cls._prompts:
                cls._prompts[lang] = {}

            if act in cls._prompts[lang]:
                LOG.warning(f'Duplicate act "{act}" found in DataPrompt for lang {lang}. Overwriting.')

            cls._prompts[lang][act] = {
                'system': system_prompt if system_prompt is not None else '',
                'user': user_prompt if user_prompt is not None else '',
                'tools': tools,
                'history': history,
                'extra_keys': extra_keys
            }