lwe.backends.api Package

lwe.backends.api Subpackages

• lwe.backends.api.schema Package
  • lwe.backends.api.schema Submodules
  • lwe.backends.api.schema.updater module
    • SchemaUpdater
      • SchemaUpdater.add_revision()
      • SchemaUpdater.confirm_upgrade()
      • SchemaUpdater.get_current_schema_version()
      • SchemaUpdater.get_latest_version()
      • SchemaUpdater.init_alembic()
      • SchemaUpdater.is_versioning_initialized()
      • SchemaUpdater.run_migrations()
      • SchemaUpdater.set_config()
      • SchemaUpdater.stamp_database()
      • SchemaUpdater.update_schema()
  • lwe.backends.api.schema Module contents
• lwe.backends.api.workflow package
  • lwe.backends.api.workflow Subpackages
    • lwe.backends.api.workflow.action_plugins package
      • lwe.backends.api.workflow.action_plugins Submodules
      • lwe.backends.api.workflow.action_plugins.lwe_input module
      • lwe.backends.api.workflow.action_plugins Module contents
    • lwe.backends.api.workflow.library package
      • lwe.backends.api.workflow.library Submodules
      • lwe.backends.api.workflow.library.lwe_command module
      • lwe.backends.api.workflow.library.lwe_llm module
      • lwe.backends.api.workflow.library.lwe_sqlite_query module
      • lwe.backends.api.workflow.library.text_extractor module
      • lwe.backends.api.workflow.library Module contents
  • lwe.backends.api.workflow Module contents

lwe.backends.api Submodules

lwe.backends.api.backend module

class lwe.backends.api.backend.ApiBackend(config=None, orm=None)

Bases: object

Backend implementation using direct API access.

activate_preset(preset_name)

Activate a preset.

Parameters:

preset_name (str) – Name of preset

Returns:

success, preset, message

Return type:

tuple

ask(input: str, request_overrides: dict = None)

Ask the LLM a question and return response.

Parameters:

input (str) – The input to be sent to the LLM.

Request_overrides:

Overrides for this specific request.

Returns:

success, LLM response, message

Return type:

tuple

ask_stream(input: str, request_overrides: dict = None)

Ask the LLM a question and stream a response.

Parameters:

input (str) – The input to be sent to the LLM.

Request_overrides:

Overrides for this specific request.

Returns:

success, LLM response, message

Return type:

tuple

auto_create_first_user()

build_message_from_template(template_name, template_vars=None, overrides=None)

Builds the message from the template.

Parameters:

• template_name – Name of the template to run.

• template_vars – Optional dictionary of template variables.

• overrides – Optional dictionary of overrides.

Returns:

A tuple containing a success indicator, tuple of built message and overrides, and a user message.

close_log()

Close the current log file if one is open.

conversation_data_to_messages(conversation_data)

Convert conversation data to list of messages.

Parameters:

conversation_data (dict) – Conversation data dict

Returns:

List of messages

Return type:

list

delete_conversation(conversation_id=None)

Delete a conversation.

Parameters:

conversation_id (int, optional) – Conversation id, defaults to current

Returns:

success, conversation, message

Return type:

tuple

get_conversation(id=None)

Get a conversation.

Parameters:

id (int, optional) – Conversation id, defaults to current

Returns:

success, conversation dict, message

Return type:

tuple

get_current_conversation_title()

get_history(limit=20, offset=0, user_id=None)

Get conversation history.

Parameters:

• limit (int, optional) – Number of results, defaults to 20

• offset (int, optional) – Result offset, defaults to 0

• user_id (int, optional) – User id, defaults to current

Returns:

success, history dict, message

Return type:

tuple

get_providers()

Get available provider plugins.

get_runtime_config()

Get the runtime configuration.

Returns:

Runtime configuration

Return type:

str

get_system_message(system_message='default')

Get the system message.

Parameters:

system_message (str) – System message alias

Returns:

System message

Return type:

str

get_system_message_aliases()

Get system message aliases from config.

