haive.core.engine.aug_llm.config

AugLLM configuration system for enhanced LLM chains.

from typing import Any, Dict This module provides a comprehensive configuration system for creating and managing enhanced LLM chains within the Haive framework. The AugLLMConfig class serves as a central configuration point that integrates prompts, tools, output parsers, and structured output models with extensive validation and debugging capabilities.

Key features: - Flexible prompt template creation and management with support for few-shot learning - Comprehensive tool integration with automatic discovery and configuration - Structured output handling via two approaches (v1: parser-based, v2: tool-based) - Rich debugging and validation to ensure proper configuration - Pre/post processing hooks for customizing input and output - Support for both synchronous and asynchronous execution

The configuration system is designed to be highly customizable while providing sensible defaults and automatic detection of configuration requirements.

Classes

AugLLMConfig

Configuration for creating enhanced LLM chains with flexible message handling.

Functions

debug_print(*args, **kwargs)

Print debug output only if DEBUG_OUTPUT is enabled.

Module Contents

class haive.core.engine.aug_llm.config.AugLLMConfig

Bases: *_get_augllm_base_classes()

Configuration for creating enhanced LLM chains with flexible message handling.

AugLLMConfig provides a structured way to configure and create LLM chains with prompts, tools, output parsers, and structured output models with comprehensive validation and automatic updates. It serves as the central configuration class for language model interactions in the Haive framework.

This class integrates several key functionalities: 1. Prompt template management with support for few-shot learning 2. Tool integration and discovery with automatic routing 3. Structured output handling (both parser-based and tool-based approaches) 4. Message handling for chat-based LLMs 5. Pre/post processing hooks for customization

The configuration system is designed to be highly flexible while enforcing consistent patterns and proper validation, making it easier to create reliable language model interactions.

engine_type

The type of engine (always LLM).

Type:

EngineType

llm_config

Configuration for the LLM provider.

Type:

LLMConfig

prompt_template

Template for structuring prompts.

Type:

Optional[BasePromptTemplate]

system_message

System message for chat models.

Type:

Optional[str]

tools

Tools that can be bound to the LLM.

Type:

Sequence[Union[Type[BaseTool], Type[BaseModel], Callable, StructuredTool, BaseModel]]

structured_output_model

Pydantic model for structured outputs.

Type:

Optional[Type[BaseModel]]

structured_output_version

Version of structured output handling (v1: parser-based, v2: tool-based).

Type:

Optional[StructuredOutputVersion]

temperature

Temperature parameter for the LLM.

Type:

Optional[float]

max_tokens

Maximum number of tokens to generate.

Type:

Optional[int]

preprocess

Function to preprocess input before sending to LLM.

Type:

Optional[Callable]

postprocess

Function to postprocess output from LLM.

Type:

Optional[Callable]

Examples

>>> from haive.core.engine.aug_llm.config import AugLLMConfig
>>> from haive.core.models.llm.base import AzureLLMConfig
>>> from pydantic import BaseModel, Field
>>>
>>> # Define a structured output model
>>> class MovieReview(BaseModel):
...     title: str = Field(description="Title of the movie")
...     rating: int = Field(description="Rating from 1-10")
...     review: str = Field(description="Detailed review of the movie")
>>>
>>> # Create a basic configuration
>>> config = AugLLMConfig(
...     name="movie_reviewer",
...     llm_config=AzureLLMConfig(model="gpt-4"),
...     system_message="You are a professional movie critic.",
...     structured_output_model=MovieReview,
...     temperature=0.7
... )
>>>
>>> # Create a runnable from the configuration
>>> reviewer = config.create_runnable()
>>>
>>> # Use the runnable
>>> result = reviewer.invoke("Review the movie 'Inception'")

add_format_instructions(model=None, as_tools=False, var_name='format_instructions')

Add format instructions to partial_variables without changing structured output configuration.

Parameters:

• model (type[pydantic.BaseModel] | None)

• as_tools (bool)

• var_name (str)

Return type:

AugLLMConfig

add_human_message(content)

Add a human message to the prompt template.

Parameters:

content (str)

Return type:

AugLLMConfig

add_optional_variable(var_name)

Add an optional variable to the prompt template.

Parameters:

var_name (str)

Return type:

AugLLMConfig

add_prompt_template(prompt_template)

Add a prompt template to the configuration.

Parameters:

prompt_template (langchain_core.prompts.BasePromptTemplate)

Return type:

AugLLMConfig

add_system_message(content)

Add or update system message in the prompt template.

Parameters:

content (str)

Return type:

