Feat/llm responses

.env_file

@@ -1,4 +1,6 @@
 TG_BOT_TOKEN=token
+OPENAI_API_KEY=api_key
+ANTHROPIC_API_KEY=api_key
 MYSQL_USERNAME=root
 MYSQL_PASSWORD=pass
 MYSQL_ROOT_PASSWORD=pass

chatsky/__rebuild_pydantic_models__.py

@@ -9,6 +9,7 @@
 from chatsky.core.ctx_dict import ContextDict
 from chatsky.core.ctx_utils import ServiceState, FrameworkData, ContextMainInfo
 from chatsky.core.service import PipelineComponent
+from chatsky.llm import LLM_API
 
 ContextMainInfo.model_rebuild()
 ContextDict.model_rebuild()

chatsky/conditions/__init__.py

@@ -11,3 +11,4 @@
 )
 from chatsky.conditions.slots import SlotsExtracted
 from chatsky.conditions.service import ServiceFinished
+from chatsky.conditions.llm import LLMCondition

chatsky/conditions/llm.py

@@ -0,0 +1,77 @@
+"""
+LLM Conditions
+--------------
+This module provides LLM-based conditions.
+"""
+
+from pydantic import Field
+from typing import Optional
+
+from chatsky.core import BaseCondition, Context
+from chatsky.core.script_function import AnyResponse
+from chatsky.llm.methods import BaseMethod
+from chatsky.llm.langchain_context import get_langchain_context
+from chatsky.llm.filters import BaseHistoryFilter, DefaultFilter
+from chatsky.llm.prompt import PositionConfig, Prompt
+
+
+class LLMCondition(BaseCondition):
+    """
+    LLM-based condition.
+    Uses prompt to produce result from model and evaluates the result using given method.
+    """
+
+    llm_model_name: str
+    """
+    Key of the model in the :py:attr:`~chatsky.core.pipeline.Pipeline.models` dictionary.
+    """
+    prompt: AnyResponse = Field(default="", validate_default=True)
+    """
+    Condition prompt.
+    """
+    history: int = 1
+    """
+    Number of dialogue turns aside from the current one to keep in history. `-1` for full history.
+    """
+    filter_func: BaseHistoryFilter = Field(default_factory=DefaultFilter)
+    """
+    Filter function to filter messages in history.
+    """
+    prompt_misc_filter: str = Field(default=r"prompt")
+    """
+    Regular expression to find prompts by key names in MISC dictionary.
+    """
+    position_config: Optional[PositionConfig] = None
+    """
+    Config for positions of prompts and messages in history.
+    """
+    max_size: int = 5000
+    """
+    Maximum size of any message in chat in symbols.
+    If a message exceeds the limit it will not be sent to the LLM and a warning
+    will be produced.
+    """
+    method: BaseMethod
+    """
+    Method that takes model's output and returns boolean.
+    """
+
+    async def call(self, ctx: Context) -> bool:
+        model = ctx.pipeline.models[self.llm_model_name]
+
+        history_messages = []
+        history_messages.extend(
+            await get_langchain_context(
+                system_prompt=await model.system_prompt(ctx),
+                ctx=ctx,
+                call_prompt=Prompt(message=self.prompt),
+                prompt_misc_filter=self.prompt_misc_filter,
+                position_config=self.position_config or model.position_config,
+                length=self.history,
+                filter_func=self.filter_func,
+                llm_model_name=self.llm_model_name,
+                max_size=self.max_size,
+            )
+        )
+
+        return await model.condition(history_messages, self.method)

chatsky/core/pipeline.py

@@ -8,10 +8,11 @@
 including :py:class:`.Actor`.
 """
 
+from __future__ import annotations
 import asyncio
 import logging
 from functools import cached_property
-from typing import Union, List, Optional
+from typing import Union, List, Dict, Optional, TYPE_CHECKING
 from pydantic import BaseModel, Field, model_validator, computed_field
 
 from chatsky.core.script import Script
@@ -30,6 +31,9 @@
 from chatsky.core.node_label import AbsoluteNodeLabel, AbsoluteNodeLabelInitTypes
 from chatsky.core.script_parsing import JSONImporter, Path
 
+if TYPE_CHECKING:
+    from chatsky.llm.llm_api import LLM_API
+
 logger = logging.getLogger(__name__)
 
 
@@ -78,6 +82,10 @@ class Pipeline(BaseModel, extra="forbid", arbitrary_types_allowed=True):
     """
     Slots configuration.
     """
+    models: Dict[str, LLM_API] = Field(default_factory=dict)
+    """
+    LLM models to be made available in custom functions.
+    """
     messenger_interface: MessengerInterface = Field(default_factory=CLIMessengerInterface)
     """
     A `MessengerInterface` instance for this pipeline.