Returns:

Dict of message aliases

Return type:

dict

init_provider()

Initialize the default provider and model.

init_system_message()

Initialize the system message from config.

initialize_backend(config=None)

Initializes the backend with provided or default configuration, and sets up necessary attributes.

This method is safe to call for dynamically reloading backends.

Parameters:

config (dict, optional) – Backend configuration options

initialize_database()

initialize_file_logging()

Initialize file logging based on configuration.

load_conversation(conversation_id)

Load a conversation by id.

Parameters:

conversation_id (int) – Conversation id

load_default_conversation()

load_default_user()

load_user(identifier)

Load a user by id or username/email.

Parameters:

identifier (int, str) – User id or username/email

Raises:

Exception – If user not found

make_llm(customizations=None)

Creates a Language Model (llm) using the provider.

Parameters:

customizations – Optional dictionary for customizations.

Returns:

Language Model (llm) object.

make_preset()

Make preset from current provider customizations.

make_request(input, request_overrides: dict = None)

Ask the LLM a question, return and optionally stream a response.

Parameters:

input (str | list) – The input to be sent to the LLM, can be a string for a single user message, or a list of message dicts with ‘role’ and ‘content’ keys.

Request_overrides:

Overrides for this specific request.

Returns:

success, LLM response, message

Return type:

tuple

name = 'api'

new_conversation()

Start a new conversation.

open_log(filename)

Open a log file for writing.

reload_plugin(plugin_name)

Reload a plugin.

Parameters:

plugin_name (str) – Name of plugin

Returns:

success, plugin_instance, message

Return type:

tuple

restore_provider_state(previous_state)

Restore backend provider attributes after a failed provider change.

retrieve_old_messages(conversation_id=None, target_id=None)

Retrieve old messages for a conversation.

Parameters:

• conversation_id (int, optional) – Conversation id, defaults to current

• target_id (int, optional) – Target message id, defaults to None

Returns:

List of messages

Return type:

list

run_template(template_name, template_vars=None, overrides=None)

Runs the given template with the provided variables and overrides.

Parameters:

• template_name – Name of the template to run.

• template_vars – Optional dictionary of template variables, will merged with any set in the template.

• overrides – Optional dictionary of overrides, will be merged with any set in the template.

Returns:

The response tuple from the template run.

run_template_compiled(message, overrides=None)

Runs the compiled template.

Parameters:

• message – The message to be sent.

• overrides – Optional dictionary of overrides.

Returns:

The response tuple from LLM request.

run_template_setup(template_name, substitutions=None)

Sets up the run of a template.

Parameters:

• template_name – Name of the template to run.

• substitutions – Optional dictionary of substitutions.

Returns:

A tuple containing a success indicator, tuple of template setup data, and a user message.

set_available_models()

Sets the available models for the provider.

set_conversation_tokens(tokens)

Set current conversation token count.

Parameters:

tokens (int) – Number of conversation tokens

set_current_user(user=None)

Set the current user.

Parameters:

user (User, optional) – User object, defaults to None

Returns:

success, preset, message on preset activation, otherwise init the provider

Return type:

tuple

set_max_submission_tokens(max_submission_tokens=None)

Set the max submission tokens.

Parameters:

• max_submission_tokens (int) – Max submission tokens

• force (bool) – Force setting max submission tokens

set_model(model_name)

Set the active model.

Parameters:

model_name (str) – Name of model

Returns:

success, customizations, message

Return type:

tuple

set_provider(provider_name, customizations=None, reset=False)

Set the active provider plugin.

Parameters:

• provider_name (str) – Name of provider plugin

• customizations (dict, optional) – Customizations for provider, defaults to None

• reset (bool, optional) – Whether to reset provider, defaults to False

Returns:

success, provider, message

Return type:

tuple

set_return_only(return_only=False)

set_system_message(system_message='default')

Set the system message.

Parameters:

system_message (str) – System message or alias

set_title(title, conversation_id=None)

Set conversation title.

Parameters:

• title (str) – New title