AugLLMConfig

add_tool(tool, name=None, route=None)

Add a single tool with optional name and route.

Parameters:

• tool (Any)

• name (str | None)

• route (str | None)

Return type:

AugLLMConfig

add_tool_with_route(tool, route, name=None, metadata=None)

Add a tool with explicit route and metadata.

Parameters:

• tool (Any)

• route (str)

• name (str | None)

• metadata (dict[str, Any] | None)

Return type:

AugLLMConfig

apply_runnable_config(runnable_config=None)

Extract parameters from runnable_config relevant to this engine.

Parameters:

runnable_config (langchain_core.runnables.RunnableConfig | None)

Return type:

dict[str, Any]

clear_tools()

Clear all tools.

Returns:

Self for method chaining

Return type:

AugLLMConfig

comprehensive_validation_and_setup()

Comprehensive validation and setup after initialization.

Return type:

Self

create_runnable(runnable_config=None)

Create a runnable LLM chain based on this configuration.

Parameters:

runnable_config (langchain_core.runnables.RunnableConfig | None)

Return type:

langchain_core.runnables.Runnable

create_tool_from_config(config, name=None, route=None, **kwargs)

Create a tool from another config object.

Parameters:

• config (Any) – Configuration object that has a to_tool method

• name (str | None) – Tool name

• route (str | None) – Tool route to set

• **kwargs – Additional kwargs for tool creation

Returns:

Created tool

Return type:

Any

debug_tool_configuration()

Print detailed debug information about tool configuration.

Return type:

AugLLMConfig

classmethod default_schemas_to_tools(data)

Default schemas to tools if schemas isn’t provided but tools has values.

Parameters:

data (dict[str, Any])

classmethod ensure_structured_output_as_tool(data)

Ensure structured output model is properly configured for both v1 and v2.

Parameters:

data (dict[str, Any])

classmethod from_few_shot(examples, example_prompt, prefix, suffix, input_variables, llm_config=None, **kwargs)

Create with few-shot examples.

Parameters:

• examples (list[dict[str, Any]])

• example_prompt (langchain_core.prompts.PromptTemplate)

• prefix (str)

• suffix (str)

• input_variables (list[str])

• llm_config (haive.core.models.llm.base.LLMConfig | None)

classmethod from_few_shot_chat(examples, example_prompt, system_message=None, llm_config=None, **kwargs)

Create with few-shot examples for chat templates.

Parameters:

• examples (list[dict[str, Any]])

• example_prompt (langchain_core.prompts.ChatPromptTemplate)

• system_message (str | None)

• llm_config (haive.core.models.llm.base.LLMConfig | None)

classmethod from_format_instructions(model, system_message=None, llm_config=None, as_tool=False, var_name='format_instructions', **kwargs)

Create config with format instructions but without structured output.

Parameters:

• model (type[pydantic.BaseModel])

• system_message (str | None)

• llm_config (haive.core.models.llm.base.LLMConfig | None)

• as_tool (bool)

• var_name (str)

classmethod from_llm_config(llm_config, **kwargs)

Create from an existing LLMConfig.

Parameters:

llm_config (haive.core.models.llm.base.LLMConfig)

classmethod from_prompt(prompt, llm_config=None, **kwargs)

Create from a prompt template.

Parameters:

• prompt (langchain_core.prompts.BasePromptTemplate)

• llm_config (haive.core.models.llm.base.LLMConfig | None)

classmethod from_pydantic_tools(tool_models, system_message=None, llm_config=None, include_instructions=True, force_tool_use=False, **kwargs)

Create with Pydantic tool models.

Parameters:

• tool_models (list[type[pydantic.BaseModel]])

• system_message (str | None)

• llm_config (haive.core.models.llm.base.LLMConfig | None)

• include_instructions (bool)

• force_tool_use (bool)

classmethod from_structured_output_v1(model, system_message=None, llm_config=None, include_instructions=True, **kwargs)

Create with v1 structured output using traditional parsing.

Parameters:

• model (type[pydantic.BaseModel])

• system_message (str | None)

• llm_config (haive.core.models.llm.base.LLMConfig | None)

• include_instructions (bool)

classmethod from_structured_output_v2(model, system_message=None, llm_config=None, include_instructions=False, output_field_name=None, **kwargs)

Create with v2 structured output using the tool-based approach.

Parameters:

• model (type[pydantic.BaseModel])

• system_message (str | None)

• llm_config (haive.core.models.llm.base.LLMConfig | None)

• include_instructions (bool)

• output_field_name (str | None)