@@ -116,6 +124,7 @@ def __init__(
         *,
         default_priority: float = None,
         slots: GroupSlot = None,
+        models: dict = None,
         messenger_interface: MessengerInterface = None,
         context_storage: DBContextStorage = None,
         pre_services: ServiceGroupInitTypes = None,
@@ -133,6 +142,7 @@ def __init__(
             "fallback_label": fallback_label,
             "default_priority": default_priority,
             "slots": slots,
+            "models": models,
             "messenger_interface": messenger_interface,
             "context_storage": context_storage,
             "pre_services": pre_services,

chatsky/llm/__init__.py

@@ -0,0 +1,4 @@
+from chatsky.llm.filters import BaseHistoryFilter, FromModel, IsImportant, MessageFilter, Return
+from chatsky.llm.methods import BaseMethod, LogProb, Contains
+from chatsky.llm.llm_api import LLM_API
+from chatsky.llm.prompt import Prompt, PositionConfig

chatsky/llm/_langchain_imports.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+try:
+    from langchain_core.output_parsers import StrOutputParser
+    from langchain_core.language_models.chat_models import BaseChatModel
+    from langchain_core.messages.base import BaseMessage
+    from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
+    from langchain_core.outputs.llm_result import LLMResult
+
+    langchain_available = True
+except ImportError:  # pragma: no cover
+    StrOutputParser = Any
+    BaseChatModel = Any
+    BaseMessage = Any
+    HumanMessage = Any
+    SystemMessage = Any
+    AIMessage = Any
+    LLMResult = Any
+
+    langchain_available = False
+
+
+def check_langchain_available():  # pragma: no cover
+    if not langchain_available:
+        raise ImportError("Langchain is not available. Please install it with `pip install chatsky[llm]`.")

chatsky/llm/filters.py

@@ -0,0 +1,164 @@
+"""
+Filters
+---------
+This module contains a collection of basic functions for history filtering to avoid cluttering LLMs context window.
+"""
+
+import abc
+from enum import Enum
+from logging import Logger
+from typing import Union, Optional
+
+from pydantic import BaseModel
+
+from chatsky.core.message import Message
+from chatsky.core.context import Context
+
+
+logger = Logger(name=__name__)
+
+
+class Return(Enum):
+    """
+    Enum that defines options for filtering turns.
+    """
+
+    NoReturn = 0
+    """
+    Do not include the turn.
+    """
+    Request = 1
+    """
+    Include request only.
+    """
+    Response = 2
+    """
+    Include response only.
+    """
+    Turn = 3
+    """
+    Include the entire turn (both request and response).
+    """
+
+
+class BaseHistoryFilter(BaseModel, abc.ABC):
+    """
+    Base class for all message history filters.
+    """
+
+    @abc.abstractmethod
+    def call(
+        self, ctx: Context, request: Optional[Message], response: Optional[Message], llm_model_name: str
+    ) -> Union[Return, int]:
+        """
+        Decide whether to include request or response or both in the context history from
+        a single turn.
+
+        The filter function is called repeatedly over all turns in context (up to history length limit in
+        :py:func:`~chatsky.llm.langchain_context.context_to_history`) to determine which parts of the turn
+        to include.
+
+        Both request and response may be ``None``. Even if such messages are not filtered out by this filter,
+        they won't be included in history.
+
+        :param ctx: Context object.
+        :param request: Request message.
+        :param response: Response message.
+        :param llm_model_name: Name of the model that calls this filter in the Pipeline.models.
+
+        :return: Instance of Return enum or a corresponding int value.
+        """
+        raise NotImplementedError()
+
+    def __call__(
+        self, ctx: Context, request: Optional[Message], response: Optional[Message], llm_model_name: str
+    ) -> Return:
+        """
+        Wrapper for call that catches exceptions and does not return any turn items if an exception occurs.
+
+        :param ctx: Context object.
+        :param request: Request message.
+        :param response: Response message.
+        :param llm_model_name: Name of the model that calls this filter in the Pipeline.models.
+
+        :return: Instance of Return enum.
+        """
+        try:
+            result = self.call(ctx, request, response, llm_model_name)
+
+            if isinstance(result, int):
+                result = Return(result)
+
+            return result
+        except Exception as exc:
+            logger.warning(exc)
+            return Return.NoReturn
+
+
+class MessageFilter(BaseHistoryFilter):
+    """
+    Variant of history filter that allows to define simple filters that do not
+    differentiate between requests and responses.
+    """
+
+    @abc.abstractmethod
+    def single_message_filter_call(self, ctx: Context, message: Optional[Message], llm_model_name: str) -> bool:
+        """
+        Determine based on a single message (which may be either request or response)
+        whether to include the message in history.
+
+        :param ctx: Context object.
+        :param message: Either request or response message.
+        :param llm_model_name: Name of the model that calls this filter in the Pipeline.models.
+
+        :return: Whether the `message` should be included in history.
+        """
+        raise NotImplementedError()
+
+    def call(
+        self, ctx: Context, request: Optional[Message], response: Optional[Message], llm_model_name: str
+    ) -> Union[Return, int]:
+        return (
+            int(self.single_message_filter_call(ctx, request, llm_model_name)) * Return.Request.value
+            | int(self.single_message_filter_call(ctx, response, llm_model_name)) * Return.Response.value
+        )
+
+
+class DefaultFilter(BaseHistoryFilter):
+    """
+    Filter used by default.
+    Never filters out messages.
+    """
+
+    def call(
+        self, ctx: Context, request: Optional[Message], response: Optional[Message], llm_model_name: str
+    ) -> Union[Return, int]:
+        return Return.Turn
+
+
+class IsImportant(MessageFilter):
+    """
+    Filter that checks if the "important" field in a Message.misc is True.
+    """
+
+    def single_message_filter_call(self, ctx: Context, message: Optional[Message], llm_model_name: str) -> bool:
+        if message is not None and message.misc is not None and message.misc.get("important", None):
+            return True
+        return False
+
+
+class FromModel(BaseHistoryFilter):
+    """
+    Filter that checks if the response of the turn is generated by the currently
+    """
+
+    def call(
+        self, ctx: Context, request: Optional[Message], response: Optional[Message], llm_model_name: str
+    ) -> Union[Return, int]:
+        if (
+            response is not None
+            and response.annotations is not None
+            and response.annotations.get("__generated_by_model__") == llm_model_name
+        ):
+            return Return.Turn
+        return Return.NoReturn