• conversation_id (int, optional) – Conversation id, defaults to current

Returns:

success, conversation, message

Return type:

tuple

switch_to_conversation(conversation_id)

Switch to a conversation.

Parameters:

conversation_id (int) – Conversation id

terminate_stream(_signal, _frame)

Handles termination signal, passing it to the request if present.

Parameters:

• _signal – The signal that triggered the termination.

• _frame – Current stack frame.

write_log(prompt, response)

Write prompt and response to log file if logging is enabled.

write_log_context()

Write current conversation context to log file if logging is enabled.

lwe.backends.api.conversation module

class lwe.backends.api.conversation.ConversationManager(config=None, orm=None)

Bases: Manager

add_conversation(user_id, title=None, hidden=False)

delete_conversation(conversation_id)

edit_conversation(conversation_id, **kwargs)

edit_conversation_title(conversation_id, new_title)

get_conversation(conversation_id)

get_conversations(user_id, limit=None, offset=None, order_desc=True)

hide_conversation(conversation_id)

unhide_conversation(conversation_id)

lwe.backends.api.conversation_storage_manager module

class lwe.backends.api.conversation_storage_manager.ConversationStorageManager(config, tool_manager, current_user=None, conversation_id=None, provider=None, model_name=None, preset_name=None, provider_manager=None, orm=None)

Bases: object

Manage conversation storage.

add_message(role, message, message_type, metadata)

Add a new message to a conversation.

Parameters:

• role (str) – Message role

• message (str) – Message content

• message_type (str) – Message type

• metadata (dict) – Message metadata

Returns:

success, added message, user message

Return type:

tuple

add_new_messages_to_conversation(new_messages, title=None)

Add new messages to a conversation.

Parameters:

• new_messages (list) – New messages

• title (str, optional) – Conversation title, defaults to None

Returns:

Conversation, last message

Return type:

tuple

create_new_conversation_if_needed(title=None)

Create new conversation if it doesn’t exist.

Parameters:

title (str, optional) – Conversation title, defaults to None

Returns:

Conversation object

Return type:

Conversation

gen_title(conversation)

Generate the title for a conversation.

Parameters:

conversation (Conversation) – Conversation

gen_title_thread(conversation_id)

Generate the title for a conversation in a separate thread.

Parameters:

conversation_id (int) – Conversation ID

get_conversation_token_count()

Get token count for conversation.

Returns:

Number of tokens

Return type:

int

get_title_provider_llm()

Get the title provider and LLM.

Returns:

provider, llm

Return type:

tuple

store_conversation_messages(new_messages, response_content=None, title=None)

Store conversation messages.

Parameters:

• new_messages (list) – New messages

• response_content (str) – Response content

• title (str, optional) – Title

Returns:

success, conversation or response_content, message

Return type:

tuple

lwe.backends.api.database module

class lwe.backends.api.database.Database(config, orm=None)

Bases: object

create_schema()

remove_schema()

schema_exists()

class lwe.backends.api.database.DatabaseDevel(config, args)

Bases: Database

create_test_data()

print_data()

run()

lwe.backends.api.database.main()

lwe.backends.api.message module

class lwe.backends.api.message.MessageManager(config=None, orm=None)

Bases: Manager

add_message(conversation_id, role, message, message_type=None, message_metadata=None, provider=None, model=None, preset=None)

build_message(role, message, message_type='content', message_metadata=None)

delete_message(message_id)

get_last_message(conversation_id)

get_message(message_id)

get_messages(conversation_id, limit=None, offset=None, target_id=None)

message_from_storage(message)

message_to_storage(message, message_type, message_metadata)

lwe.backends.api.orm module

class lwe.backends.api.orm.Conversation(**kwargs)

Bases: Base

created_time

hidden

id

messages

title

updated_time

user

user_id

class lwe.backends.api.orm.Manager(config=None, orm=None)

Bases: object

orm_add_conversation(user, title, hidden=False)

orm_add_message(conversation, role, message, message_type, message_metadata, provider, model, preset)

