typed prompt
0.1.4
Un sistema de gestión de inmediato validado y seguro para LLM que atrapa errores temprano, hace cumplir la seguridad de tipo y proporciona una forma estructurada de administrar las indicaciones. Utiliza modelos Pydantic para la validación variable y las plantillas Jinja2 para la representación rápida.
Nota : Esta biblioteca está en desarrollo temprano y está sujeta a cambios.
Siempre me ha encontrado difícil administrar indicaciones dinámicas para LLM. El proceso es propenso a errores, con problemas a menudo descubiertos solo en tiempo de ejecución. Tipeed-ProMPT tiene como objetivo resolver este problema proporcionando una forma estructurada de tipo seguro de administrar las indicaciones que captan errores temprano y aplican la seguridad de tipo.
Descargo de responsabilidad : este es un proyecto personal para resolver las quejas que he tenido en el pasado y no afiliado a ninguna organización. Es un trabajo en progreso y sujeto a cambios.
Agregaré más características y ejemplos en el futuro. Si tiene alguna sugerencia o retroalimentación, ¡no dude en abrir un problema!
from typed_prompt import BasePrompt
from pydantic import BaseModel
from typing import Optional
# Define your variables
class UserVars ( BaseModel ):
name : str
expertise : str
# This works - all template variables are defined
class ValidPrompt ( BasePrompt [ UserVars ]):
"""Helping {{name}} with {{expertise}} level knowledge."""
prompt_template : str = "Explain {{topic}} to me"
variables : UserVars
def render ( self , * , topic : str , ** extra_vars ) -> RenderOutput :
extra_vars [ "topic" ] = topic
return super (). render ( ** extra_vars )
# This fails immediately - 'unknown_var' not defined
class InvalidPrompt ( BasePrompt [ UserVars ]):
prompt_template : str = "What is {{unknown_var}}?" # ValueError!
variables : UserVars
# This fails - 'expertise' defined but never used
class UnusedVarPrompt ( BasePrompt [ UserVars ]):
prompt_template : str = "Hello {{name}}" # ValueError!
variables : UserVars from typing import Union
class TemplateVars ( BaseModel ):
user_type : Union [ "expert" , "beginner" ]
name : str
preferences : Optional [ dict ] = None
class ConditionalPrompt ( BasePrompt [ TemplateVars ]):
"""{% if user_type == 'expert' %}
Technical advisor for {{name}}
{% else %}
Friendly helper for {{name}}
{% endif %}"""
prompt_template : str = """
{% if preferences %}
Considering your preferences: {% for k, v in preferences.items() %}
- {{k}}: {{v}}{% endfor %}
{% endif %}
How can I help with {{topic}}?
"""
variables : TemplateVars
def render ( self , * , topic : str , ** extra_vars ) -> RenderOutput :
extra_vars [ "topic" ] = topic
return super (). render ( ** extra_vars ) from typed_prompt import RenderOutput
from pydantic import BaseModel , Field
class MyConfig ( BaseModel ):
temperature : float = Field ( default = 0.7 , ge = 0 , le = 2 )
model : str = Field ( default = "gpt-4" )
class MyPrompt ( BasePrompt [ UserVars ]):
"""Assistant for {{name}}"""
prompt_template : str = "Help with {{topic}}"
variables : UserVars
config : MyConfig = Field ( default_factory = MyConfig )
def render ( self , * , topic : str , ** extra_vars ) -> RenderOutput :
extra_vars [ "topic" ] = topic
return super (). render ( ** extra_vars )
# Use custom config
prompt = MyPrompt (
variables = UserVars ( name = "Alice" , expertise = "intermediate" ),
config = MyConfig ( temperature = 0.9 , model = "gpt-3.5-turbo" )
)Nota : Uso de ninguno como valor para variables opcionales se volverá como
Noneen el mensaje. por ejemplo, "prueba de prueba{{var}}hará comoTest example NonesivaresNone. Este es el comportamiento predeterminado de jinja. Por lo tanto, debe manejar esto en su plantilla Jinja2. Eg{{if var}}o{{var | default('default value')}}o sin embargo desea manejarlo.
La biblioteca valida sus plantillas de solicitud durante la definición de clase:
Todas las variables se validan a través de Pydantic:
Adjunte la configuración personalizada a las indicaciones:
Considere este ejemplo:
# Without typed-prompt
def create_prompt ( user_data ):
template = "Hello {{username}}, your level is {{level}}"
# Error only discovered when rendering with wrong data
return template . format ( ** user_data ) # KeyError at runtime!
# With typed-prompt
class UserPrompt ( BasePrompt [ UserVars ]):
prompt_template : str = "Hello {{unknown_var}}" # Error immediately!
variables : UserVarsLa biblioteca captura errores de plantilla en el momento de la definición.
uv add tpyed-prompto
pip install typed-promptPara obtener más ejemplos y documentación detallada, consulte el directorio de ejemplos.
Para ejecutar los ejemplos:
uv run python examples/user.pyTipeed-ProMPT utiliza una estructura indicada de dos partes que coincide con los patrones de interacción LLM comunes:
Solicitud del sistema : proporciona contexto o instrucciones para el modelo AI. Puedes definir esto de dos maneras:
system_prompt_template Solicitud del usuario : contiene la plantilla de solicitud real que se enviará al modelo. Esto siempre se define en el atributo de clase prompt_template .
Las variables en el proceso escrito se manejan a través de tres mecanismos complementarios:
Modelo de variables : un modelo pydantic que define las variables principales que sus necesidades rápidas:
class UserVariables ( BaseModel ):
name : str
age : int
occupation : Optional [ str ] = NoneParámetros del método de renderizado : las variables adicionales se pueden definir como argumentos de solo palabras clave en un método de renderizado personalizado:
def render ( self , * , learning_topic : str , ** extra_vars ) -> RenderOutput :
extra_vars [ "learning_topic" ] = learning_topic
return super (). render ( ** extra_vars )Variables adicionales : las variables únicas se pueden pasar directamente al método de renderizado.
La biblioteca realiza una validación integral para atrapar problemas comunes temprano:
Para indicaciones complejas, puede cargar plantillas de archivos externos:
class ComplexPrompt ( BasePrompt [ ComplexVariables ]):
system_prompt_template = Path ( "templates/system_prompt.j2" ). read_text ()
prompt_template : str = Path ( "templates/user_prompt.j2" ). read_text ()Nota : Con motores de plantilla como Jinja2, normalmente puede recargar plantillas de recarga, pero esto no es compatible con Tipeed-Prompt ya que las plantillas se validan en el momento de la definición de clase.
La clase fundamental para crear indicaciones estructuradas.
T : una subclase de base pydantic que define la estructura de las variables de plantilla system_prompt_template : opcional [str] - plantilla de solicitud del sistemaprompt_template : STR - Plantilla de solicitud del usuariovariables : t - instancia del modelo de variables render(**extra_vars) -> RenderOutput : Renders ambas indicaciones con variables proporcionadasUn NameTuple que proporciona acceso estructurado a las indicaciones renderizadas:
system_prompt : opcional [str]: la solicitud del sistema renderizadouser_prompt : STR: la solicitud de usuario renderizada Estructurar sus plantillas para la máxima legibilidad y mantenimiento:
Use documentos para las indicaciones del sistema : cuando sea posible, defina las indicaciones del sistema en las documentos de clase para una mejor organización de código:
class UserPrompt ( BasePrompt [ UserVariables ]):
"""You are having a conversation with {{name}}, a {{age}}-year-old {{occupation}}."""
prompt_template : str = "What would you like to discuss?"Plantillas complejas separadas : para plantillas más largas, use archivos externos:
system_prompt_template = Path ( "templates/system_prompt.j2" ). read_text ()Use la sintaxis condicional de Jinja2 para el contenido dinámico:
class DynamicPrompt ( BasePrompt [ Variables ]):
prompt_template : str = """
{% if expert_mode %}
Provide a detailed technical explanation of {{topic}}
{% else %}
Explain {{topic}} in simple terms
{% endif %}
""" ¡Las contribuciones son bienvenidas!
Este proyecto tiene licencia bajo la licencia MIT; consulte el archivo de licencia para obtener más detalles.
Las opciones aún se volverán como None en el aviso.
Haga que Jinja2 sea opcional, (para una plantilla muy simple, solo use el formato de cadena, por ejemplo f"Hello {name}" ). Tal vez debería haber comenzado más simple jajaja.
Salida OpenAI Objetos de mensajes compatibles.
La capacidad de definir, no solo un indicador del sistema y una sola rápida, sino cadenas rápidas. EG system_prompt -> user_prompt -> assistant_response -> user_prompt -> assistant_response -> ...