classmethod from_system_and_few_shot(system_message, examples, example_prompt, prefix, suffix, input_variables, llm_config=None, **kwargs)

Create with system message and few-shot examples.

Parameters:

• system_message (str)

• examples (list[dict[str, Any]])

• example_prompt (langchain_core.prompts.PromptTemplate)

• prefix (str)

• suffix (str)

• input_variables (list[str])

• llm_config (haive.core.models.llm.base.LLMConfig | None)

classmethod from_system_prompt(system_prompt, llm_config=None, **kwargs)

Create from a system prompt string.

Parameters:

• system_prompt (str)

• llm_config (haive.core.models.llm.base.LLMConfig | None)

classmethod from_tools(tools, system_message=None, llm_config=None, use_tool_for_format_instructions=None, force_tool_use=False, **kwargs)

Create with specified tools.

Parameters:

• tools (list[langchain_core.tools.BaseTool | type[langchain_core.tools.BaseTool] | str | type[pydantic.BaseModel]])

• system_message (str | None)

• llm_config (haive.core.models.llm.base.LLMConfig | None)

• use_tool_for_format_instructions (bool | None)

• force_tool_use (bool)

get_active_template()

Get the name of the currently active template.

Return type:

str | None

get_format_instructions(model=None, as_tools=False)

Get format instructions for a model without changing the config.

Parameters:

• model (type[pydantic.BaseModel] | None)

• as_tools (bool)

Return type:

str

get_input_fields()

Get schema fields for input.

Return type:

dict[str, tuple[type, Any]]

get_output_fields()

Get schema fields for output.

Return type:

dict[str, tuple[type, Any]]

instantiate_llm()

Instantiate the LLM based on the configuration.

Return type:

Any

list_prompt_templates()

List available template names.

Return type:

list[str]

model_post_init(__context)

Proper Pydantic post-initialization.

Return type:

None

remove_message(index)

Remove a message from the prompt template.

Parameters:

index (int)

Return type:

AugLLMConfig

remove_prompt_template(name=None)

Remove a template or disable the active one.

Parameters:

name (str | None) – Template name to remove. If None, disables active template.

Returns:

Self for method chaining

Return type:

AugLLMConfig

remove_tool(tool)

Remove a tool and update all related configurations.

Parameters:

tool (Any)

Return type:

AugLLMConfig

replace_message(index, message)

Replace a message in the prompt template.

Parameters:

• index (int)

• message (str | langchain_core.messages.BaseMessage)

Return type:

AugLLMConfig

classmethod set_default_structured_output_version(data)

Set default structured output version to v2 (tools) when model is provided but version is not.

Parameters:

data (dict[str, Any])

use_prompt_template(name)

Switch to using a specific named template.

Parameters:

name (str) – Name of the template to activate

Returns:

Self for method chaining

Raises:

ValueError – If template name not found

Return type:

AugLLMConfig

classmethod validate_prompt_template(v)

Validate and reconstruct prompt template from dict data.

Return type:

Any

classmethod validate_schemas(v)

Validate and auto-name schemas.

Return type:

Any

classmethod validate_structured_output_model(v)

Validate structured output model and default to tools-based validation.

Return type:

Any

classmethod validate_tools(v)

Validate and auto-name tools.

Return type:

Any

with_format_instructions(model, as_tool=False, var_name='format_instructions')

Add format instructions without setting up structured output or parser.

Parameters:

• model (type[pydantic.BaseModel])

• as_tool (bool)

• var_name (str)

Return type:

AugLLMConfig

with_pydantic_tools(tool_models, include_instructions=True, force_use=False)

Configure with Pydantic tools output parsing.

Parameters:

• tool_models (list[type[pydantic.BaseModel]])

• include_instructions (bool)

• force_use (bool)

Return type:

AugLLMConfig

with_structured_output(model, include_instructions=True, version='v2')

Configure with Pydantic structured output.

Parameters:

• model (type[pydantic.BaseModel])

• include_instructions (bool)

• version (str)

Return type:

AugLLMConfig

with_tools(tools, force_use=False, specific_tool=None)

Configure with specified tools.

Parameters:

• tools (list[type[langchain_core.tools.BaseTool] | type[pydantic.BaseModel] | collections.abc.Callable | langchain_core.tools.StructuredTool | langchain_core.tools.BaseTool | str])

• force_use (bool)

• specific_tool (str | None)

Return type:

AugLLMConfig

haive.core.engine.aug_llm.config.debug_print(*args, **kwargs)

Print debug output only if DEBUG_OUTPUT is enabled.

Return type:

None