orm_add_user(username, password, email, default_preset='', preferences=None)

orm_delete_conversation(conversation)

orm_delete_message(message)

orm_delete_user(user)

orm_edit_conversation(conversation, **kwargs)

orm_edit_message(message, **kwargs)

orm_edit_user(user, **kwargs)

orm_get_conversation(conversation_id)

orm_get_conversations(user, limit=20, offset=None, order_desc=True)

orm_get_last_message(conversation)

orm_get_message(message_id)

orm_get_messages(conversation, limit=None, offset=None, target_id=None)

orm_get_user(user_id)

orm_get_users(limit=None, offset=None)

class lwe.backends.api.orm.Message(**kwargs)

Bases: Base

conversation

conversation_id

created_time

id

message

message_metadata

message_type

model

preset

provider

role

class lwe.backends.api.orm.Orm(config=None)

Bases: object

create_engine_and_metadata()

object_as_dict(obj)

class lwe.backends.api.orm.User(**kwargs)

Bases: Base

conversations

created_time

default_preset

email

id

last_login_time

password

preferences

username

lwe.backends.api.repl module

class lwe.backends.api.repl.ApiRepl(config=None)

Bases: Repl

A shell interpreter that serves as a front end to the ApiBackend class

action_preset_delete(preset_name=None)

Deletes an existing preset

Parameters:

preset_name (str) – Required. The name of the preset to delete

Returns:

A tuple containing the success status, the preset name, and a user message

Return type:

tuple

action_preset_edit(preset_name=None)

Edit an existing preset

Parameters:

preset_name (str) – Required. The name of the preset

Returns:

A tuple containing the success status, the preset name, and a user message

Return type:

tuple

action_preset_load(preset_name=None)

Load an existing preset

This activates the provider and model customizations stored in the preset as the current configuration.

Parameters:

preset_name (str) – Required. The name of the preset to load.

Returns:

A tuple containing the success status, the preset, and a user message

Return type:

tuple

action_preset_save(*args)

Create a new preset, or update an existing preset

Parameters:

args (tuple) – The arguments passed to the method, first must be the preset name, second is the metadata name, and others are the metadata value to be saved

Returns:

A tuple containing the success status, the preset, and a user message

Return type:

tuple

action_preset_show(preset_name=None)

Display a preset

Parameters:

preset_name (str) – Optional. The name of the preset to show (default: active preset)

Returns:

A tuple containing the success status, the preset, and a user message

Return type:

tuple

action_user_delete(username=None)

Delete a user

Parameters:

username (str) – The username of the user to be deleted

Returns:

A tuple containing the success status, user object, and a message

Return type:

tuple[bool, User, str]

action_user_edit(username=None)

Edit the current user’s information

Parameters:

username (str) – The username of the user to edit, if not provided, the logged in user will be used.

Returns:

The result of the edit_user method

Return type:

Any

action_user_login(identifier=None)

Login in as a user

If the ‘identifier’ argument is not provided, you will be prompted for either a username or email. You will be prompted for a password if one is set for the user.

Parameters:

identifier (str) – The username or email

Returns:

A tuple containing the success status, user object, and a message

Return type:

tuple[bool, User, str]

action_user_logout()

Logout the current user.

Returns:

A tuple containing the success status, None, and a message

Return type:

tuple[bool, None, str]

action_user_register(username=None)

Register a new user

If the ‘username’ argument is not provided, you will be prompted for it.

You will also be prompted for:

email: Optional, valid email password: Optional, if given will be required for login

Parameters:

username (str) – The username of the new user

Returns:

A tuple containing the success status, user object, and a message

Return type:

tuple[bool, User, str]

action_user_show(username=None)

Show user information

Parameters:

username (str) – The username of the user to show, if not provided, the logged in user will be used.

Returns:

The result of the display_user method

Return type:

Any

action_workflow_copy(*workflow_names)

Copies an existing workflow and saves it as a new workflow

Arguments:

workflow_names: Required. The name of the old and new workflows separated by whitespace,

Examples:

{COMMAND} old_workflow new_workflow

action_workflow_delete(workflow_name=None)

Deletes an existing workflow

Arguments:

workflow_name: Required. The name of the workflow to delete

Examples:

{COMMAND} myworkflow

action_workflow_edit(workflow_name=None)

Create a new workflow, or edit an existing workflow

Arguments:

workflow_name: Required. The name of the workflow

Examples:

{COMMAND} myworkflow

action_workflow_run(*args)

Run a workflow

Arguments:

workflow_name: Required. The name of the workflow variables: Space-separated list of additional variables to pass to the workflow

Examples:

{COMMAND} myworkflow {COMMAND} myworkflow foo=bar baz=”bang bong”

action_workflow_show(workflow_name=None)

Display a workflow

Arguments:

workflow_name: Required. The name of the workflow

Examples:

{COMMAND} myworkflow

add_examples()

Add example configurations

Returns:

None

build_shell_user_prefix()

Build the prefix for the shell prompt

Returns:

The prefix for the shell prompt

Return type:

str

check_login()

Check if a user is logged in

Returns:

None

command_login(identifier=None)

Alias of ‘{COMMAND_LEADER}user-login’

Login in as a user.

Parameters:

identifier (str) – The username or email

Returns:

The result of the action_user_login method

Return type:

Any

command_logout(_)

Alias of ‘{COMMAND_LEADER}user-logout’

Logout the current user.

Parameters:

_ – Unused argument

Returns:

The result of the action_user_logout method

Return type:

Any

command_max_submission_tokens(max_submission_tokens=None)

The maximum number of tokens that can be submitted to the model.

For chat-based providers, this will be used to truncate earlier messages in the conversation to keep the total number of tokens within the set value.

For non-chat-based providers, this value can only be viewed, if available.

If the provider configuration specifies a max tokens value for a model, it will be used. Otherwise, a default value of {OPEN_AI_MAX_TOKENS} will be used.

Arguments:

max_submission_tokens: An integer between {OPEN_AI_MIN_SUBMISSION_TOKENS} and the maximum value a model can accept. (chat providers only)

With no arguments, view the current max submission tokens.

Examples:

{COMMAND} {COMMAND} 256

command_preset(args)

Run actions on presets

Presets are saved provider/model configurations.

Available actions:

• delete: Delete a preset

• load: Load a preset (makes it the active preset)

• edit: Open a preset for editing

• save: Save the existing configuration to a preset, and/or set metadata on the preset

• show: Show a preset

Arguments:

preset_name: Required. The name of the preset.

Examples:

• /preset delete mypreset

• /preset load mypreset

• /preset edit mypreset

• /preset save mypreset

• /preset save mypreset description This is my description

• /preset save mypreset system_message Speak like a pirate

• /preset save mypreset max_submission_tokens 4000

• /preset save mypreset return_on_tool_call true

• /preset save mypreset return_on_tool_response true

• /preset save mypreset max_submission_tokens (without value, setting is deleted)

• /preset show mypreset

command_presets(arg)

List available presets

Preset are pre-configured provider/model configurations that can be stored and loaded for convenience.

They are located in the ‘presets’ directory in the following locations:

• The main configuration directory

• The profile configuration directory

See {COMMAND_LEADER}config for current locations.

Arguments:

filter_string: Optional. If provided, only presets with a name or description containing the filter string will be shown.

Examples:

{COMMAND} {COMMAND} filterstring

command_provider(arg)

View or set the current LLM provider

Arguments:

provider: The name of the provider to set. model_name: Optional. The model to initialize the provider with. With no arguments, view current set model attributes

Examples:

{COMMAND} {COMMAND} chat_openai {COMMAND} chat_openai gpt-4o

command_providers(arg)

List currently enabled providers

Examples:

{COMMAND}

command_system_message(alias=None)

Set the system message sent for conversations.

The system message helps set the behavior of the assistant. Conversations begin with a system message to gently instruct the assistant.

Arguments:

system_message: String, or a system message alias name from the configuration.

The special string ‘default’ will reset the system message to its default value. With no arguments, show the currently set system message.

Examples:

{COMMAND} {COMMAND} {SYSTEM_MESSAGE_DEFAULT}

command_tools(arg)

List available tools

Tools are pieces of Python code that the LLM can request to be called to perform some action.

They are located in the ‘tools’ directory in the following locations:

• The main configuration directory

• The profile configuration directory

See {COMMAND_LEADER}config for current locations.

Arguments:

filter_string: Optional. If provided, only tools with a name or description containing the filter string will be shown.

Examples:

{COMMAND} {COMMAND} filterstring

command_user(args)

Run actions on users

Available actions:

• delete: Delete a user

• edit: Edit a user

• login: Log in a user

• logout: Log out a user

• register: Register a new user

• show: Show a user

Arguments:

user_name: Optional, will be prompted for if necessary, defaults to currently logged in user

When registering, you can optionally supply email/password – no password is passwordless login.

Login can be username or email.

Examples:

• {COMMAND} delete [myuser]

• {COMMAND} edit [myuser]

• {COMMAND} login [myuser]

• {COMMAND} logout

• {COMMAND} register [myuser]

• {COMMAND} show [myuser]

command_users(_)

Show information for all users

Parameters:

_ – Unused argument

Returns:

The result of the user_management.get_users method

Return type:

Any

command_workflow(args)

Run actions on workflows

Workflows enable multi-step interaction with LLMs, with simple decision-making abilities.

Available actions:

• copy: Copy a workflow

• delete: Delete a workflow

• edit: Open or create a workflow for editing

• run: Run a workflow

• show: Show a workflow

Arguments:

workflow_name: Required. The name of the workflow.

For copy, a new workflow name is also required.

For run, arguments may be supplied in key=value format, these will override default vars in the workflow.

Examples:

• /workflow copy myworkflow myworkflow_copy

• /workflow delete myworkflow

• /workflow edit myworkflow

• /workflow run myworkflow

• /workflow run myworkflow argument=”some value”

• /workflow show myworkflow

command_workflows(arg)

List available workflows

Workflows enable multi-step interaction with LLMs, with simple decision-making abilities.

They are located in the ‘workflows’ directory in the following locations, and searched in this order:

• The profile configuration directory

• The main configuration directory

• The core workflows directory

See {COMMAND_LEADER}config for current locations of the configuration and profile directories.

Arguments:

filter_string: Optional. If provided, only workflows with a name or description containing the filter string will be shown.

Examples:

{COMMAND} {COMMAND} filterstring

configure_backend()

configure_shell_commands()

create_first_user()

Create the first user

Returns:

None

display_user(user)

Display user information

Parameters:

user (User) – The user object to display information for

Returns:

None

edit_user(user)

Edit user information

Parameters:

user (User) – The user object to edit

Returns:

A tuple containing the success status, user object, and a message

Return type:

tuple[bool, User, str]

exec_prompt_pre(command, arg)

get_current_conversation_title()

Get the title of the current conversation

Returns:

The title of the current conversation

Return type:

str

get_custom_shell_completions()

get_model_temperature()

Get the temperature of the model

Returns:

The temperature of the model

Return type:

str

get_set_backend_setting(value_type, setting, value, min=None, max=None)

get_user(user_id)

launch_backend(interactive=True)

login(user)

Log in as a user

Parameters:

user (User) – The user to log in as

Returns:

A tuple containing the success status, user object, and a message

Return type:

tuple[bool, User, str]

not_logged_in_disallowed_commands()

select_preset(allow_empty=False)

set_logged_in_user(user=None)

Set the logged in user

Parameters:

user (User) – The user object to set as the logged in user

Returns:

None

validate_email(email)

welcome_message()

Print the welcome message

Returns:

None

lwe.backends.api.request module

class lwe.backends.api.request.ApiRequest(config=None, provider=None, provider_manager=None, tool_manager=None, input=None, preset=None, preset_manager=None, system_message=None, old_messages=None, max_submission_tokens=None, request_overrides=None, return_only=False, orm=None)

Bases: object

Individual LLM requests manager

attach_files(messages)

build_chat_request(messages)

Build chat request for LLM.

Parameters:

messages (list) – Messages

Returns:

Prepared messages

Return type:

list

build_request_config(config)

build_tool_response_message(tool_call, tool_response)

call_llm(messages)

Call the LLM.

Parameters:

messages (list) – Messages

Returns:

success, response, message

Return type:

tuple

check_forced_tool()

Check if a tool call is forced.

Returns:

True if forced tool

Return type:

bool

check_return_on_tool_response(new_messages)

Check for return on tool response.

Supports multiple tool calls.

Parameters:

new_messages (list) – List of new messages

Returns:

Tool response or None, updated messages

Return type:

tuple

execute_llm_non_streaming(messages)

execute_llm_streaming(messages)

execute_tool_call(tool_call)

execute_tool_calls(tool_calls, new_messages)

expand_tools(customizations)

Expand any configured tools to their full definition.

Parameters:

customizations (dict) – Model customizations

Returns:

customizations, tools, tool_choice

Return type:

tuple

extract_message_content(message)

Extract the content from an LLM message.

Parameters:

message (dict | BaseMessage) – Message

Returns:

Built message, tool calls

Return type:

tuple

extract_metadata_customizations()

get_preset_metadata_customizations(preset_name)

handle_non_tool_response(response_message, new_messages)

handle_tool_calls(tool_calls, new_messages)

is_tool_response_message(message)

Check if a message is a tool response.

Parameters:

message (dict) – The message

Returns:

True if tool response

Return type:

bool

iterate_streaming_response(messages, print_stream, stream_callback)

load_provider(config)

log_tool_call(tool_call)

merge_preset_overrides(config)

output_chunk_content(content, print_stream, stream_callback)

post_response(response_obj, new_messages)

prepare_ask_request()

Prepare the request for the LLM.

Returns:

New messages, messages

Return type:

tuple

prepare_config(config)

prepare_custom_new_conversation_messages()

Prepare custom new conversation messages.

Returns:

List of new messages

Return type:

list

prepare_default_new_conversation_messages()

Prepare default new conversation messages.

Returns:

List of new messages

Return type:

list

prepare_new_conversation_messages()

Prepare new conversation messages.

Returns:

List of new messages

Return type:

list

run_tool(tool_name, data)

Run a tool.

Parameters:

• tool_name (str) – Tool name

• data (dict) – Tool arguments

Returns:

success, response, message

Return type:

tuple

set_request_llm()

setup_request_config(preset_name=None, preset_overrides=None, metadata=None, customizations=None)

Set up the configuration for the request.

Parameters:

• preset_name (str, optional) – Override preset name

• preset_overrides (dict, optional) – Overrides for preset, defaults to None

• metadata (dict, optional) – Preset metadata

• customizations (dict, optional) – Provider/model customizations

Returns:

success, llm, message

Return type:

tuple

should_return_on_tool_call()

Check if should return on tool call.

Returns:

Whether to return on tool call

Return type:

bool

strip_out_messages_over_max_tokens(messages, max_tokens)

Recursively strip out messages over max tokens.

Parameters:

• messages (list) – Messages

• max_tokens (int) – Max tokens

Returns:

Messages

Return type:

list

terminate_stream(_signal, _frame)

Handles termination signal and stops the stream if it’s running.

lwe.backends.api.user module

class lwe.backends.api.user.UserManager(config=None, orm=None)

Bases: Manager

delete_user(user_id)

edit_user(user_id, username=None, email=None, password=None, default_preset=None)

get_by_user_id(user_id)

get_by_username(username)

get_by_username_or_email(identifier)

get_users(limit=None, offset=None)

login(identifier, password)

logout(user_id)

register(username, email, password, default_preset='', preferences=None)

user_found_message(user)

lwe.backends.api Module contents